1. #include "StdAfx.h"
2. #include "PythonSkill.h"
4. #include "../EterBase/Poly/Poly.h"
5. #include "../EterPack/EterPackManager.h"
6. #include "InstanceBase.h"
7. #include "PythonPlayer.h"
9. std::map<std::string, DWORD> CPythonSkill::SSkillData::ms_StatusNameMap;
10. std::map<std::string, DWORD> CPythonSkill::SSkillData::ms_NewMinStatusNameMap;
11. std::map<std::string, DWORD> CPythonSkill::SSkillData::ms_NewMaxStatusNameMap;
12. DWORD CPythonSkill::SSkillData::ms_dwTimeIncreaseSkillNumber = 0;
14. BOOL SKILL_EFFECT_UPGRADE_ENABLE = FALSE;
16. int SplitLine(const char * c_szText, CTokenVector* pstTokenVector, const char * c_szDelimeter)
17. {
18. pstTokenVector->reserve(10);
19. pstTokenVector->clear();
21. std::string stToken;
22. std::string stLine = c_szText;
24. DWORD basePos = 0;
26. do
27. {
28. int beginPos = stLine.find_first_not_of(c_szDelimeter, basePos);
30. if (beginPos < 0)
31. return -1;
33. int endPos;
35. if (stLine[beginPos] == '"')
36. {
37. ++beginPos;
38. endPos = stLine.find_first_of("\"", beginPos);
40. if (endPos < 0)
41. return -2;
43. basePos = endPos + 1;
44. }
45. else
46. {
47. endPos = stLine.find_first_of(c_szDelimeter, beginPos);
48. basePos = endPos;
49. }
51. pstTokenVector->push_back(stLine.substr(beginPos, endPos - beginPos));
53. // Ãß°¡ ÄÚµå. ¸ÇµÚ¿¡ ÅÇÀÌ ÀÖ´Â °æ¿ì¸¦ üũÇÑ´Ù. - [levites]
54. if (int(stLine.find_first_not_of(c_szDelimeter, basePos)) < 0)
55. break;
56. } while (basePos < stLine.length());
58. return 0;
59. }
61. // OVERWRITE_SKILLPROTO_POLY
62. void string_replace_word(const char* base, int base_len, const char* src, int src_len, const char* dst, int dst_len, std::string& result)
63. {
64. result.resize(0);
65. if (base_len > 0 && dst_len > src_len)
66. result.reserve(base_len + (dst_len-src_len) * (base_len/src_len));
67. else
68. result.reserve(base_len);
70. int prev = 0;
71. int cur = 0;
72. while (cur < base_len)
73. {
74. if (memcmp(base + cur, src, src_len) == 0)
75. {
76. result.append(base + prev, cur - prev);
77. result.append(dst, dst_len);
78. cur += src_len;
79. prev = cur;
80. }
81. else
82. {
83. ++cur;
84. }
85. }
86. result.append(base + prev, cur - prev);
87. }
88. // END_OF_OVERWRITE_SKILLPROTO_POLY
90. bool CPythonSkill::RegisterSkillTable(const char * c_szFileName)
91. {
92. const VOID* pvData;
93. CMappedFile kFile;
94. if (!CEterPackManager::Instance().Get(kFile, c_szFileName, &pvData))
95. return false;
97. CMemoryTextFileLoader textFileLoader;
98. textFileLoader.Bind(kFile.Size(), pvData);
100. // OVERWRITE_SKILLPROTO_POLY
101. string src_poly_rand;
102. string src_poly_atk;
103. string src_poly_mwep;
104. // END_OF_OVERWRITE_SKILLPROTO_POLY
106. CTokenVector TokenVector;
107. for (DWORD i = 0; i < textFileLoader.GetLineCount(); ++i)
108. {
109. if (!textFileLoader.SplitLineByTab(i, &TokenVector))
110. continue;
112. std::string strLine = textFileLoader.GetLineString(i);
114. if (TABLE_TOKEN_TYPE_MAX_NUM != TokenVector.size())
115. {
116. Tracef("CPythonSkill::RegisterSkillTable(%s) - Strange Token Count [Line:%d / TokenCount:%d]\n", c_szFileName, i, TokenVector.size());
117. continue;
118. }
120. int iVnum = atoi(TokenVector[TABLE_TOKEN_TYPE_VNUM].c_str());
122. TSkillDataMap::iterator itor = m_SkillDataMap.find(iVnum);
123. if (m_SkillDataMap.end() == itor)
124. {
125. Tracef("CPythonSkill::RegisterSkillTable(%s) - NOT EXIST SkillDesc [Vnum:%d Line:%d]\n", c_szFileName, iVnum, i);
126. continue;
127. }
129. TSkillData & rSkillData = itor->second;
131. const std::string & c_strSPCostPoly = TokenVector[TABLE_TOKEN_TYPE_SP_COST_POLY];
132. if (!c_strSPCostPoly.empty())
133. {
134. rSkillData.strNeedSPFormula = c_strSPCostPoly;
135. }
137. const std::string & c_strCooldownPoly = TokenVector[TABLE_TOKEN_TYPE_COOLDOWN_POLY];
138. if (!c_strCooldownPoly.empty())
139. {
140. rSkillData.strCoolTimeFormula = c_strCooldownPoly;
141. }
143. const std::string & c_strDurationSPCostPoly = TokenVector[TABLE_TOKEN_TYPE_DURATION_SP_COST_POLY];
144. if (!c_strDurationSPCostPoly.empty())
145. {
146. rSkillData.strContinuationSPFormula = c_strDurationSPCostPoly;
147. }
149. const std::string & c_strTargetRange = TokenVector[TABLE_TOKEN_TYPE_TARGET_RANGE];
150. if (!c_strTargetRange.empty())
151. {
152. rSkillData.dwTargetRange = atoi(c_strTargetRange.c_str());
153. }
155. rSkillData.strDuration = TokenVector[TABLE_TOKEN_TYPE_DURATION_POLY];
158. const DWORD LevelEmpty = 1;
160. const std::string & c_strMaxLevel = TokenVector[TABLE_TOKEN_TYPE_MAX_LEVEL];
161. if (!c_strMaxLevel.empty())
162. {
163. int maxLevel = atoi(c_strMaxLevel.c_str());
164. if(maxLevel > LevelEmpty)
165. rSkillData.byMaxLevel = maxLevel;
166. }
168. const std::string & c_strLevelLimit = TokenVector[TABLE_TOKEN_TYPE_LEVEL_LIMIT];
169. if (!c_strLevelLimit.empty())
170. {
171. int levelLimit = atoi(c_strLevelLimit.c_str());
172. if(rSkillData.byLevelLimit > LevelEmpty)
173. rSkillData.byLevelLimit = levelLimit;
174. }
175. const std::string & c_strPointPoly = TokenVector[TABLE_TOKEN_TYPE_POINT_POLY];
177. // OVERWRITE_SKILLPROTO_POLY
178. bool USE_SKILL_PROTO = LocaleService_IsCHEONMA() ? false : true;
180. switch (iVnum)
181. {
182. case 34:
184. // GUILD_SKILL_DISPLAY_BUG_FIX
185. case 151:
186. case 152:
187. case 153:
188. case 154:
189. case 155:
190. case 156:
191. case 157:
192. // END_OF_GUILD_SKILL_DISPLAY_BUG_FIX
193. USE_SKILL_PROTO = false;
194. break;
195. }
197. if (!rSkillData.AffectDataVector.empty() && USE_SKILL_PROTO)
198. {
199. TAffectData& affect = rSkillData.AffectDataVector[0];
201. if (strstr(c_strPointPoly.c_str(), "atk") != NULL ||
202. strstr(c_strPointPoly.c_str(), "mwep") != NULL ||
203. strstr(c_strPointPoly.c_str(), "number") != NULL)
204. {
205. src_poly_rand = "";
206. src_poly_atk = "";
207. src_poly_mwep = "";
209. // MIN
210. string_replace_word(c_strPointPoly.c_str(), c_strPointPoly.length(),
211. "number", 6, "min", 3, src_poly_rand);
212. string_replace_word(src_poly_rand.c_str(), src_poly_rand.length(),
213. "atk", 3, "minatk", 6, src_poly_atk);
214. string_replace_word(src_poly_atk.c_str(), src_poly_atk.length(),
215. "mwep", 4, "minmwep", 7, affect.strAffectMinFormula);
216. // END_OF_MIN
218. // MAX
219. string_replace_word(c_strPointPoly.c_str(), c_strPointPoly.length(),
220. "number", 6, "max", 3, src_poly_rand);
221. string_replace_word(src_poly_rand.c_str(), src_poly_rand.length(),
222. "atk", 3, "maxatk", 6, src_poly_atk);
223. string_replace_word(src_poly_atk.c_str(), src_poly_atk.length(),
224. "mwep", 4, "maxmwep", 7, affect.strAffectMaxFormula);
225. // END_OF_MAX
227. switch (iVnum)
228. {
229. case 1: // »ï¿¬Âü
230. affect.strAffectMinFormula += "* 3";
231. affect.strAffectMaxFormula += "* 3";
232. break;
233. }
235. }
236. else
237. {
238. affect.strAffectMinFormula = c_strPointPoly;
239. affect.strAffectMaxFormula = "";
240. }
241. }
242. // END_OF_OVERWRITE_SKILLPROTO_POLY
243. }
245. return true;
246. }
248. void CPythonSkill::__RegisterGradeIconImage(TSkillData & rData, const char * c_szHeader, const char * c_szImageName)
249. {
250. for (int j = 0; j < SKILL_GRADE_COUNT; ++j)
251. {
252. TGradeData & rGradeData = rData.GradeData[j];
254. char szCount[8+1];
255. _snprintf_s(szCount, sizeof(szCount), "_%02d", j+1);
257. std::string strFileName = "";
258. strFileName += c_szHeader;
259. strFileName += c_szImageName;
260. strFileName += szCount;
261. strFileName += ".sub";
262. rGradeData.pImage = (CGraphicImage *)CResourceManager::Instance().GetResourcePointer(strFileName.c_str());
263. }
264. }
266. void CPythonSkill::__RegisterNormalIconImage(TSkillData & rData, const char * c_szHeader, const char * c_szImageName)
267. {
268. std::string strFileName = "";
269. strFileName += c_szHeader;
270. strFileName += c_szImageName;
271. strFileName += ".sub";
272. rData.pImage = (CGraphicImage *)CResourceManager::Instance().GetResourcePointer(strFileName.c_str());
273. for (int j = 0; j < SKILL_GRADE_COUNT; ++j)
274. {
275. TGradeData & rGradeData = rData.GradeData[j];
276. rGradeData.pImage = rData.pImage;
277. }
278. }
279. extern const DWORD c_iSkillIndex_Riding;
280. bool CPythonSkill::RegisterSkillDesc(const char * c_szFileName)
281. {
282. const VOID* pvData;
283. CMappedFile kFile;
284. if (!CEterPackManager::Instance().Get(kFile, c_szFileName, &pvData))
285. return false;
287. CMemoryTextFileLoader textFileLoader;
288. textFileLoader.Bind(kFile.Size(), pvData);
290. CTokenVector TokenVector;
291. for (DWORD i = 0; i < textFileLoader.GetLineCount(); ++i)
292. {
293. if (!textFileLoader.SplitLineByTab(i, &TokenVector))
294. continue;
296. if (DESC_TOKEN_TYPE_VNUM >= TokenVector.size())
297. {
298. TraceError("SkillDesc.line(%d).NO_VNUM_ERROR\n", i + 1);
299. continue;
300. }
302. DWORD iSkillIndex = atoi(TokenVector[DESC_TOKEN_TYPE_VNUM].c_str());
303. if (iSkillIndex == 0)
304. {
305. TraceError("SkillDesc.line(%d).NO_INDEX_ERROR\n", i + 1);
306. continue;
307. }
309. if (DESC_TOKEN_TYPE_JOB >= TokenVector.size())
310. {
311. TraceError("SkillDesc.line(%d).NO_JOB_ERROR\n", i + 1);
312. continue;
313. }
315. m_SkillDataMap.insert(make_pair(iSkillIndex, TSkillData()));
316. TSkillData & rSkillData = m_SkillDataMap[iSkillIndex];
318. // Vnum
319. rSkillData.dwSkillIndex = iSkillIndex;
321. // Type
322. {
323. std::string strJob = TokenVector[DESC_TOKEN_TYPE_JOB];
324. stl_lowers(strJob);
326. std::map<std::string, DWORD>::iterator it = m_SkillTypeIndexMap.find(strJob.c_str());
327. if (m_SkillTypeIndexMap.end() == it)
328. {
329. TraceError("CPythonSkill::RegisterSkillDesc(dwSkillIndex=%d, strType=%s).STRANGE_SKILL_TYPE", iSkillIndex, strJob.c_str());
330. continue;
331. }
333. rSkillData.byType = BYTE(it->second);
334. }
336. // Name
337. {
338. rSkillData.strName = TokenVector[DESC_TOKEN_TYPE_NAME1];
339. rSkillData.GradeData[0].strName = TokenVector[DESC_TOKEN_TYPE_NAME1];
340. rSkillData.GradeData[1].strName = TokenVector[DESC_TOKEN_TYPE_NAME2];
341. rSkillData.GradeData[2].strName = TokenVector[DESC_TOKEN_TYPE_NAME3];
343. if (rSkillData.GradeData[1].strName.empty())
344. rSkillData.GradeData[1].strName = TokenVector[DESC_TOKEN_TYPE_NAME1];
345. if (rSkillData.GradeData[2].strName.empty())
346. rSkillData.GradeData[2].strName = TokenVector[DESC_TOKEN_TYPE_NAME1];
347. }
349. // Description
350. {
351. rSkillData.strDescription = TokenVector[DESC_TOKEN_TYPE_DESCRIPTION];
352. }
354. // Condition
355. {
356. rSkillData.ConditionDataVector.clear();
357. for (int j = 0; j < CONDITION_COLUMN_COUNT; ++j)
358. {
359. const std::string & c_rstrCondition = TokenVector[DESC_TOKEN_TYPE_CONDITION1+j];
360. if (!c_rstrCondition.empty())
361. rSkillData.ConditionDataVector.push_back(c_rstrCondition);
362. }
363. }
365. // Attribute
366. {
367. const std::string & c_rstrAttribute = TokenVector[DESC_TOKEN_TYPE_ATTRIBUTE];
368. CTokenVector AttributeTokenVector;
369. SplitLine(c_rstrAttribute.c_str(), &AttributeTokenVector, "|");
371. for (CTokenVector::iterator it = AttributeTokenVector.begin(); it != AttributeTokenVector.end(); ++it)
372. {
373. std::string & rstrToken = *it;
374. std::map<std::string, DWORD>::iterator it2 = m_SkillAttributeIndexMap.find(rstrToken);
375. if (m_SkillAttributeIndexMap.end() == it2)
376. {
377. TraceError("CPythonSkill::RegisterSkillDesc(dwSkillIndex=%d) - Strange Skill Attribute(%s)", iSkillIndex, rstrToken.c_str());
378. continue;
379. }
380. rSkillData.dwSkillAttribute |= it2->second;
381. }
382. }
384. // Weapon
385. {
386. const std::string & c_rstrWeapon = TokenVector[DESC_TOKEN_TYPE_WEAPON];
387. CTokenVector WeaponTokenVector;
388. SplitLine(c_rstrWeapon.c_str(), &WeaponTokenVector, "|");
390. for (CTokenVector::iterator it = WeaponTokenVector.begin(); it != WeaponTokenVector.end(); ++it)
391. {
392. std::string & rstrToken = *it;
393. std::map<std::string, DWORD>::iterator it2 = m_SkillNeedWeaponIndexMap.find(rstrToken);
394. if (m_SkillNeedWeaponIndexMap.end() == it2)
395. {
396. TraceError("CPythonSkill::RegisterSkillDesc(dwSkillIndex=%d) - Strange Skill Need Weapon(%s)", iSkillIndex, rstrToken.c_str());
397. continue;
398. }
399. rSkillData.dwNeedWeapon |= it2->second;
400. }
401. }
403. // Icon Name
404. {
405. const std::string & c_rstrJob = TokenVector[DESC_TOKEN_TYPE_JOB];
406. const std::string & c_rstrIconName = TokenVector[DESC_TOKEN_TYPE_ICON_NAME];
408. // NOTE : Support ½ºÅ³ÀÓ¿¡µµ 3´Ü°è¸¦ Áö¿øÇØ¾ß Çؼ­ ¿¹¿Ü ó¸® - [levites]
409. if (c_iSkillIndex_Riding == iSkillIndex)
410. {
411. char szIconFileNameHeader[64+1];
412. _snprintf_s(szIconFileNameHeader, sizeof(szIconFileNameHeader), "%sskill/common/support/", g_strImagePath.c_str());
414. __RegisterGradeIconImage(rSkillData, szIconFileNameHeader, c_rstrIconName.c_str());
415. }
416. else if (m_PathNameMap.end() != m_PathNameMap.find(c_rstrJob))
417. {
418. char szIconFileNameHeader[64+1];
419. _snprintf_s(szIconFileNameHeader, sizeof(szIconFileNameHeader), "%sskill/%s/", g_strImagePath.c_str(), m_PathNameMap[c_rstrJob].c_str());
421. switch (rSkillData.byType)
422. {
423. case SKILL_TYPE_ACTIVE:
424. {
425. __RegisterGradeIconImage(rSkillData, szIconFileNameHeader, c_rstrIconName.c_str());
426. break;
427. }
428. case SKILL_TYPE_SUPPORT:
429. case SKILL_TYPE_GUILD:
430. case SKILL_TYPE_HORSE:
431. {
432. __RegisterNormalIconImage(rSkillData, szIconFileNameHeader, c_rstrIconName.c_str());
433. break;
434. }
435. }
436. }
437. }
439. // Motion Index
440. if (TokenVector.size() > DESC_TOKEN_TYPE_MOTION_INDEX)
441. {
442. const std::string & c_rstrMotionIndex = TokenVector[DESC_TOKEN_TYPE_MOTION_INDEX];
443. if (c_rstrMotionIndex.empty())
444. {
445. rSkillData.bNoMotion = TRUE;
446. rSkillData.wMotionIndex = 0;
447. }
448. else
449. {
450. rSkillData.bNoMotion = FALSE;
451. rSkillData.wMotionIndex = (WORD)atoi(c_rstrMotionIndex.c_str());
452. }
453. }
454. else
455. {
456. rSkillData.wMotionIndex = 0;
457. }
459. if (TokenVector.size() > DESC_TOKEN_TYPE_TARGET_COUNT_FORMULA)
460. rSkillData.strTargetCountFormula = TokenVector[DESC_TOKEN_TYPE_TARGET_COUNT_FORMULA].c_str();
461. if (TokenVector.size() > DESC_TOKEN_TYPE_MOTION_LOOP_COUNT_FORMULA)
462. rSkillData.strMotionLoopCountFormula = TokenVector[DESC_TOKEN_TYPE_MOTION_LOOP_COUNT_FORMULA].c_str();
464. rSkillData.AffectDataNewVector.clear();
465. rSkillData.AffectDataNewVector.reserve(3);
467. // Affect
468. for (int j = 0; j < AFFECT_COLUMN_COUNT; ++j)
469. {
470. int iDescriptionSlotIndex = DESC_TOKEN_TYPE_AFFECT_DESCRIPTION_1 + j*AFFECT_STEP_COUNT;
471. int iMinSlotIndex = DESC_TOKEN_TYPE_AFFECT_MIN_1 + j*AFFECT_STEP_COUNT;
472. int iMaxSlotIndex = DESC_TOKEN_TYPE_AFFECT_MAX_1 + j*AFFECT_STEP_COUNT;
474. if (TokenVector.size() > iDescriptionSlotIndex)
475. if (!TokenVector[iDescriptionSlotIndex].empty())
476. {
477. rSkillData.AffectDataVector.push_back(TAffectData());
479. TAffectData & rAffectData = *rSkillData.AffectDataVector.rbegin();
480. rAffectData.strAffectDescription = "";
481. rAffectData.strAffectMinFormula = "";
482. rAffectData.strAffectMaxFormula = "";
484. rAffectData.strAffectDescription = TokenVector[iDescriptionSlotIndex];
485. if (TokenVector.size() > iMinSlotIndex)
486. if (!TokenVector[iMinSlotIndex].empty())
487. rAffectData.strAffectMinFormula = TokenVector[iMinSlotIndex];
488. if (TokenVector.size() > iMaxSlotIndex)
489. if (!TokenVector[iMaxSlotIndex].empty())
490. rAffectData.strAffectMaxFormula = TokenVector[iMaxSlotIndex];
491. }
492. }
494. if (TokenVector.size() > DESC_TOKEN_TYPE_MOTION_INDEX_GRADE_NUM)
495. {
496. int numGrade = atoi(TokenVector[DESC_TOKEN_TYPE_MOTION_INDEX_GRADE_NUM].c_str());
497. if (SKILL_EFFECT_COUNT < numGrade)
498. {
499. TraceError("%s[%s] °¡ µî±Ş Á¦ÇÑ[%d]À» ³Ñ¾î°¬½À´Ï´Ù.",rSkillData.strName.c_str(), TokenVector[DESC_TOKEN_TYPE_MOTION_INDEX_GRADE_NUM].c_str(), SKILL_EFFECT_COUNT);
500. return false;
501. }
502. for (int iGrade = 0; iGrade < numGrade; iGrade++)
503. {
504. //if (iGrade == SKILL_GRADE_COUNT)
505. // rSkillData.GradeData[iGrade] = rSkillData.GradeData[iGrade-1];
506. rSkillData.GradeData[iGrade].wMotionIndex = rSkillData.wMotionIndex+iGrade*SKILL_GRADEGAP;
507. }
508. for(int iSpace = numGrade; iSpace < SKILL_EFFECT_COUNT; iSpace++)
509. {
510. rSkillData.GradeData[iSpace].wMotionIndex = rSkillData.wMotionIndex;
511. }
512. }
514. if (TokenVector.size() > DESC_TOKEN_TYPE_LEVEL_LIMIT)
515. {
516. const std::string & c_rstrLevelLimit = TokenVector[DESC_TOKEN_TYPE_LEVEL_LIMIT];
517. if (c_rstrLevelLimit.empty())
518. rSkillData.byLevelLimit = 0;
519. else
520. rSkillData.byLevelLimit = (WORD)atoi(c_rstrLevelLimit.c_str());
521. }
523. if (TokenVector.size() > DESC_TOKEN_TYPE_MAX_LEVEL)
524. {
525. const std::string & c_rstrMaxLevel = TokenVector[DESC_TOKEN_TYPE_MAX_LEVEL];
526. const DWORD LevelLimitEmpty = 1;
527. if (c_rstrMaxLevel.empty())
528. {
529. if(rSkillData.byLevelLimit > LevelLimitEmpty)
530. rSkillData.byMaxLevel = rSkillData.byLevelLimit;
531. else
532. rSkillData.byMaxLevel = 20;
533. }
534. else
535. rSkillData.byMaxLevel = (BYTE)atoi(c_rstrMaxLevel.c_str());
536. }
537. }
539. return true;
540. }
542. void CPythonSkill::Destroy()
543. {
544. m_SkillDataMap.clear();
545. }
547. bool CPythonSkill::RegisterSkill(DWORD dwSkillIndex, const char * c_szFileName)
548. {
549. CTextFileLoader TextFileLoader;
550. if (!TextFileLoader.Load(c_szFileName))
551. {
552. TraceError("CPythonSkill::RegisterSkill(dwSkillIndex=%d, c_szFileName=%s) - Failed to find file", dwSkillIndex, c_szFileName);
553. return false;
554. }
556. TextFileLoader.SetTop();
558. TSkillData SkillData;
559. SkillData.dwSkillIndex = dwSkillIndex;
561. std::string strTypeName;
562. if (TextFileLoader.GetTokenString("type", &strTypeName))
563. {
564. stl_lowers(strTypeName);
565. std::map<std::string, DWORD>::iterator it = m_SkillTypeIndexMap.find(strTypeName.c_str());
566. if (m_SkillTypeIndexMap.end() == it)
567. {
568. TraceError("Strange Skill Type - CPythonSkill::RegisterSkill(dwSkillIndex=%d, c_szFileName=%s)", dwSkillIndex, c_szFileName);
569. return false;
570. }
572. SkillData.byType = (BYTE)it->second;
573. }
574. else
575. {
576. TraceError("CPythonSkill::RegisterSkill(dwSkillIndex=%d, c_szFileName=%s) - Failed to find key [type]", dwSkillIndex, c_szFileName);
577. return false;
578. }
580. CTokenVector * pAttributeTokenVector;
581. if (TextFileLoader.GetTokenVector("attribute", &pAttributeTokenVector))
582. {
583. for (CTokenVector::iterator it = pAttributeTokenVector->begin(); it != pAttributeTokenVector->end(); ++it)
584. {
585. std::string & rstrToken = *it;
586. std::map<std::string, DWORD>::iterator it2 = m_SkillAttributeIndexMap.find(rstrToken.c_str());
587. if (m_SkillAttributeIndexMap.end() == it2)
588. {
589. TraceError("Strange Skill Attribute - CPythonSkill::RegisterSkill(dwSkillIndex=%d, c_szFileName=%s)", dwSkillIndex, c_szFileName);
590. continue;
591. }
592. SkillData.dwSkillAttribute |= it2->second;
593. }
594. }
596. CTokenVector * pNeedWeaponVector;
597. if (TextFileLoader.GetTokenVector("needweapon", &pNeedWeaponVector))
598. {
599. for (CTokenVector::iterator it = pNeedWeaponVector->begin(); it != pNeedWeaponVector->end(); ++it)
600. {
601. std::string & rstrToken = *it;
602. std::map<std::string, DWORD>::iterator it2 = m_SkillNeedWeaponIndexMap.find(rstrToken.c_str());
603. if (m_SkillNeedWeaponIndexMap.end() == it2)
604. {
605. TraceError("Strange Skill Need Weapon - CPythonSkill::RegisterSkill(dwSkillIndex=%d, c_szFileName=%s)", dwSkillIndex, c_szFileName);
606. continue;
607. }
608. SkillData.dwNeedWeapon |= it2->second;
609. }
610. }
612. {
613. char szName[256];
614. snprintf_s(szName, "%dname", LocaleService_GetCodePage());
615. if (!TextFileLoader.GetTokenString(szName, &SkillData.strName))
616. if (!TextFileLoader.GetTokenString("name", &SkillData.strName))
617. {
618. TraceError("CPythonSkill::RegisterSkill(dwSkillIndex=%d, c_szFileName=%s) - Failed to find [%s]", dwSkillIndex, c_szFileName, szName);
619. return false;
620. }
621. }
623. {
624. char szName[256];
625. snprintf_s(szName, "%ddescription", LocaleService_GetCodePage());
626. if (!TextFileLoader.GetTokenString(szName, &SkillData.strDescription))
627. TextFileLoader.GetTokenString("description", &SkillData.strDescription);
628. }
630. if (!TextFileLoader.GetTokenString("iconfilename", &SkillData.strIconFileName))
631. {
632. TraceError("CPythonSkill::RegisterSkill(dwSkillIndex=%d, c_szFileName=%s) - Failed to find [iconfilename]", dwSkillIndex, c_szFileName);
633. return false;
634. }
636. {
637. CTokenVector * pConditionDataVector;
639. char szConditionData[256];
640. snprintf_s(szConditionData, "%dconditiondata", LocaleService_GetCodePage());
642. bool isConditionData=true;
643. if (!TextFileLoader.GetTokenVector(szConditionData, &pConditionDataVector))
644. if (!TextFileLoader.GetTokenVector("conditiondata", &pConditionDataVector))
645. isConditionData=false;
647. if (isConditionData)
648. {
649. DWORD dwSize = pConditionDataVector->size();
650. SkillData.ConditionDataVector.clear();
651. SkillData.ConditionDataVector.resize(dwSize);
652. for (DWORD i = 0; i < dwSize; ++i)
653. {
654. SkillData.ConditionDataVector[i] = pConditionDataVector->at(i);
655. }
656. }
657. }
659. {
660. CTokenVector * pAffectDataVector;
662. char szAffectData[256];
663. snprintf_s(szAffectData, "%daffectdata", LocaleService_GetCodePage());
665. bool isAffectData=true;
666. if (!TextFileLoader.GetTokenVector(szAffectData, &pAffectDataVector))
667. if (!TextFileLoader.GetTokenVector("affectdata", &pAffectDataVector))
668. isAffectData=false;
670. if (isAffectData)
671. {
672. DWORD dwSize = pAffectDataVector->size()/3;
673. SkillData.AffectDataVector.clear();
674. SkillData.AffectDataVector.resize(dwSize);
675. for (DWORD i = 0; i < dwSize; ++i)
676. {
677. SkillData.AffectDataVector[i].strAffectDescription = pAffectDataVector->at(i*3+0);
678. SkillData.AffectDataVector[i].strAffectMinFormula = pAffectDataVector->at(i*3+1);
679. SkillData.AffectDataVector[i].strAffectMaxFormula = pAffectDataVector->at(i*3+2);
680. }
681. }
682. }
684. {
685. CTokenVector * pGradeDataVector;
687. char szGradeData[256];
688. snprintf_s(szGradeData, "%dgradedata", LocaleService_GetCodePage());
690. if (TextFileLoader.GetTokenVector(szGradeData, &pGradeDataVector))
691. {
692. if (SKILL_GRADE_COUNT*2 != pGradeDataVector->size())
693. TraceError("CPythonSkill::RegisterSkill(dwSkillIndex=%d, c_szFileName=%s) - Strange Grade Data Count", dwSkillIndex, c_szFileName);
695. for (DWORD i = 0; i < min(SKILL_GRADE_COUNT, pGradeDataVector->size()/2); ++i)
696. {
697. SkillData.GradeData[i].strName = pGradeDataVector->at(i*2+0);
698. std::string strIconFileName = g_strImagePath + pGradeDataVector->at(i*2+1);
699. SkillData.GradeData[i].pImage = (CGraphicImage *)CResourceManager::Instance().GetResourcePointer(strIconFileName.c_str());
700. }
701. }
702. }
704. TextFileLoader.GetTokenString("cooltimeformula", &SkillData.strCoolTimeFormula);
705. TextFileLoader.GetTokenString("targetcountformula", &SkillData.strTargetCountFormula);
706. TextFileLoader.GetTokenString("motionloopcountformula", &SkillData.strMotionLoopCountFormula);
707. TextFileLoader.GetTokenString("needspformula", &SkillData.strNeedSPFormula);
708. TextFileLoader.GetTokenString("continuationspformula", &SkillData.strContinuationSPFormula);
709. TextFileLoader.GetTokenDoubleWord("range", &SkillData.dwTargetRange);
710. TextFileLoader.GetTokenByte("maxlevel", &SkillData.byMaxLevel);
711. TextFileLoader.GetTokenByte("leveluppoint", &SkillData.byLevelUpPoint);
713. WORD wMotionIndex;
714. if (TextFileLoader.GetTokenWord("motionindex", &wMotionIndex))
715. {
716. SkillData.wMotionIndex = wMotionIndex;
717. }
718. else
719. {
720. SkillData.wMotionIndex = 0;
721. }
723. WORD wMotionIndexForMe;
724. if (TextFileLoader.GetTokenWord("motionindexforme", &wMotionIndexForMe))
725. {
726. SkillData.wMotionIndexForMe = wMotionIndexForMe;
727. }
728. else
729. {
730. SkillData.wMotionIndexForMe = 0;
731. }
733. SkillData.strIconFileName = g_strImagePath + SkillData.strIconFileName;
734. SkillData.pImage = (CGraphicImage *)CResourceManager::Instance().GetResourcePointer(SkillData.strIconFileName.c_str());
736. m_SkillDataMap.insert(TSkillDataMap::value_type(dwSkillIndex, SkillData));
738. /////
740. if (SkillData.IsTimeIncreaseSkill())
741. {
742. CPythonSkill::SSkillData::ms_dwTimeIncreaseSkillNumber = SkillData.dwSkillIndex;
743. }
745. return true;
746. }
748. BOOL CPythonSkill::GetSkillData(DWORD dwSkillIndex, TSkillData ** ppSkillData)
749. {
750. TSkillDataMap::iterator it = m_SkillDataMap.find(dwSkillIndex);
752. if (m_SkillDataMap.end() == it)
753. return FALSE;
755. *ppSkillData = &(it->second);
756. return TRUE;
757. }
759. bool CPythonSkill::GetSkillDataByName(const char * c_szName, TSkillData ** ppSkillData)
760. {
761. TSkillDataMap::iterator itor = m_SkillDataMap.begin();
762. for (; itor != m_SkillDataMap.end(); ++itor)
763. {
764. TSkillData * pData = &(itor->second);
765. if (0 == pData->strName.compare(c_szName))
766. {
767. *ppSkillData = &(itor->second);
768. return true;
769. }
770. }
771. return false;
772. }
774. void CPythonSkill::SetPathName(const char * c_szFileName)
775. {
776. m_strPathName = c_szFileName;
777. }
779. const char * CPythonSkill::GetPathName()
780. {
781. return m_strPathName.c_str();
782. }
784. void CPythonSkill::TEST()
785. {
786. BOOL isFirst;
787. std::map<std::string, DWORD>::iterator itorSub;
789. FILE * File = fopen("test.txt", "w");
791. for (TSkillDataMap::iterator itor = m_SkillDataMap.begin(); itor != m_SkillDataMap.end(); ++itor)
792. {
793. TSkillData & rSkillData = itor->second;
795. std::string strLine = "";
796. strLine += rSkillData.strName.c_str();
797. strLine += "\t";
798. // Name2
799. strLine += "\t";
800. // Name3
801. strLine += "\t";
802. strLine += rSkillData.strDescription;
803. strLine += "\t";
804. if (rSkillData.ConditionDataVector.size() > 0)
805. strLine += rSkillData.ConditionDataVector[0];
806. strLine += "\t";
807. if (rSkillData.ConditionDataVector.size() > 1)
808. strLine += rSkillData.ConditionDataVector[1];
809. strLine += "\t";
810. if (rSkillData.ConditionDataVector.size() > 2)
811. strLine += rSkillData.ConditionDataVector[2];
812. strLine += "\t";
813. if (rSkillData.ConditionDataVector.size() > 3)
814. strLine += rSkillData.ConditionDataVector[3];
816. strLine += "\t";
817. isFirst = TRUE;
818. for (itorSub = m_SkillAttributeIndexMap.begin(); itorSub != m_SkillAttributeIndexMap.end(); ++itorSub)
819. {
820. if (itorSub->second & rSkillData.dwSkillAttribute)
821. {
822. if (isFirst)
823. {
824. isFirst = FALSE;
825. }
826. else
827. {
828. strLine += "|";
829. }
830. strLine += itorSub->first.c_str();
831. }
832. }
834. strLine += "\t";
835. isFirst = TRUE;
836. for (itorSub = m_SkillNeedWeaponIndexMap.begin(); itorSub != m_SkillNeedWeaponIndexMap.end(); ++itorSub)
837. {
838. if (itorSub->second & rSkillData.dwNeedWeapon)
839. {
840. if (isFirst)
841. {
842. isFirst = FALSE;
843. }
844. else
845. {
846. strLine += "|";
847. }
848. strLine += itorSub->first.c_str();
849. }
850. }
852. strLine += "\t";
853. std::string strFileName = rSkillData.strIconFileName;
854. int iPos = strFileName.find_last_of("/", rSkillData.strIconFileName.length());
855. if (iPos > 0)
856. strFileName = strFileName.substr(iPos+1, strFileName.length() - iPos - 4 - 1);
857. strLine += strFileName;
859. strLine += "\t";
860. char szMotionIndex[32+1];
861. _snprintf_s(szMotionIndex, sizeof(szMotionIndex), "%d", rSkillData.wMotionIndex);
862. strLine += szMotionIndex;
864. strLine += "\t";
865. if (rSkillData.wMotionIndexForMe > 1)
866. {
867. char szMotionIndexForMe[32+1];
868. _snprintf_s(szMotionIndexForMe, sizeof(szMotionIndexForMe), "%d", rSkillData.wMotionIndexForMe);
869. strLine += szMotionIndexForMe;
870. }
872. assert(rSkillData.AffectDataVector.size() <= 3);
873. strLine += "\t";
874. if (rSkillData.AffectDataVector.size() > 0)
875. {
876. strLine += rSkillData.AffectDataVector[0].strAffectDescription;
877. strLine += "\t";
878. strLine += rSkillData.AffectDataVector[0].strAffectMinFormula;
879. strLine += "\t";
880. strLine += rSkillData.AffectDataVector[0].strAffectMaxFormula;
881. }
882. strLine += "\t";
883. if (rSkillData.AffectDataVector.size() > 1)
884. {
885. strLine += rSkillData.AffectDataVector[1].strAffectDescription;
886. strLine += "\t";
887. strLine += rSkillData.AffectDataVector[1].strAffectMinFormula;
888. strLine += "\t";
889. strLine += rSkillData.AffectDataVector[1].strAffectMaxFormula;
890. }
891. strLine += "\t";
892. if (rSkillData.AffectDataVector.size() > 2)
893. {
894. strLine += rSkillData.AffectDataVector[2].strAffectDescription;
895. strLine += "\t";
896. strLine += rSkillData.AffectDataVector[2].strAffectMinFormula;
897. strLine += "\t";
898. strLine += rSkillData.AffectDataVector[2].strAffectMaxFormula;
899. }
901. fprintf(File, "%s\n", strLine.c_str());
902. }
904. fclose(File);
905. }
907. CPythonSkill::CPythonSkill()
908. {
909. m_SkillTypeIndexMap.insert(std::map<std::string, DWORD>::value_type("none", SKILL_TYPE_NONE));
910. m_SkillTypeIndexMap.insert(std::map<std::string, DWORD>::value_type("active", SKILL_TYPE_ACTIVE));
911. m_SkillTypeIndexMap.insert(std::map<std::string, DWORD>::value_type("support", SKILL_TYPE_SUPPORT));
912. m_SkillTypeIndexMap.insert(std::map<std::string, DWORD>::value_type("guild", SKILL_TYPE_GUILD));
913. m_SkillTypeIndexMap.insert(std::map<std::string, DWORD>::value_type("horse", SKILL_TYPE_HORSE));
914. m_SkillTypeIndexMap.insert(std::map<std::string, DWORD>::value_type("warrior", SKILL_TYPE_ACTIVE));
915. m_SkillTypeIndexMap.insert(std::map<std::string, DWORD>::value_type("assassin", SKILL_TYPE_ACTIVE));
916. m_SkillTypeIndexMap.insert(std::map<std::string, DWORD>::value_type("sura", SKILL_TYPE_ACTIVE));
917. m_SkillTypeIndexMap.insert(std::map<std::string, DWORD>::value_type("shaman", SKILL_TYPE_ACTIVE));
918. m_SkillTypeIndexMap.insert(std::map<std::string, DWORD>::value_type("passive", SKILL_TYPE_ACTIVE));
920. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("NEED_POISON_BOTTLE", SKILL_ATTRIBUTE_NEED_POISON_BOTTLE));
921. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("NEED_EMPTY_BOTTLE", SKILL_ATTRIBUTE_NEED_EMPTY_BOTTLE));
922. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("CAN_USE_IF_NOT_ENOUGH", SKILL_ATTRIBUTE_CAN_USE_IF_NOT_ENOUGH));
923. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("FAN_RANGE", SKILL_ATTRIBUTE_FAN_RANGE));
924. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("NEED_CORPSE", SKILL_ATTRIBUTE_NEED_CORPSE));
925. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("NEED_TARGET", SKILL_ATTRIBUTE_NEED_TARGET));
926. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("TOGGLE", SKILL_ATTRIBUTE_TOGGLE));
927. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("WEAPON_LIMITATION", SKILL_ATTRIBUTE_WEAPON_LIMITATION));
928. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("MELEE_ATTACK", SKILL_ATTRIBUTE_MELEE_ATTACK));
929. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("CHARGE_ATTACK", SKILL_ATTRIBUTE_CHARGE_ATTACK));
930. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("USE_HP", SKILL_ATTRIBUTE_USE_HP));
931. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("CAN_CHANGE_DIRECTION", SKILL_ATTRIBUTE_CAN_CHANGE_DIRECTION));
932. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("STANDING_SKILL", SKILL_ATTRIBUTE_STANDING_SKILL));
933. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("ONLY_FOR_ALLIANCE", SKILL_ATTRIBUTE_ONLY_FOR_ALLIANCE));
934. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("CAN_USE_FOR_ME", SKILL_ATTRIBUTE_CAN_USE_FOR_ME));
935. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("ATTACK_SKILL", SKILL_ATTRIBUTE_ATTACK_SKILL));
936. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("MOVING_SKILL", SKILL_ATTRIBUTE_MOVING_SKILL));
937. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("HORSE_SKILL", SKILL_ATTRIBUTE_HORSE_SKILL));
938. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("TIME_INCREASE_SKILL", SKILL_ATTRIBUTE_TIME_INCREASE_SKILL));
939. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("PASSIVE", SKILL_ATTRIBUTE_PASSIVE));
940. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("CANNOT_LEVEL_UP", SKILL_ATTRIBUTE_CANNOT_LEVEL_UP));
941. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("ONLY_FOR_GUILD_WAR", SKILL_ATTRIBUTE_ONLY_FOR_GUILD_WAR));
942. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("CIRCLE_RANGE", SKILL_ATTRIBUTE_CIRCLE_RANGE));
943. m_SkillAttributeIndexMap.insert(std::map<std::string, DWORD>::value_type("SEARCH_TARGET", SKILL_ATTRIBUTE_SEARCH_TARGET));
945. m_SkillNeedWeaponIndexMap.insert(std::map<std::string, DWORD>::value_type("SWORD", SKILL_NEED_WEAPON_SWORD));
946. m_SkillNeedWeaponIndexMap.insert(std::map<std::string, DWORD>::value_type("DAGGER", SKILL_NEED_WEAPON_DAGGER));
947. m_SkillNeedWeaponIndexMap.insert(std::map<std::string, DWORD>::value_type("BOW", SKILL_NEED_WEAPON_BOW));
948. m_SkillNeedWeaponIndexMap.insert(std::map<std::string, DWORD>::value_type("TWO_HANDED", SKILL_NEED_WEAPON_TWO_HANDED));
949. m_SkillNeedWeaponIndexMap.insert(std::map<std::string, DWORD>::value_type("DOUBLE_SWORD", SKILL_NEED_WEAPON_DOUBLE_SWORD));
950. m_SkillNeedWeaponIndexMap.insert(std::map<std::string, DWORD>::value_type("BELL", SKILL_NEED_WEAPON_BELL));
951. m_SkillNeedWeaponIndexMap.insert(std::map<std::string, DWORD>::value_type("FAN", SKILL_NEED_WEAPON_FAN));
952. m_SkillNeedWeaponIndexMap.insert(std::map<std::string, DWORD>::value_type("ARROW", SKILL_NEED_WEAPON_ARROW));
953. m_SkillNeedWeaponIndexMap.insert(std::map<std::string, DWORD>::value_type("EMPTY_HAND", SKILL_NEED_WEAPON_EMPTY_HAND));
955. m_SkillWeaponTypeIndexMap.insert(make_pair(std::string("SWORD"), CItemData::WEAPON_SWORD));
956. m_SkillWeaponTypeIndexMap.insert(make_pair(std::string("DAGGER"), CItemData::WEAPON_DAGGER));
957. m_SkillWeaponTypeIndexMap.insert(make_pair(std::string("BOW"), CItemData::WEAPON_BOW));
958. m_SkillWeaponTypeIndexMap.insert(make_pair(std::string("TWO_HANDED"), CItemData::WEAPON_TWO_HANDED));
959. m_SkillWeaponTypeIndexMap.insert(make_pair(std::string("DOUBLE_SWORD"), CItemData::WEAPON_DAGGER));
960. m_SkillWeaponTypeIndexMap.insert(make_pair(std::string("BELL"), CItemData::WEAPON_BELL));
961. m_SkillWeaponTypeIndexMap.insert(make_pair(std::string("FAN"), CItemData::WEAPON_FAN));
962. m_SkillWeaponTypeIndexMap.insert(make_pair(std::string("ARROW"), CItemData::WEAPON_ARROW));
964. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("chain"), POINT_NONE));
965. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("HR"), POINT_HIT_RATE));
966. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("LV"), POINT_LEVEL));
967. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("Level"), POINT_LEVEL));
968. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("MaxHP"), POINT_MAX_HP));
969. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("MaxSP"), POINT_MAX_SP));
970. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("MinMWEP"), POINT_MIN_WEP));
971. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("MaxMWEP"), POINT_MAX_WEP));
972. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("MinWEP"), POINT_MIN_WEP));
973. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("MaxWEP"), POINT_MAX_WEP));
974. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("MinATK"), POINT_MIN_ATK));
975. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("MaxATK"), POINT_MAX_ATK));
976. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("ATKSPD"), POINT_ATT_SPEED));
977. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("AttackPower"), POINT_MIN_ATK));
978. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("AtkMin"), POINT_MIN_ATK));
979. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("AtkMax"), POINT_MAX_ATK));
980. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("DefencePower"), POINT_DEF_GRADE));
981. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("DEF"), POINT_DEF_GRADE));
982. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("MWEP"), POINT_MAGIC_ATT_GRADE));
984. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("MagicAttackPower"), POINT_MAGIC_ATT_GRADE));
985. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("INT"), POINT_IQ));
986. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("STR"), POINT_ST));
987. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("DEX"), POINT_DX));
988. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("CON"), POINT_HT));
990. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("minatk"), POINT_MIN_ATK));
991. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("maxatk"), POINT_MAX_ATK));
992. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("minmtk"), POINT_MIN_WEP));
993. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("maxmtk"), POINT_MAX_WEP));
995. // GUILD_SKILL_DISPLAY_BUG_FIX
996. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("maxhp"), POINT_MAX_HP));
997. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("maxsp"), POINT_MAX_SP));
998. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("odef"), POINT_DEF_GRADE));
999. // END_OF_GUILD_SKILL_DISPLAY_BUG_FIX
1001. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("minwep"), POINT_MIN_WEP));
1002. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("maxwep"), POINT_MAX_WEP));
1003. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("minmwep"), POINT_MIN_MAGIC_WEP));
1004. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("maxmwep"), POINT_MAX_MAGIC_WEP));
1005. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("lv"), POINT_LEVEL));
1006. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("ar"), POINT_HIT_RATE));
1007. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("iq"), POINT_IQ));
1008. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("str"), POINT_ST));
1009. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("dex"), POINT_DX));
1010. SSkillData::ms_StatusNameMap.insert(make_pair(std::string("con"), POINT_HT));
1012. /////
1014. SSkillData::ms_NewMinStatusNameMap.insert(make_pair(std::string("atk"), POINT_MIN_ATK));
1015. SSkillData::ms_NewMinStatusNameMap.insert(make_pair(std::string("mtk"), POINT_MIN_WEP));
1016. SSkillData::ms_NewMinStatusNameMap.insert(make_pair(std::string("wep"), POINT_MIN_WEP));
1017. SSkillData::ms_NewMinStatusNameMap.insert(make_pair(std::string("lv"), POINT_LEVEL));
1018. SSkillData::ms_NewMinStatusNameMap.insert(make_pair(std::string("ar"), POINT_HIT_RATE));
1019. SSkillData::ms_NewMinStatusNameMap.insert(make_pair(std::string("iq"), POINT_IQ));
1020. SSkillData::ms_NewMinStatusNameMap.insert(make_pair(std::string("str"), POINT_ST));
1021. SSkillData::ms_NewMinStatusNameMap.insert(make_pair(std::string("dex"), POINT_DX));
1022. SSkillData::ms_NewMinStatusNameMap.insert(make_pair(std::string("con"), POINT_HT));
1024. SSkillData::ms_NewMaxStatusNameMap.insert(make_pair(std::string("atk"), POINT_MAX_ATK));
1025. SSkillData::ms_NewMaxStatusNameMap.insert(make_pair(std::string("mtk"), POINT_MAX_WEP));
1026. SSkillData::ms_NewMinStatusNameMap.insert(make_pair(std::string("wep"), POINT_MAX_WEP));
1027. SSkillData::ms_NewMaxStatusNameMap.insert(make_pair(std::string("lv"), POINT_LEVEL));
1028. SSkillData::ms_NewMaxStatusNameMap.insert(make_pair(std::string("ar"), POINT_HIT_RATE));
1029. SSkillData::ms_NewMaxStatusNameMap.insert(make_pair(std::string("iq"), POINT_IQ));
1030. SSkillData::ms_NewMaxStatusNameMap.insert(make_pair(std::string("str"), POINT_ST));
1031. SSkillData::ms_NewMaxStatusNameMap.insert(make_pair(std::string("dex"), POINT_DX));
1032. SSkillData::ms_NewMaxStatusNameMap.insert(make_pair(std::string("con"), POINT_HT));
1034. m_PathNameMap.insert(make_pair(std::string("WARRIOR"), std::string("warrior")));
1035. m_PathNameMap.insert(make_pair(std::string("ASSASSIN"), std::string("assassin")));
1036. m_PathNameMap.insert(make_pair(std::string("SURA"), std::string("sura")));
1037. m_PathNameMap.insert(make_pair(std::string("SHAMAN"), std::string("shaman")));
1038. m_PathNameMap.insert(make_pair(std::string("PASSIVE"), std::string("passive")));
1039. m_PathNameMap.insert(make_pair(std::string("SUPPORT"), std::string("common/support")));
1040. m_PathNameMap.insert(make_pair(std::string("GUILD"), std::string("common/guild")));
1041. m_PathNameMap.insert(make_pair(std::string("HORSE"), std::string("common/horse")));
1042. }
1043. CPythonSkill::~CPythonSkill()
1044. {
1045. }
1047. ///////////////////////////////////////////////////////////////////////////////////////////////////
1048. ///////////////////////////////////////////////////////////////////////////////////////////////////
1049. ///////////////////////////////////////////////////////////////////////////////////////////////////
1051. DWORD CPythonSkill::SSkillData::MELEE_SKILL_TARGET_RANGE=170;
1053. const std::string CPythonSkill::SSkillData::GetName() const
1054. {
1055. return strName;
1056. }
1058. BYTE CPythonSkill::SSkillData::GetType() const
1059. {
1060. return byType;
1061. }
1063. BOOL CPythonSkill::SSkillData::IsMeleeSkill()
1064. {
1065. if (dwSkillAttribute & SKILL_ATTRIBUTE_MELEE_ATTACK)
1066. return TRUE;
1068. return FALSE;
1069. }
1071. BOOL CPythonSkill::SSkillData::IsChargeSkill()
1072. {
1073. if (dwSkillAttribute & SKILL_ATTRIBUTE_CHARGE_ATTACK)
1074. return TRUE;
1076. return FALSE;
1077. }
1079. BOOL CPythonSkill::SSkillData::IsOnlyForGuildWar()
1080. {
1081. if (dwSkillAttribute & SKILL_ATTRIBUTE_ONLY_FOR_GUILD_WAR)
1082. return TRUE;
1084. return FALSE;
1085. }
1087. DWORD CPythonSkill::SSkillData::GetTargetRange() const
1088. {
1089. if (dwSkillAttribute & SKILL_ATTRIBUTE_MELEE_ATTACK)
1090. return MELEE_SKILL_TARGET_RANGE;
1092. if (dwSkillAttribute & SKILL_ATTRIBUTE_CHARGE_ATTACK)
1093. return MELEE_SKILL_TARGET_RANGE;
1095. return dwTargetRange;
1096. }
1098. BOOL CPythonSkill::SSkillData::CanChangeDirection()
1099. {
1100. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_CAN_CHANGE_DIRECTION);
1101. }
1103. BOOL CPythonSkill::SSkillData::IsFanRange()
1104. {
1105. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_FAN_RANGE);
1106. }
1108. BOOL CPythonSkill::SSkillData::IsCircleRange()
1109. {
1110. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_CIRCLE_RANGE);
1111. }
1113. BOOL CPythonSkill::SSkillData::IsAutoSearchTarget()
1114. {
1115. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_SEARCH_TARGET);
1116. }
1118. BOOL CPythonSkill::SSkillData::IsNeedCorpse()
1119. {
1120. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_NEED_CORPSE);
1121. }
1123. BOOL CPythonSkill::SSkillData::IsNeedTarget()
1124. {
1125. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_NEED_TARGET);
1126. }
1128. BOOL CPythonSkill::SSkillData::IsToggleSkill()
1129. {
1130. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_TOGGLE);
1131. }
1133. BOOL CPythonSkill::SSkillData::IsUseHPSkill()
1134. {
1135. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_USE_HP);
1136. }
1138. BOOL CPythonSkill::SSkillData::IsStandingSkill()
1139. {
1140. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_STANDING_SKILL);
1141. }
1143. BOOL CPythonSkill::SSkillData::CanUseWeaponType(DWORD dwWeaponType)
1144. {
1145. if (!(dwSkillAttribute & SKILL_ATTRIBUTE_WEAPON_LIMITATION))
1146. return TRUE;
1148. return 0 != (dwNeedWeapon & (1 << dwWeaponType));
1149. }
1151. BOOL CPythonSkill::SSkillData::IsOnlyForAlliance()
1152. {
1153. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_ONLY_FOR_ALLIANCE);
1154. }
1156. BOOL CPythonSkill::SSkillData::CanUseForMe()
1157. {
1158. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_CAN_USE_FOR_ME);
1159. }
1161. BOOL CPythonSkill::SSkillData::CanUseIfNotEnough()
1162. {
1163. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_CAN_USE_IF_NOT_ENOUGH);
1164. }
1166. BOOL CPythonSkill::SSkillData::IsNeedEmptyBottle()
1167. {
1168. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_NEED_EMPTY_BOTTLE);
1169. }
1171. BOOL CPythonSkill::SSkillData::IsNeedPoisonBottle()
1172. {
1173. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_NEED_POISON_BOTTLE);
1174. }
1176. BOOL CPythonSkill::SSkillData::IsNeedBow()
1177. {
1178. if (!(dwSkillAttribute & SKILL_ATTRIBUTE_WEAPON_LIMITATION))
1179. return FALSE;
1181. return 0 != (dwNeedWeapon & SKILL_NEED_WEAPON_BOW);
1182. }
1184. BOOL CPythonSkill::SSkillData::IsHorseSkill()
1185. {
1186. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_HORSE_SKILL);
1187. }
1189. BOOL CPythonSkill::SSkillData::IsMovingSkill()
1190. {
1191. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_MOVING_SKILL);
1192. }
1194. BOOL CPythonSkill::SSkillData::IsAttackSkill()
1195. {
1196. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_ATTACK_SKILL);
1197. }
1199. BOOL CPythonSkill::SSkillData::IsTimeIncreaseSkill()
1200. {
1201. return 0 != (dwSkillAttribute & SKILL_ATTRIBUTE_TIME_INCREASE_SKILL);
1202. }
1204. bool CPythonSkill::SSkillData::GetState(const char * c_szStateName, int * piState, int iMinMaxType)
1205. {
1206. std::map<std::string, DWORD> * pStatusNameMap = NULL;
1208. switch (iMinMaxType)
1209. {
1210. case VALUE_TYPE_FREE:
1211. pStatusNameMap = &ms_StatusNameMap;
1212. break;
1213. case VALUE_TYPE_MIN:
1214. pStatusNameMap = &ms_NewMinStatusNameMap;
1215. break;
1216. case VALUE_TYPE_MAX:
1217. pStatusNameMap = &ms_NewMaxStatusNameMap;
1218. break;
1219. default:
1220. return false;
1221. break;
1222. }
1224. std::map<std::string, DWORD>::iterator it = pStatusNameMap->find(c_szStateName);
1226. if (it != pStatusNameMap->end())
1227. {
1228. *piState = CPythonPlayer::Instance().GetStatus(it->second);
1229. }
1230. else if (0 == strncmp(c_szStateName, "JeungJi", 7))
1231. {
1232. *piState = 0;
1234. // ÁõÁö¼ú Àӽà Á¦¿Ü
1235. /*
1236. if (0 != ms_dwTimeIncreaseSkillNumber)
1237. {
1238. DWORD dwSkillSlotIndex;
1239. if (!CPythonPlayer::Instance().FindSkillSlotIndexBySkillIndex(ms_dwTimeIncreaseSkillNumber, &dwSkillSlotIndex))
1240. return false;
1242. *piState = CPythonPlayer::Instance().GetSkillLevel(dwSkillSlotIndex);
1243. }
1244. */
1245. }
1247. return true;
1248. }
1250. float CPythonSkill::SSkillData::ProcessFormula(CPoly * pPoly, float fSkillLevel, int iMinMaxType)
1251. {
1252. if (pPoly->Analyze())
1253. {
1254. for (DWORD i = 0; i < pPoly->GetVarCount(); ++i)
1255. {
1256. const char * c_szVarName = pPoly->GetVarName(i);
1257. float fState;
1258. if (!strcmp("SkillPoint", c_szVarName) || !strcmp("k", c_szVarName))
1259. {
1260. fState = fSkillLevel;
1261. }
1262. else
1263. {
1264. int iState;
1265. if (!GetState(c_szVarName, &iState, iMinMaxType))
1266. return 0.0f;
1268. fState = float(iState);
1270. if (!strcmp("ar", c_szVarName))
1271. fState /= 100.0f;
1272. }
1273. pPoly->SetVar(c_szVarName, fState);
1274. }
1275. }
1276. else
1277. {
1278. TraceError("skillGetAffect - Strange Formula [%s]", strName.c_str());
1279. return 0.0f;
1280. }
1282. return pPoly->Eval();
1283. }
1285. const char * CPythonSkill::SSkillData::GetAffectDescription(DWORD dwIndex, float fSkillLevel)
1286. {
1287. if (dwIndex >= AffectDataVector.size())
1288. return NULL;
1290. const std::string & c_rstrAffectDescription = AffectDataVector[dwIndex].strAffectDescription;
1291. const std::string & c_rstrAffectMinFormula = AffectDataVector[dwIndex].strAffectMinFormula;
1292. const std::string & c_rstrAffectMaxFormula = AffectDataVector[dwIndex].strAffectMaxFormula;
1294. CPoly minPoly;
1295. CPoly maxPoly;
1296. minPoly.SetStr(c_rstrAffectMinFormula.c_str());
1297. maxPoly.SetStr(c_rstrAffectMaxFormula.c_str());
1299. // OVERWRITE_SKILLPROTO_POLY
1300. float fMinValue = ProcessFormula(&minPoly, fSkillLevel);
1301. float fMaxValue = ProcessFormula(&maxPoly, fSkillLevel);
1303. if (fMinValue < 0.0)
1304. fMinValue = - fMinValue;
1305. if (fMaxValue < 0.0)
1306. fMaxValue = - fMaxValue;
1308. if (CP_ARABIC == ::GetDefaultCodePage())
1309. {
1310. // #0000870: [M2AE] Çѱ¹¾î ¸ğµåÀ϶§ ƯÁ¤ ¾Æ¶ø¾î ¹®Àå¿¡¼­ Å©·¡½¬ ¹ß»ı
1311. static std::string strDescription;
1312. strDescription = c_rstrAffectDescription;
1313. int first = strDescription.find("%.0f");
1314. if (first >= 0)
1315. {
1316. fMinValue = floorf(fMinValue);
1318. char szMinValue[256];
1319. _snprintf_s(szMinValue, sizeof(szMinValue), "%.0f", fMinValue);
1320. strDescription.replace(first, 4, szMinValue);
1322. int second = strDescription.find("%.0f", first);
1323. if (second >= 0)
1324. {
1325. fMaxValue = floorf(fMaxValue);
1327. char szMaxValue[256];
1328. _snprintf_s(szMaxValue, sizeof(szMaxValue), "%.0f", fMaxValue);
1329. strDescription.replace(second, 4, szMaxValue);
1330. }
1331. }
1332. return strDescription.c_str();
1333. }
1334. else
1335. {
1336. if (strstr(c_rstrAffectDescription.c_str(), "%.0f"))
1337. {
1338. fMinValue = floorf(fMinValue);
1339. fMaxValue = floorf(fMaxValue);
1340. }
1342. static char szDescription[64+1];
1343. _snprintf_s(szDescription, sizeof(szDescription), c_rstrAffectDescription.c_str(), fMinValue, fMaxValue);
1345. return szDescription;
1346. }
1347. }
1349. DWORD CPythonSkill::SSkillData::GetSkillCoolTime(float fSkillPoint)
1350. {
1351. if (strCoolTimeFormula.empty())
1352. return 0;
1354. CPoly poly;
1355. poly.SetStr(strCoolTimeFormula.c_str());
1357. return DWORD(ProcessFormula(&poly, fSkillPoint));
1358. }
1361. DWORD CPythonSkill::SSkillData::GetTargetCount(float fSkillPoint)
1362. {
1363. if (strTargetCountFormula.empty())
1364. return 0;
1366. CPoly poly;
1367. poly.SetStr(strTargetCountFormula.c_str());
1369. return DWORD(ProcessFormula(&poly, fSkillPoint));
1370. }
1372. DWORD CPythonSkill::SSkillData::GetSkillMotionIndex(int iGrade)
1373. {
1374. if (-1 != iGrade && SKILL_EFFECT_UPGRADE_ENABLE)
1375. {
1376. assert(iGrade >= 0 && iGrade < SKILL_EFFECT_COUNT);
1377. /*
1378. if (SKILL_GRADE_COUNT == iGrade)
1379. {
1380. return GradeData[SKILL_GRADE_COUNT-1].wMotionIndex;
1381. }
1382. else */
1383. if (iGrade >= 0 && iGrade < SKILL_EFFECT_COUNT)
1384. {
1385. return GradeData[iGrade].wMotionIndex;
1386. }
1387. }
1389. return wMotionIndex;
1390. }
1392. BYTE CPythonSkill::SSkillData::GetMaxLevel()
1393. {
1394. return byMaxLevel;
1395. }
1397. BYTE CPythonSkill::SSkillData::GetLevelUpPoint()
1398. {
1399. return byLevelUpPoint;
1400. }
1402. BOOL CPythonSkill::SSkillData::IsNoMotion()
1403. {
1404. return bNoMotion;
1405. }
1407. bool CPythonSkill::SSkillData::IsCanUseSkill()
1408. {
1409. if (0 != (dwSkillAttribute & SKILL_ATTRIBUTE_PASSIVE))
1410. return false;
1412. return true;
1413. }
1415. DWORD CPythonSkill::SSkillData::GetMotionLoopCount(float fSkillPoint)
1416. {
1417. if (strMotionLoopCountFormula.empty())
1418. return 0;
1420. CPoly poly;
1421. poly.SetStr(strMotionLoopCountFormula.c_str());
1423. return DWORD(ProcessFormula(&poly, fSkillPoint));
1424. }
1426. int CPythonSkill::SSkillData::GetNeedSP(float fSkillPoint)
1427. {
1428. if (strNeedSPFormula.empty())
1429. return 0;
1431. CPoly poly;
1432. poly.SetStr(strNeedSPFormula.c_str());
1434. return int(ProcessFormula(&poly, fSkillPoint));
1435. }
1437. DWORD CPythonSkill::SSkillData::GetContinuationSP(float fSkillPoint)
1438. {
1439. if (strContinuationSPFormula.empty())
1440. return 0;
1442. CPoly poly;
1443. poly.SetStr(strContinuationSPFormula.c_str());
1445. return DWORD(ProcessFormula(&poly, fSkillPoint));
1446. }
1448. DWORD CPythonSkill::SSkillData::GetDuration(float fSkillPoint)
1449. {
1450. if (strDuration.empty())
1451. return 0;
1453. CPoly poly;
1454. poly.SetStr(strDuration.c_str());
1456. return DWORD(ProcessFormula(&poly, fSkillPoint));
1457. }
1459. CPythonSkill::SSkillData::SSkillData()
1460. {
1461. byType = SKILL_TYPE_ACTIVE;
1462. byMaxLevel = 20;
1463. byLevelUpPoint = 1;
1464. dwSkillAttribute = 0;
1465. dwNeedWeapon = 0;
1466. dwTargetRange = 0;
1467. strCoolTimeFormula = "";
1468. strMotionLoopCountFormula = "";
1469. strNeedSPFormula = "";
1470. strContinuationSPFormula = "";
1471. isRequirement = FALSE;
1472. strRequireSkillName = "";
1473. byRequireSkillLevel = 0;
1474. strDuration = "";
1475. byLevelLimit = 0;
1476. bNoMotion = FALSE;
1478. strName = "";
1479. pImage = NULL;
1481. for (int j = 0; j < SKILL_GRADE_COUNT; ++j)
1482. {
1483. TGradeData & rGradeData = GradeData[j];
1484. rGradeData.strName = "";
1485. rGradeData.pImage = NULL;
1486. rGradeData.wMotionIndex = 0;
1487. }
1488. }
1490. ///////////////////////////////////////////////////////////////////////////////////////////////////
1491. ///////////////////////////////////////////////////////////////////////////////////////////////////
1492. ///////////////////////////////////////////////////////////////////////////////////////////////////
1494. PyObject * skillSetPathName(PyObject * poSelf, PyObject * poArgs)
1495. {
1496. char * szPathName;
1497. if (!PyTuple_GetString(poArgs, 0, &szPathName))
1498. return Py_BadArgument();
1500. CPythonSkill::Instance().SetPathName(szPathName);
1501. return Py_BuildNone();
1502. }
1504. PyObject * skillRegisterSkill(PyObject * poSelf, PyObject * poArgs)
1505. {
1506. int iSkillIndex;
1507. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1508. return Py_BadArgument();
1509. char * szFileName;
1510. if (!PyTuple_GetString(poArgs, 1, &szFileName))
1511. return Py_BadArgument();
1513. std::string strFullFileName;
1514. strFullFileName = CPythonSkill::Instance().GetPathName();
1515. strFullFileName += szFileName;
1517. if (!CPythonSkill::Instance().RegisterSkill(iSkillIndex, strFullFileName.c_str()))
1518. return Py_BuildException("skill.RegisterSkill - Failed to find skill data file : %d, %s", iSkillIndex, strFullFileName.c_str());
1520. return Py_BuildNone();
1521. }
1523. PyObject * skillLoadSkillData(PyObject * poSelf, PyObject * poArgs)
1524. {
1528. return Py_BuildNone();
1529. }
1531. PyObject * skillRegisterSkillDesc(PyObject * poSelf, PyObject * poArgs)
1532. {
1533. char * szFileName;
1534. if (!PyTuple_GetString(poArgs, 0, &szFileName))
1535. return Py_BadArgument();
1537. if (!CPythonSkill::Instance().RegisterSkillDesc(szFileName))
1538. return Py_BuildException("Failed to load Skill Desc");
1540. return Py_BuildNone();
1541. }
1543. PyObject * skillClearSkillData(PyObject * poSelf, PyObject * poArgs)
1544. {
1545. CPythonSkill::SSkillData::ms_dwTimeIncreaseSkillNumber = 0;
1546. return Py_BuildNone();
1547. }
1549. PyObject * skillGetSkillName(PyObject * poSelf, PyObject * poArgs)
1550. {
1551. int iSkillIndex;
1552. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1553. return Py_BadArgument();
1555. int iSkillGrade = -1;
1556. PyTuple_GetInteger(poArgs, 1, &iSkillGrade);
1558. CPythonSkill::SSkillData * c_pSkillData;
1559. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1560. return Py_BuildException("skill.GetSkillName - Failed to find skill by %d", iSkillIndex);
1562. if (-1 != iSkillGrade)
1563. if (iSkillGrade >= 0 && iSkillGrade < CPythonSkill::SKILL_GRADE_COUNT)
1564. {
1565. return Py_BuildValue("s", c_pSkillData->GradeData[iSkillGrade].strName.c_str());
1566. }
1568. return Py_BuildValue("s", c_pSkillData->strName.c_str());
1569. }
1571. PyObject * skillGetSkillDescription(PyObject * poSelf, PyObject * poArgs)
1572. {
1573. int iSkillIndex;
1574. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1575. return Py_BadArgument();
1577. CPythonSkill::SSkillData * c_pSkillData;
1578. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1579. return Py_BuildException("skill.GetSkillDescription - Failed to find skill by %d", iSkillIndex);
1581. return Py_BuildValue("s", c_pSkillData->strDescription.c_str());
1582. }
1584. PyObject * skillGetSkillType(PyObject * poSelf, PyObject * poArgs)
1585. {
1586. int iSkillIndex;
1587. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1588. return Py_BadArgument();
1590. CPythonSkill::SSkillData * c_pSkillData;
1591. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1592. return Py_BuildException("skill.GetSkillType - Failed to find skill by %d", iSkillIndex);
1594. return Py_BuildValue("i", c_pSkillData->byType);
1595. }
1597. PyObject * skillGetSkillConditionDescriptionCount(PyObject * poSelf, PyObject * poArgs)
1598. {
1599. int iSkillIndex;
1600. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1601. return Py_BadArgument();
1603. CPythonSkill::SSkillData * c_pSkillData;
1604. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1605. return Py_BuildException("skill.GetSkillConditionDescriptionCount - Failed to find skill by %d", iSkillIndex);
1607. return Py_BuildValue("i", c_pSkillData->ConditionDataVector.size());
1608. }
1610. PyObject * skillGetSkillConditionDescription(PyObject * poSelf, PyObject * poArgs)
1611. {
1612. int iSkillIndex;
1613. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1614. return Py_BadArgument();
1616. int iConditionIndex;
1617. if (!PyTuple_GetInteger(poArgs, 1, &iConditionIndex))
1618. return Py_BadArgument();
1620. CPythonSkill::SSkillData * c_pSkillData;
1621. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1622. return Py_BuildException("skill.GetSkillConditionDescription() - Failed to find skill by %d", iSkillIndex);
1624. if (iConditionIndex >= c_pSkillData->ConditionDataVector.size())
1625. return Py_BuildValue("None");
1627. return Py_BuildValue("s", c_pSkillData->ConditionDataVector[iConditionIndex].c_str());
1628. }
1630. PyObject * skillGetSkillAffectDescriptionCount(PyObject * poSelf, PyObject * poArgs)
1631. {
1632. int iSkillIndex;
1633. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1634. return Py_BadArgument();
1636. CPythonSkill::SSkillData * c_pSkillData;
1637. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1638. return Py_BuildException("skill.GetSkillAffectDescriptionCount - Failed to find skill by %d", iSkillIndex);
1640. return Py_BuildValue("i", c_pSkillData->AffectDataVector.size());
1641. }
1643. PyObject * skillGetSkillAffectDescription(PyObject * poSelf, PyObject * poArgs)
1644. {
1645. int iSkillIndex;
1646. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1647. return Py_BadArgument();
1649. int iAffectIndex;
1650. if (!PyTuple_GetInteger(poArgs, 1, &iAffectIndex))
1651. return Py_BadArgument();
1653. float fSkillPoint;
1654. if (!PyTuple_GetFloat(poArgs, 2, &fSkillPoint))
1655. return Py_BadArgument();
1657. CPythonSkill::SSkillData * c_pSkillData;
1658. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1659. return Py_BuildException("skill.GetSkillAffectDescription - Failed to find skill by %d", iSkillIndex);
1661. return Py_BuildValue("s", c_pSkillData->GetAffectDescription(iAffectIndex, fSkillPoint));
1662. }
1664. PyObject * skillGetSkillCoolTime(PyObject * poSelf, PyObject * poArgs)
1665. {
1666. int iSkillIndex;
1667. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1668. return Py_BadArgument();
1670. float fSkillPoint;
1671. if (!PyTuple_GetFloat(poArgs, 1, &fSkillPoint))
1672. return Py_BadArgument();
1674. CPythonSkill::SSkillData * c_pSkillData;
1675. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1676. return Py_BuildException("skill.GetSkillCoolTime - Failed to find skill by %d", iSkillIndex);
1678. return Py_BuildValue("i", c_pSkillData->GetSkillCoolTime(fSkillPoint));
1679. }
1681. PyObject * skillGetSkillNeedSP(PyObject * poSelf, PyObject * poArgs)
1682. {
1683. int iSkillIndex;
1684. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1685. return Py_BadArgument();
1687. float fSkillPoint;
1688. if (!PyTuple_GetFloat(poArgs, 1, &fSkillPoint))
1689. return Py_BadArgument();
1691. CPythonSkill::SSkillData * c_pSkillData;
1692. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1693. return Py_BuildException("skill.GetSkillNeedSP Failed to find skill by %d", iSkillIndex);
1695. return Py_BuildValue("i", c_pSkillData->GetNeedSP(fSkillPoint));
1696. }
1698. PyObject * skillGetSkillContinuationSP(PyObject * poSelf, PyObject * poArgs)
1699. {
1700. int iSkillIndex;
1701. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1702. return Py_BadArgument();
1704. float fSkillPoint;
1705. if (!PyTuple_GetFloat(poArgs, 1, &fSkillPoint))
1706. return Py_BadArgument();
1708. CPythonSkill::SSkillData * c_pSkillData;
1709. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1710. return Py_BuildException("skill.GetSkillContinuationSP - Failed to find skill by %d", iSkillIndex);
1712. return Py_BuildValue("i", c_pSkillData->GetContinuationSP(fSkillPoint));
1713. }
1715. PyObject * skillGetSkillMaxLevel(PyObject * poSelf, PyObject * poArgs)
1716. {
1717. int iSkillIndex;
1718. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1719. return Py_BadArgument();
1721. CPythonSkill::SSkillData * c_pSkillData;
1722. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1723. return Py_BuildException("skill.GetSkillMaxLevel - Failed to find skill by %d", iSkillIndex);
1725. return Py_BuildValue("i", c_pSkillData->GetMaxLevel());
1726. }
1728. PyObject * skillGetSkillLevelUpPoint(PyObject * poSelf, PyObject * poArgs)
1729. {
1730. int iSkillIndex;
1731. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1732. return Py_BadArgument();
1734. CPythonSkill::SSkillData * c_pSkillData;
1735. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1736. return Py_BuildException("skill.GetSkillLevelUpPoint - Failed to find skill by %d", iSkillIndex);
1738. return Py_BuildValue("i", c_pSkillData->GetLevelUpPoint());
1739. }
1741. PyObject * skillGetSkillLevelLimit(PyObject * poSelf, PyObject * poArgs)
1742. {
1743. int iSkillIndex;
1744. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1745. return Py_BadArgument();
1747. CPythonSkill::SSkillData * c_pSkillData;
1748. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1749. return Py_BuildException("skill.GetSkillLevelLimit - Failed to find skill by %d", iSkillIndex);
1751. return Py_BuildValue("i", c_pSkillData->byLevelLimit);
1752. }
1754. PyObject * skillIsSkillRequirement(PyObject * poSelf, PyObject * poArgs)
1755. {
1756. int iSkillIndex;
1757. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1758. return Py_BadArgument();
1760. CPythonSkill::SSkillData * c_pSkillData;
1761. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1762. return Py_BuildException("skill.IsSkillRequirement - Failed to find skill by %d", iSkillIndex);
1764. if (c_pSkillData->isRequirement)
1765. {
1766. CPythonSkill::SSkillData * pRequireSkillData;
1767. if (!CPythonSkill::Instance().GetSkillDataByName(c_pSkillData->strRequireSkillName.c_str(), &pRequireSkillData))
1768. {
1769. TraceError("skill.IsSkillRequirement - Failed to find skill : [%d/%s] can't find [%s]\n", c_pSkillData->dwSkillIndex, c_pSkillData->strName.c_str(), c_pSkillData->strRequireSkillName.c_str());
1770. return Py_BuildValue("i", FALSE);
1771. }
1773. DWORD dwRequireSkillSlotIndex;
1774. if (!CPythonPlayer::Instance().FindSkillSlotIndexBySkillIndex(pRequireSkillData->dwSkillIndex, &dwRequireSkillSlotIndex))
1775. return Py_BuildValue("i", FALSE);
1776. }
1778. return Py_BuildValue("i", c_pSkillData->isRequirement);
1779. }
1781. PyObject * skillGetSkillRequirementData(PyObject * poSelf, PyObject * poArgs)
1782. {
1783. int iSkillIndex;
1784. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1785. return Py_BadArgument();
1787. CPythonSkill::SSkillData * c_pSkillData;
1788. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1789. return Py_BuildException("skill.GetSkillRequirementData - Failed to find skill by %d", iSkillIndex);
1791. CPythonSkill::SSkillData * pRequireSkillData;
1792. if (!CPythonSkill::Instance().GetSkillDataByName(c_pSkillData->strRequireSkillName.c_str(), &pRequireSkillData))
1793. return Py_BuildValue("si", 0, "None", 0);
1795. int ireqLevel = (int)ceil(float(c_pSkillData->byRequireSkillLevel)/float(max(1, pRequireSkillData->byLevelUpPoint)));
1796. return Py_BuildValue("si", c_pSkillData->strRequireSkillName.c_str(), ireqLevel);
1797. }
1799. PyObject * skillGetSkillRequireStatCount(PyObject * poSelf, PyObject * poArgs)
1800. {
1801. int iSkillIndex;
1802. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1803. return Py_BadArgument();
1805. CPythonSkill::SSkillData * c_pSkillData;
1806. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1807. return Py_BuildException("skill.GetSkillRequireStatCount - Failed to find skill by %d", iSkillIndex);
1809. return Py_BuildValue("i", c_pSkillData->RequireStatDataVector.size());
1810. }
1812. PyObject * skillGetSkillRequireStatData(PyObject * poSelf, PyObject * poArgs)
1813. {
1814. int iSkillIndex;
1815. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1816. return Py_BadArgument();
1817. int iStatIndex;
1818. if (!PyTuple_GetInteger(poArgs, 1, &iStatIndex))
1819. return Py_BadArgument();
1821. CPythonSkill::SSkillData * c_pSkillData;
1822. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1823. return Py_BuildException("skill.GetSkillRequireStatData - Failed to find skill by %d", iSkillIndex);
1825. if (iStatIndex >= c_pSkillData->RequireStatDataVector.size())
1826. return Py_BuildValue("ii", 0, 0);
1828. const CPythonSkill::TRequireStatData & c_rRequireStatData = c_pSkillData->RequireStatDataVector[iStatIndex];
1830. return Py_BuildValue("ii", c_rRequireStatData.byPoint, c_rRequireStatData.byLevel);
1831. }
1833. PyObject * skillCanLevelUpSkill(PyObject * poSelf, PyObject * poArgs)
1834. {
1835. int iSkillIndex;
1836. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1837. return Py_BadArgument();
1838. int iSkillLevel;
1839. if (!PyTuple_GetInteger(poArgs, 1, &iSkillLevel))
1840. return Py_BadArgument();
1842. CPythonSkill::SSkillData * c_pSkillData;
1843. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1844. return Py_BuildException("skill.CanLevelUpSkill - Failed to find skill by %d", iSkillIndex);
1846. if (iSkillLevel >= c_pSkillData->GetMaxLevel())
1847. return Py_BuildValue("i", FALSE);
1849. if (c_pSkillData->isRequirement)
1850. {
1851. CPythonSkill::SSkillData * pRequireSkillData;
1852. if (CPythonSkill::Instance().GetSkillDataByName(c_pSkillData->strRequireSkillName.c_str(), &pRequireSkillData))
1853. {
1854. DWORD dwRequireSkillSlotIndex;
1855. if (CPythonPlayer::Instance().FindSkillSlotIndexBySkillIndex(pRequireSkillData->dwSkillIndex, &dwRequireSkillSlotIndex))
1856. {
1857. int iSkillGrade = CPythonPlayer::Instance().GetSkillGrade(dwRequireSkillSlotIndex);
1858. int iSkillLevel = CPythonPlayer::Instance().GetSkillLevel(dwRequireSkillSlotIndex);
1859. if (iSkillGrade <= 0)
1860. if (iSkillLevel < c_pSkillData->byRequireSkillLevel)
1861. return Py_BuildValue("i", FALSE);
1862. }
1863. }
1864. }
1866. for (DWORD i = 0; i < c_pSkillData->RequireStatDataVector.size(); ++i)
1867. {
1868. const CPythonSkill::TRequireStatData & c_rRequireStatData = c_pSkillData->RequireStatDataVector[i];
1869. if (CPythonPlayer::Instance().GetStatus(c_rRequireStatData.byPoint) < c_rRequireStatData.byLevel)
1870. return Py_BuildValue("i", FALSE);
1871. }
1873. if (0 != (c_pSkillData->dwSkillAttribute & CPythonSkill::SKILL_ATTRIBUTE_CANNOT_LEVEL_UP))
1874. return Py_BuildValue("i", FALSE);
1876. return Py_BuildValue("i", TRUE);
1877. }
1879. PyObject * skillCheckRequirementSueccess(PyObject * poSelf, PyObject * poArgs)
1880. {
1881. int iSkillIndex;
1882. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1883. return Py_BadArgument();
1885. CPythonSkill::SSkillData * c_pSkillData;
1886. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1887. return Py_BuildException("skill.CheckRequirementSueccess - Failed to find skill by %d", iSkillIndex);
1889. if (c_pSkillData->isRequirement)
1890. {
1891. CPythonSkill::SSkillData * pRequireSkillData;
1892. if (CPythonSkill::Instance().GetSkillDataByName(c_pSkillData->strRequireSkillName.c_str(), &pRequireSkillData))
1893. {
1894. DWORD dwRequireSkillSlotIndex;
1895. if (CPythonPlayer::Instance().FindSkillSlotIndexBySkillIndex(pRequireSkillData->dwSkillIndex, &dwRequireSkillSlotIndex))
1896. {
1897. int iSkillGrade = CPythonPlayer::Instance().GetSkillGrade(dwRequireSkillSlotIndex);
1898. int iSkillLevel = CPythonPlayer::Instance().GetSkillLevel(dwRequireSkillSlotIndex);
1899. if (iSkillGrade <= 0)
1900. if (iSkillLevel < c_pSkillData->byRequireSkillLevel)
1901. return Py_BuildValue("i", FALSE);
1902. }
1903. }
1904. }
1906. return Py_BuildValue("i", TRUE);
1907. }
1909. PyObject * skillGetNeedCharacterLevel(PyObject * poSelf, PyObject * poArgs)
1910. {
1911. int iSkillIndex;
1912. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1913. return Py_BadArgument();
1915. CPythonSkill::SSkillData * c_pSkillData;
1916. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1917. return Py_BuildException("skill.GetNeedCharacterLevel - Failed to find skill by %d", iSkillIndex);
1919. std::vector<CPythonSkill::TRequireStatData>::iterator itor = c_pSkillData->RequireStatDataVector.begin();
1920. for (; itor != c_pSkillData->RequireStatDataVector.end(); ++itor)
1921. {
1922. const CPythonSkill::TRequireStatData & c_rRequireStatData = *itor;
1924. if (POINT_LEVEL == c_rRequireStatData.byPoint)
1925. return Py_BuildValue("i", c_rRequireStatData.byLevel);
1926. }
1928. return Py_BuildValue("i", 0);
1929. }
1931. PyObject * skillIsToggleSkill(PyObject * poSelf, PyObject * poArgs)
1932. {
1933. int iSkillIndex;
1934. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1935. return Py_BadArgument();
1937. CPythonSkill::SSkillData * c_pSkillData;
1938. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1939. return Py_BuildException("skill.IsToggleSkill - Failed to find skill by %d", iSkillIndex);
1941. return Py_BuildValue("i", c_pSkillData->IsToggleSkill());
1942. }
1944. PyObject * skillIsUseHPSkill(PyObject * poSelf, PyObject * poArgs)
1945. {
1946. int iSkillIndex;
1947. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1948. return Py_BadArgument();
1950. CPythonSkill::SSkillData * c_pSkillData;
1951. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1952. return Py_BuildException("skill.IsUseHPSkill - Failed to find skill by %d", iSkillIndex);
1954. return Py_BuildValue("i", c_pSkillData->IsUseHPSkill());
1955. }
1957. PyObject * skillIsStandingSkill(PyObject * poSelf, PyObject * poArgs)
1958. {
1959. int iSkillIndex;
1960. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1961. return Py_BadArgument();
1963. CPythonSkill::SSkillData * c_pSkillData;
1964. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1965. return Py_BuildException("skill.IsStandingSkill - Failed to find skill by %d", iSkillIndex);
1967. return Py_BuildValue("i", c_pSkillData->IsStandingSkill());
1968. }
1970. PyObject * skillCanUseSkill(PyObject * poSelf, PyObject * poArgs)
1971. {
1972. int iSkillIndex;
1973. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1974. return Py_BadArgument();
1976. CPythonSkill::SSkillData * c_pSkillData;
1977. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1978. return Py_BuildException("skill.CanUseSkill - Failed to find skill by %d", iSkillIndex);
1980. return Py_BuildValue("i", c_pSkillData->IsCanUseSkill());
1981. }
1983. PyObject * skillIsLevelUpSkill(PyObject * poSelf, PyObject * poArgs)
1984. {
1985. int iSkillIndex;
1986. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
1987. return Py_BadArgument();
1989. CPythonSkill::SSkillData * c_pSkillData;
1990. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
1991. return Py_BuildException("skill.IsLevelUpSkill - Failed to find skill by %d", iSkillIndex);
1993. // ¸ğµÎ ·¹º§¾÷ °¡´É
1995. return Py_BuildValue("i", TRUE);
1996. }
1998. PyObject * skillGetIconName(PyObject * poSelf, PyObject * poArgs)
1999. {
2000. int iSkillIndex;
2001. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
2002. return Py_BadArgument();
2004. CPythonSkill::SSkillData * c_pSkillData;
2005. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
2006. return Py_BuildValue("s", "");
2008. return Py_BuildValue("s", c_pSkillData->strIconFileName.c_str());
2009. }
2011. PyObject * skillGetIconImage(PyObject * poSelf, PyObject * poArgs)
2012. {
2013. int iSkillIndex;
2014. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
2015. return Py_BadArgument();
2017. CPythonSkill::SSkillData * c_pSkillData;
2018. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
2019. return Py_BuildValue("i", 0); // ÀͼÁ¼ÇÀ» ³»´Â ´ë½Å 0À» ¸®ÅÏÇÑ´Ù.
2021. return Py_BuildValue("i", c_pSkillData->pImage);
2022. }
2026. PyObject * skillGetIconInstance(PyObject * poSelf, PyObject * poArgs)
2027. {
2028. int iSkillIndex;
2029. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
2030. return Py_BadArgument();
2032. CPythonSkill::SSkillData * c_pSkillData;
2033. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
2034. return Py_BuildException("skill.GetIconInstance - Failed to find skill by %d", iSkillIndex);
2036. CGraphicImageInstance * pImageInstance = CGraphicImageInstance::New();
2037. pImageInstance->SetImagePointer(c_pSkillData->pImage);
2039. return Py_BuildValue("i", pImageInstance);
2040. }
2042. PyObject * skillGetIconImageNew(PyObject * poSelf, PyObject * poArgs)
2043. {
2044. int iSkillIndex;
2045. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
2046. return Py_BadArgument();
2048. int iGradeIndex;
2049. if (!PyTuple_GetInteger(poArgs, 1, &iGradeIndex))
2050. return Py_BadArgument();
2052. CPythonSkill::SSkillData * c_pSkillData;
2053. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
2054. return Py_BuildValue("i", 0); // ÀͼÁ¼ÇÀ» ³»´Â ´ë½Å 0À» ¸®ÅÏÇÑ´Ù.
2056. if (iGradeIndex < 0)
2057. iGradeIndex = 0;
2059. if (iGradeIndex >= CPythonSkill::SKILL_GRADE_COUNT)
2060. iGradeIndex = CPythonSkill::SKILL_GRADE_COUNT-1;
2062. return Py_BuildValue("i", c_pSkillData->GradeData[iGradeIndex].pImage);
2063. }
2065. PyObject * skillGetIconInstanceNew(PyObject * poSelf, PyObject * poArgs)
2066. {
2067. int iSkillIndex;
2068. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
2069. return Py_BadArgument();
2071. int iGradeIndex;
2072. if (!PyTuple_GetInteger(poArgs, 1, &iGradeIndex))
2073. return Py_BadArgument();
2075. CPythonSkill::SSkillData * c_pSkillData;
2076. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
2077. return Py_BuildException("skill.GetIconInstanceNew - Failed to find skill by %d", iSkillIndex);
2079. //CGraphicImage * pImage = c_pSkillData->pImage;
2081. if (iGradeIndex < 0)
2082. iGradeIndex = 0;
2084. if (iGradeIndex >= CPythonSkill::SKILL_GRADE_COUNT)
2085. iGradeIndex = CPythonSkill::SKILL_GRADE_COUNT-1;
2087. CGraphicImageInstance * pImageInstance = CGraphicImageInstance::New();
2088. pImageInstance->SetImagePointer(c_pSkillData->GradeData[iGradeIndex].pImage);
2090. return Py_BuildValue("i", pImageInstance);
2091. }
2093. PyObject * skillDeleteIconInstance(PyObject * poSelf, PyObject * poArgs)
2094. {
2095. int iHandle;
2096. if (!PyTuple_GetInteger(poArgs, 0, &iHandle))
2097. return Py_BadArgument();
2099. CGraphicImageInstance::Delete((CGraphicImageInstance *) iHandle);
2100. return Py_BuildNone();
2101. }
2103. PyObject * skillGetGradeData(PyObject * poSelf, PyObject * poArgs)
2104. {
2105. int iSkillIndex;
2106. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
2107. return Py_BadArgument();
2109. int iGradeIndex;
2110. if (!PyTuple_GetInteger(poArgs, 1, &iGradeIndex))
2111. return Py_BadArgument();
2113. CPythonSkill::SSkillData * c_pSkillData;
2114. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
2115. return Py_BuildException("skill.GetGradeData - Failed to find skill by %d", iSkillIndex);
2117. if (iGradeIndex < 0 || iGradeIndex >= CPythonSkill::SKILL_GRADE_COUNT)
2118. return Py_BuildException("Strange grade index [%d]", iSkillIndex, iGradeIndex);
2120. return Py_BuildValue("i", c_pSkillData->GradeData[iGradeIndex]);
2121. }
2123. PyObject * skillGetNewAffectDataCount(PyObject * poSelf, PyObject * poArgs)
2124. {
2125. int iSkillIndex;
2126. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
2127. return Py_BadArgument();
2129. CPythonSkill::SSkillData * c_pSkillData;
2130. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
2131. return Py_BuildException("skill.GetNewAffectDataCount - Failed to find skill by %d", iSkillIndex);
2133. return Py_BuildValue("i", c_pSkillData->AffectDataNewVector.size());
2134. }
2136. PyObject * skillGetNewAffectData(PyObject * poSelf, PyObject * poArgs)
2137. {
2138. int iSkillIndex;
2139. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
2140. return Py_BadArgument();
2141. int iAffectIndex;
2142. if (!PyTuple_GetInteger(poArgs, 1, &iAffectIndex))
2143. return Py_BadArgument();
2144. float fSkillLevel;
2145. if (!PyTuple_GetFloat(poArgs, 2, &fSkillLevel))
2146. return Py_BadArgument();
2148. CPythonSkill::SSkillData * pSkillData;
2149. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &pSkillData))
2150. return Py_BuildException("skill.GetNewAffectData - Failed to find skill by %d", iSkillIndex);
2152. if (iAffectIndex < 0 || iAffectIndex >= pSkillData->AffectDataNewVector.size())
2153. return Py_BuildException(" skill.GetNewAffectData - Strange AffectIndex %d", iAffectIndex);
2155. CPythonSkill::TAffectDataNew & rAffectData = pSkillData->AffectDataNewVector[iAffectIndex];
2157. CPoly minPoly;
2158. CPoly maxPoly;
2159. minPoly.SetRandom(CPoly::RANDOM_TYPE_FORCE_MIN);
2160. maxPoly.SetRandom(CPoly::RANDOM_TYPE_FORCE_MAX);
2161. minPoly.SetStr(rAffectData.strPointPoly.c_str());
2162. maxPoly.SetStr(rAffectData.strPointPoly.c_str());
2163. float fMinValue = pSkillData->ProcessFormula(&minPoly, fSkillLevel, CPythonSkill::VALUE_TYPE_MIN);
2164. float fMaxValue = pSkillData->ProcessFormula(&maxPoly, fSkillLevel, CPythonSkill::VALUE_TYPE_MAX);
2166. return Py_BuildValue("sff", rAffectData.strPointType.c_str(), fMinValue, fMaxValue);
2167. }
2169. PyObject * skillGetDuration(PyObject * poSelf, PyObject * poArgs)
2170. {
2171. int iSkillIndex;
2172. if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
2173. return Py_BadArgument();
2174. float fSkillLevel;
2175. if (!PyTuple_GetFloat(poArgs, 1, &fSkillLevel))
2176. return Py_BadArgument();
2178. CPythonSkill::SSkillData * c_pSkillData;
2179. if (!CPythonSkill::Instance().GetSkillData(iSkillIndex, &c_pSkillData))
2180. return Py_BuildException("skill.GetDuration - Failed to find skill by %d", iSkillIndex);
2182. return Py_BuildValue("i", c_pSkillData->GetDuration(fSkillLevel));
2183. }
2185. PyObject * skillTEST(PyObject * poSelf, PyObject * poArgs)
2186. {
2187. CPythonSkill::Instance().TEST();
2188. return Py_BuildNone();
2189. }
2191. void initskill()
2192. {
2193. static PyMethodDef s_methods[] =
2194. {
2195. { "SetPathName", skillSetPathName, METH_VARARGS },
2196. { "RegisterSkill", skillRegisterSkill, METH_VARARGS },
2197. { "LoadSkillData", skillLoadSkillData, METH_VARARGS },
2198. { "ClearSkillData", skillClearSkillData, METH_VARARGS },
2200. /////
2202. { "GetSkillName", skillGetSkillName, METH_VARARGS },
2203. { "GetSkillDescription", skillGetSkillDescription, METH_VARARGS },
2204. { "GetSkillType", skillGetSkillType, METH_VARARGS },
2205. { "GetSkillConditionDescriptionCount", skillGetSkillConditionDescriptionCount, METH_VARARGS },
2206. { "GetSkillConditionDescription", skillGetSkillConditionDescription, METH_VARARGS },
2207. { "GetSkillAffectDescriptionCount", skillGetSkillAffectDescriptionCount, METH_VARARGS },
2208. { "GetSkillAffectDescription", skillGetSkillAffectDescription, METH_VARARGS },
2209. { "GetSkillCoolTime", skillGetSkillCoolTime, METH_VARARGS },
2210. { "GetSkillNeedSP", skillGetSkillNeedSP, METH_VARARGS },
2211. { "GetSkillContinuationSP", skillGetSkillContinuationSP, METH_VARARGS },
2212. { "GetSkillMaxLevel", skillGetSkillMaxLevel, METH_VARARGS },
2213. { "GetSkillLevelUpPoint", skillGetSkillLevelUpPoint, METH_VARARGS },
2214. { "GetSkillLevelLimit", skillGetSkillLevelLimit, METH_VARARGS },
2215. { "IsSkillRequirement", skillIsSkillRequirement, METH_VARARGS },
2216. { "GetSkillRequirementData", skillGetSkillRequirementData, METH_VARARGS },
2217. { "GetSkillRequireStatCount", skillGetSkillRequireStatCount, METH_VARARGS },
2218. { "GetSkillRequireStatData", skillGetSkillRequireStatData, METH_VARARGS },
2219. { "CanLevelUpSkill", skillCanLevelUpSkill, METH_VARARGS },
2220. { "IsLevelUpSkill", skillIsLevelUpSkill, METH_VARARGS },
2221. { "CheckRequirementSueccess", skillCheckRequirementSueccess, METH_VARARGS },
2222. { "GetNeedCharacterLevel", skillGetNeedCharacterLevel, METH_VARARGS },
2223. { "IsToggleSkill", skillIsToggleSkill, METH_VARARGS },
2224. { "IsUseHPSkill", skillIsUseHPSkill, METH_VARARGS },
2225. { "IsStandingSkill", skillIsStandingSkill, METH_VARARGS },
2226. { "CanUseSkill", skillCanUseSkill, METH_VARARGS },
2227. { "GetIconName", skillGetIconName, METH_VARARGS },
2228. { "GetIconImage", skillGetIconImage, METH_VARARGS },
2229. { "GetIconImageNew", skillGetIconImageNew, METH_VARARGS },
2230. { "GetIconInstance", skillGetIconInstance, METH_VARARGS },
2231. { "GetIconInstanceNew", skillGetIconInstanceNew, METH_VARARGS },
2232. { "DeleteIconInstance", skillDeleteIconInstance, METH_VARARGS },
2233. { "GetGradeData", skillGetGradeData, METH_VARARGS },
2235. { "GetNewAffectDataCount", skillGetNewAffectDataCount, METH_VARARGS },
2236. { "GetNewAffectData", skillGetNewAffectData, METH_VARARGS },
2237. { "GetDuration", skillGetDuration, METH_VARARGS },
2239. { "TEST", skillTEST, METH_VARARGS },
2241. { NULL, NULL, NULL },
2242. };
2244. PyObject * poModule = Py_InitModule("skill", s_methods);
2245. PyModule_AddIntConstant(poModule, "SKILL_TYPE_NONE", CPythonSkill::SKILL_TYPE_NONE);
2246. PyModule_AddIntConstant(poModule, "SKILL_TYPE_ACTIVE", CPythonSkill::SKILL_TYPE_ACTIVE);
2247. PyModule_AddIntConstant(poModule, "SKILL_TYPE_SUPPORT", CPythonSkill::SKILL_TYPE_SUPPORT);
2248. PyModule_AddIntConstant(poModule, "SKILL_TYPE_GUILD", CPythonSkill::SKILL_TYPE_GUILD);
2249. PyModule_AddIntConstant(poModule, "SKILL_TYPE_HORSE", CPythonSkill::SKILL_TYPE_HORSE);
2250. PyModule_AddIntConstant(poModule, "SKILL_TYPE_MAX_NUM", CPythonSkill::SKILL_TYPE_MAX_NUM);
2252. PyModule_AddIntConstant(poModule, "SKILL_GRADE_COUNT", CPythonSkill::SKILL_GRADE_COUNT);
2253. PyModule_AddIntConstant(poModule, "SKILL_GRADE_STEP_COUNT", CPythonSkill::SKILL_GRADE_STEP_COUNT);
2254. PyModule_AddIntConstant(poModule, "SKILL_GRADEGAP", CPythonSkill::SKILL_GRADEGAP);
2255. PyModule_AddIntConstant(poModule, "SKILL_EFFECT_COUNT", CPythonSkill::SKILL_EFFECT_COUNT);
2256. }

PythonSkill.cpp