port 2V2-c: chrmgr/chr modules + race registration chain
PythonCharacterManagerModule/PythonCharacterModule ported verbatim; the 2V0 chr/chrmgr stubs are gone and initchr/initchrmgr run in 40250 order. The registration chain they need (RaceData/RaceDataFile/RaceManager/ RaceMotionData, GameType, AttributeData/AttributeInstance, TextFileLoader, Util, Camera/CameraProcedure) is ported; CRaceManager is created in PythonBoot. port.login_flow asserts race 0 has its wait motions and no unhandled packet header; port.login_live 8/8 against 192.168.21.203. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
shenlei
co-authored by
Claude Opus 5.5
Claude Opus 5.5
parent
62b6e23bfc
commit
996d793f0c
@@ -1,9 +0,0 @@
|
||||
#include "EterLib/StdAfx.h"
|
||||
#include "EterLib/Camera.h"
|
||||
#include "../PlatformStub.h"
|
||||
|
||||
CCamera* CCameraManager::GetCurrentCamera()
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
return nullptr;
|
||||
}
|
||||
@@ -75,229 +75,6 @@ void AddStubConstants_background(PyObject* poModule)
|
||||
PyModule_AddIntConstant(poModule, "TEXTURE_SORT", CMapOutdoor::TEXTURE_SORT);
|
||||
}
|
||||
|
||||
// 40250 UserInterface/PythonCharacterModule.cpp
|
||||
void AddStubConstants_chr(PyObject* poModule)
|
||||
{
|
||||
(void) poModule;
|
||||
PyModule_AddIntConstant(poModule, "PLAYER_NAME_MAX_LEN", PLAYER_NAME_MAX_LEN);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_NONE", CRaceMotionData::NAME_NONE);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_SPAWN", CRaceMotionData::NAME_SPAWN);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_WAIT", CRaceMotionData::NAME_WAIT);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_WALK", CRaceMotionData::NAME_WALK);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_RUN", CRaceMotionData::NAME_RUN);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_CHANGE_WEAPON", CRaceMotionData::NAME_CHANGE_WEAPON);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_DAMAGE", CRaceMotionData::NAME_DAMAGE);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_DAMAGE_FLYING", CRaceMotionData::NAME_DAMAGE_FLYING);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_STAND_UP", CRaceMotionData::NAME_STAND_UP);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_DAMAGE_BACK", CRaceMotionData::NAME_DAMAGE_BACK);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_DAMAGE_FLYING_BACK", CRaceMotionData::NAME_DAMAGE_FLYING_BACK);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_STAND_UP_BACK", CRaceMotionData::NAME_STAND_UP_BACK);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_DEAD", CRaceMotionData::NAME_DEAD);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_DEAD_BACK", CRaceMotionData::NAME_DEAD_BACK);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_NORMAL_ATTACK", CRaceMotionData::NAME_NORMAL_ATTACK);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_COMBO_ATTACK_1", CRaceMotionData::NAME_COMBO_ATTACK_1);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_COMBO_ATTACK_2", CRaceMotionData::NAME_COMBO_ATTACK_2);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_COMBO_ATTACK_3", CRaceMotionData::NAME_COMBO_ATTACK_3);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_COMBO_ATTACK_4", CRaceMotionData::NAME_COMBO_ATTACK_4);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_COMBO_ATTACK_5", CRaceMotionData::NAME_COMBO_ATTACK_5);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_COMBO_ATTACK_6", CRaceMotionData::NAME_COMBO_ATTACK_6);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_COMBO_ATTACK_7", CRaceMotionData::NAME_COMBO_ATTACK_7);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_COMBO_ATTACK_8", CRaceMotionData::NAME_COMBO_ATTACK_8);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_INTRO_WAIT", CRaceMotionData::NAME_INTRO_WAIT);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_INTRO_SELECTED", CRaceMotionData::NAME_INTRO_SELECTED);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_INTRO_NOT_SELECTED", CRaceMotionData::NAME_INTRO_NOT_SELECTED);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_FISHING_THROW", CRaceMotionData::NAME_FISHING_THROW);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_FISHING_WAIT", CRaceMotionData::NAME_FISHING_WAIT);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_FISHING_STOP", CRaceMotionData::NAME_FISHING_STOP);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_FISHING_REACT", CRaceMotionData::NAME_FISHING_REACT);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_FISHING_CATCH", CRaceMotionData::NAME_FISHING_CATCH);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_FISHING_FAIL", CRaceMotionData::NAME_FISHING_FAIL);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_STOP", CRaceMotionData::NAME_STOP);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_SKILL", CRaceMotionData::NAME_SKILL);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_CLAP", CRaceMotionData::NAME_CLAP);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_DANCE_1", CRaceMotionData::NAME_DANCE_1);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_DANCE_2", CRaceMotionData::NAME_DANCE_2);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_DANCE_3", CRaceMotionData::NAME_DANCE_3);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_DANCE_4", CRaceMotionData::NAME_DANCE_4);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_DANCE_5", CRaceMotionData::NAME_DANCE_5);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_DANCE_6", CRaceMotionData::NAME_DANCE_6);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_CONGRATULATION", CRaceMotionData::NAME_CONGRATULATION);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_FORGIVE", CRaceMotionData::NAME_FORGIVE);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_ANGRY", CRaceMotionData::NAME_ANGRY);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_ATTRACTIVE", CRaceMotionData::NAME_ATTRACTIVE);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_SAD", CRaceMotionData::NAME_SAD);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_SHY", CRaceMotionData::NAME_SHY);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_CHEERUP", CRaceMotionData::NAME_CHEERUP);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_BANTER", CRaceMotionData::NAME_BANTER);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_JOY", CRaceMotionData::NAME_JOY);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_CHEERS_1", CRaceMotionData::NAME_CHEERS_1);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_CHEERS_2", CRaceMotionData::NAME_CHEERS_2);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_KISS_WITH_WARRIOR", CRaceMotionData::NAME_KISS_WITH_WARRIOR);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_KISS_WITH_ASSASSIN", CRaceMotionData::NAME_KISS_WITH_ASSASSIN);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_KISS_WITH_SURA", CRaceMotionData::NAME_KISS_WITH_SURA);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_KISS_WITH_SHAMAN", CRaceMotionData::NAME_KISS_WITH_SHAMAN);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_FRENCH_KISS_WITH_WARRIOR", CRaceMotionData::NAME_FRENCH_KISS_WITH_WARRIOR);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_FRENCH_KISS_WITH_ASSASSIN", CRaceMotionData::NAME_FRENCH_KISS_WITH_ASSASSIN);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_FRENCH_KISS_WITH_SURA", CRaceMotionData::NAME_FRENCH_KISS_WITH_SURA);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_FRENCH_KISS_WITH_SHAMAN", CRaceMotionData::NAME_FRENCH_KISS_WITH_SHAMAN);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_SLAP_HIT_WITH_WARRIOR", CRaceMotionData::NAME_SLAP_HIT_WITH_WARRIOR);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_SLAP_HIT_WITH_ASSASSIN", CRaceMotionData::NAME_SLAP_HIT_WITH_ASSASSIN);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_SLAP_HIT_WITH_SURA", CRaceMotionData::NAME_SLAP_HIT_WITH_SURA);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_SLAP_HIT_WITH_SHAMAN", CRaceMotionData::NAME_SLAP_HIT_WITH_SHAMAN);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_SLAP_HURT_WITH_WARRIOR", CRaceMotionData::NAME_SLAP_HURT_WITH_WARRIOR);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_SLAP_HURT_WITH_ASSASSIN", CRaceMotionData::NAME_SLAP_HURT_WITH_ASSASSIN);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_SLAP_HURT_WITH_SURA", CRaceMotionData::NAME_SLAP_HURT_WITH_SURA);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_SLAP_HURT_WITH_SHAMAN", CRaceMotionData::NAME_SLAP_HURT_WITH_SHAMAN);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_DIG", CRaceMotionData::NAME_DIG);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_RESERVED", CRaceMotionData::MODE_RESERVED);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_GENERAL", CRaceMotionData::MODE_GENERAL);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_ONEHAND_SWORD", CRaceMotionData::MODE_ONEHAND_SWORD);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_TWOHAND_SWORD", CRaceMotionData::MODE_TWOHAND_SWORD);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_DUALHAND_SWORD", CRaceMotionData::MODE_DUALHAND_SWORD);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_BOW", CRaceMotionData::MODE_BOW);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_FAN", CRaceMotionData::MODE_FAN);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_BELL", CRaceMotionData::MODE_BELL);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_FISHING", CRaceMotionData::MODE_FISHING);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_HORSE", CRaceMotionData::MODE_HORSE);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_HORSE_ONEHAND_SWORD", CRaceMotionData::MODE_HORSE_ONEHAND_SWORD);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_HORSE_TWOHAND_SWORD", CRaceMotionData::MODE_HORSE_TWOHAND_SWORD);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_HORSE_DUALHAND_SWORD", CRaceMotionData::MODE_HORSE_DUALHAND_SWORD);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_HORSE_BOW", CRaceMotionData::MODE_HORSE_BOW);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_HORSE_FAN", CRaceMotionData::MODE_HORSE_FAN);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_HORSE_BELL", CRaceMotionData::MODE_HORSE_BELL);
|
||||
PyModule_AddIntConstant(poModule, "MOTION_MODE_WEDDING_DRESS", CRaceMotionData::MODE_WEDDING_DRESS);
|
||||
PyModule_AddIntConstant(poModule, "DIR_NORTH", CInstanceBase::DIR_NORTH);
|
||||
PyModule_AddIntConstant(poModule, "DIR_NORTHEAST", CInstanceBase::DIR_NORTHEAST);
|
||||
PyModule_AddIntConstant(poModule, "DIR_EAST", CInstanceBase::DIR_EAST);
|
||||
PyModule_AddIntConstant(poModule, "DIR_SOUTHEAST", CInstanceBase::DIR_SOUTHEAST);
|
||||
PyModule_AddIntConstant(poModule, "DIR_SOUTH", CInstanceBase::DIR_SOUTH);
|
||||
PyModule_AddIntConstant(poModule, "DIR_SOUTHWEST", CInstanceBase::DIR_SOUTHWEST);
|
||||
PyModule_AddIntConstant(poModule, "DIR_WEST", CInstanceBase::DIR_WEST);
|
||||
PyModule_AddIntConstant(poModule, "DIR_NORTHWEST", CInstanceBase::DIR_NORTHWEST);
|
||||
PyModule_AddIntConstant(poModule, "INSTANCE_TYPE_PLAYER", CActorInstance::TYPE_PC);
|
||||
PyModule_AddIntConstant(poModule, "INSTANCE_TYPE_NPC", CActorInstance::TYPE_NPC);
|
||||
PyModule_AddIntConstant(poModule, "INSTANCE_TYPE_ENEMY", CActorInstance::TYPE_ENEMY);
|
||||
PyModule_AddIntConstant(poModule, "INSTANCE_TYPE_BUILDING", CActorInstance::TYPE_BUILDING);
|
||||
PyModule_AddIntConstant(poModule, "INSTANCE_TYPE_OBJECT", CActorInstance::TYPE_OBJECT);
|
||||
PyModule_AddIntConstant(poModule, "PART_WEAPON", CRaceData::PART_WEAPON);
|
||||
PyModule_AddIntConstant(poModule, "PART_HEAD", CRaceData::PART_HEAD);
|
||||
PyModule_AddIntConstant(poModule, "PART_WEAPON_LEFT", CRaceData::PART_WEAPON_LEFT);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_POISON", CInstanceBase::AFFECT_POISON);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_SLOW", CInstanceBase::AFFECT_SLOW);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_STUN", CInstanceBase::AFFECT_STUN);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_MOV_SPEED_POTION", CInstanceBase::AFFECT_MOV_SPEED_POTION);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_ATT_SPEED_POTION", CInstanceBase::AFFECT_ATT_SPEED_POTION);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_FISH_MIND", CInstanceBase::AFFECT_FISH_MIND);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_JEONGWI", CInstanceBase::AFFECT_JEONGWI);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_GEOMGYEONG", CInstanceBase::AFFECT_GEOMGYEONG);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_CHEONGEUN", CInstanceBase::AFFECT_CHEONGEUN);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_GYEONGGONG", CInstanceBase::AFFECT_GYEONGGONG);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_EUNHYEONG", CInstanceBase::AFFECT_EUNHYEONG);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_GWIGEOM", CInstanceBase::AFFECT_GWIGEOM);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_GONGPO", CInstanceBase::AFFECT_GONGPO);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_JUMAGAP", CInstanceBase::AFFECT_JUMAGAP);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_HOSIN", CInstanceBase::AFFECT_HOSIN);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_BOHO", CInstanceBase::AFFECT_BOHO);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_KWAESOK", CInstanceBase::AFFECT_KWAESOK);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_HEUKSIN", CInstanceBase::AFFECT_HEUKSIN);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_MUYEONG", CInstanceBase::AFFECT_MUYEONG);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_GICHEON", CInstanceBase::AFFECT_GICHEON);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_JEUNGRYEOK", CInstanceBase::AFFECT_JEUNGRYEOK);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_PABEOP", CInstanceBase::AFFECT_PABEOP);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_FALLEN_CHEONGEUN", CInstanceBase::AFFECT_FALLEN_CHEONGEUN);
|
||||
PyModule_AddIntConstant(poModule, "AFFECT_CHINA_FIREWORK", CInstanceBase::AFFECT_CHINA_FIREWORK);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_MALL", CInstanceBase::NEW_AFFECT_MALL);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_NO_DEATH_PENALTY", CInstanceBase::NEW_AFFECT_NO_DEATH_PENALTY);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_SKILL_BOOK_BONUS", CInstanceBase::NEW_AFFECT_SKILL_BOOK_BONUS);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_SKILL_BOOK_NO_DELAY", CInstanceBase::NEW_AFFECT_SKILL_BOOK_NO_DELAY);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_EXP_BONUS", CInstanceBase::NEW_AFFECT_EXP_BONUS);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_EXP_BONUS_EURO_FREE", CInstanceBase::NEW_AFFECT_EXP_BONUS_EURO_FREE);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_EXP_BONUS_EURO_FREE_UNDER_15",CInstanceBase::NEW_AFFECT_EXP_BONUS_EURO_FREE_UNDER_15);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_ITEM_BONUS", CInstanceBase::NEW_AFFECT_ITEM_BONUS);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_SAFEBOX", CInstanceBase::NEW_AFFECT_SAFEBOX);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_AUTOLOOT", CInstanceBase::NEW_AFFECT_AUTOLOOT);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_FISH_MIND", CInstanceBase::NEW_AFFECT_FISH_MIND);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_MARRIAGE_FAST", CInstanceBase::NEW_AFFECT_MARRIAGE_FAST);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_GOLD_BONUS", CInstanceBase::NEW_AFFECT_GOLD_BONUS);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_AUTO_HP_RECOVERY", CInstanceBase::NEW_AFFECT_AUTO_HP_RECOVERY);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_AUTO_SP_RECOVERY", CInstanceBase::NEW_AFFECT_AUTO_SP_RECOVERY);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_DRAGON_SOUL_QUALIFIED", CInstanceBase::NEW_AFFECT_DRAGON_SOUL_QUALIFIED);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_DRAGON_SOUL_DECK1", CInstanceBase::NEW_AFFECT_DRAGON_SOUL_DECK1);
|
||||
PyModule_AddIntConstant(poModule, "NEW_AFFECT_DRAGON_SOUL_DECK2", CInstanceBase::NEW_AFFECT_DRAGON_SOUL_DECK2);
|
||||
}
|
||||
|
||||
// 40250 UserInterface/PythonCharacterManagerModule.cpp
|
||||
void AddStubConstants_chrmgr(PyObject* poModule)
|
||||
{
|
||||
(void) poModule;
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_MOB", CInstanceBase::NAMECOLOR_NORMAL_MOB);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_NPC", CInstanceBase::NAMECOLOR_NORMAL_NPC);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_PC", CInstanceBase::NAMECOLOR_NORMAL_PC);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_EMPIRE_MOB", CInstanceBase::NAMECOLOR_EMPIRE_MOB);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_EMPIRE_NPC", CInstanceBase::NAMECOLOR_EMPIRE_NPC);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_EMPIRE_PC", CInstanceBase::NAMECOLOR_EMPIRE_PC);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_FUNC", CInstanceBase::NAMECOLOR_FUNC);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_PK", CInstanceBase::NAMECOLOR_PK);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_PVP", CInstanceBase::NAMECOLOR_PVP);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_PARTY", CInstanceBase::NAMECOLOR_PARTY);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_WARP", CInstanceBase::NAMECOLOR_WARP);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_WAYPOINT", CInstanceBase::NAMECOLOR_WAYPOINT);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_EXTRA", CInstanceBase::NAMECOLOR_EXTRA);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SPAWN_DISAPPEAR", CInstanceBase::EFFECT_SPAWN_DISAPPEAR);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SPAWN_APPEAR", CInstanceBase::EFFECT_SPAWN_APPEAR);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DUST", CInstanceBase::EFFECT_DUST);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_HORSE_DUST", CInstanceBase::EFFECT_HORSE_DUST);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_STUN", CInstanceBase::EFFECT_STUN);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_HIT", CInstanceBase::EFFECT_HIT);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_FLAME_ATTACK", CInstanceBase::EFFECT_FLAME_ATTACK);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_FLAME_HIT", CInstanceBase::EFFECT_FLAME_HIT);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_FLAME_ATTACH", CInstanceBase::EFFECT_FLAME_ATTACH);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_ELECTRIC_ATTACK", CInstanceBase::EFFECT_ELECTRIC_ATTACK);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_ELECTRIC_HIT", CInstanceBase::EFFECT_ELECTRIC_HIT);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_ELECTRIC_ATTACH", CInstanceBase::EFFECT_ELECTRIC_ATTACH);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SELECT", CInstanceBase::EFFECT_SELECT);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_TARGET", CInstanceBase::EFFECT_TARGET);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_CRITICAL", CInstanceBase::EFFECT_CRITICAL);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_TARGET", CInstanceBase::EFFECT_DAMAGE_TARGET);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_NOT_TARGET", CInstanceBase::EFFECT_DAMAGE_NOT_TARGET);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_SELFDAMAGE", CInstanceBase::EFFECT_DAMAGE_SELFDAMAGE);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_SELFDAMAGE2", CInstanceBase::EFFECT_DAMAGE_SELFDAMAGE2);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_POISON", CInstanceBase::EFFECT_DAMAGE_POISON);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_MISS", CInstanceBase::EFFECT_DAMAGE_MISS);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_TARGETMISS", CInstanceBase::EFFECT_DAMAGE_TARGETMISS);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_CRITICAL", CInstanceBase::EFFECT_DAMAGE_CRITICAL);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_LEVELUP", CInstanceBase::EFFECT_LEVELUP);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SKILLUP", CInstanceBase::EFFECT_SKILLUP);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_HPUP_RED", CInstanceBase::EFFECT_HPUP_RED);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SPUP_BLUE", CInstanceBase::EFFECT_SPUP_BLUE);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SPEEDUP_GREEN", CInstanceBase::EFFECT_SPEEDUP_GREEN);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DXUP_PURPLE", CInstanceBase::EFFECT_DXUP_PURPLE);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_PENETRATE", CInstanceBase::EFFECT_PENETRATE);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_BLOCK", CInstanceBase::EFFECT_BLOCK);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DODGE", CInstanceBase::EFFECT_DODGE);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_FIRECRACKER", CInstanceBase::EFFECT_FIRECRACKER);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SPIN_TOP", CInstanceBase::EFFECT_SPIN_TOP);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_WEAPON", CInstanceBase::EFFECT_WEAPON);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_AFFECT", CInstanceBase::EFFECT_AFFECT);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_EMOTICON", CInstanceBase::EFFECT_EMOTICON);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_EMPIRE", CInstanceBase::EFFECT_EMPIRE);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_REFINED", CInstanceBase::EFFECT_REFINED);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SUCCESS", CInstanceBase::EFFECT_SUCCESS) ;
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_FAIL", CInstanceBase::EFFECT_FAIL) ;
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_FR_SUCCESS", CInstanceBase::EFFECT_FR_SUCCESS) ;
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_LEVELUP_ON_14_FOR_GERMANY", CInstanceBase::EFFECT_LEVELUP_ON_14_FOR_GERMANY ); //레벨업 14일때 ( 독일전용 )
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_LEVELUP_UNDER_15_FOR_GERMANY", CInstanceBase::EFFECT_LEVELUP_UNDER_15_FOR_GERMANY );//레벨업 15일때 ( 독일전용 )
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_PERCENT_DAMAGE1", CInstanceBase::EFFECT_PERCENT_DAMAGE1);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_PERCENT_DAMAGE2", CInstanceBase::EFFECT_PERCENT_DAMAGE2);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_PERCENT_DAMAGE3", CInstanceBase::EFFECT_PERCENT_DAMAGE3);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_AUTO_HPUP", CInstanceBase::EFFECT_AUTO_HPUP);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_AUTO_SPUP", CInstanceBase::EFFECT_AUTO_SPUP);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_RAMADAN_RING_EQUIP", CInstanceBase::EFFECT_RAMADAN_RING_EQUIP);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_HALLOWEEN_CANDY_EQUIP", CInstanceBase::EFFECT_HALLOWEEN_CANDY_EQUIP);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_HAPPINESS_RING_EQUIP", CInstanceBase::EFFECT_HAPPINESS_RING_EQUIP);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_LOVE_PENDANT_EQUIP", CInstanceBase::EFFECT_LOVE_PENDANT_EQUIP);
|
||||
}
|
||||
|
||||
// 40250 UserInterface/PythonEffectModule.cpp
|
||||
enum
|
||||
{
|
||||
|
||||
@@ -7,8 +7,6 @@
|
||||
// GameplayModuleConstants.cpp: each module's 40250 constants.
|
||||
void AddStubConstants_ServerStateChecker(PyObject* poModule);
|
||||
void AddStubConstants_background(PyObject* poModule);
|
||||
void AddStubConstants_chr(PyObject* poModule);
|
||||
void AddStubConstants_chrmgr(PyObject* poModule);
|
||||
void AddStubConstants_effect(PyObject* poModule);
|
||||
void AddStubConstants_event(PyObject* poModule);
|
||||
void AddStubConstants_eventMgr(PyObject* poModule);
|
||||
@@ -153,244 +151,6 @@ PyMethodDef methods_background[] = {
|
||||
{ "WarpTest", stub_background_WarpTest, METH_VARARGS },
|
||||
{ NULL, NULL }
|
||||
};
|
||||
// 40250 UserInterface/PythonCharacterModule.cpp: chr export names.
|
||||
PyObject* stub_chr_DismountHorse(PyObject*, PyObject*) { return stub_call_named("chr.DismountHorse", Py_BuildNone()); }
|
||||
PyObject* stub_chr_MountHorse(PyObject*, PyObject*) { return stub_call_named("chr.MountHorse", Py_BuildNone()); }
|
||||
PyObject* stub_chr_Destroy(PyObject*, PyObject*) { return stub_call_named("chr.Destroy", Py_BuildNone()); }
|
||||
PyObject* stub_chr_Update(PyObject*, PyObject*) { return stub_call_named("chr.Update", Py_BuildNone()); }
|
||||
PyObject* stub_chr_Deform(PyObject*, PyObject*) { return stub_call_named("chr.Deform", Py_BuildNone()); }
|
||||
PyObject* stub_chr_Render(PyObject*, PyObject*) { return stub_call_named("chr.Render", Py_BuildNone()); }
|
||||
PyObject* stub_chr_RenderCollision(PyObject*, PyObject*) { return stub_call_named("chr.RenderCollision", Py_BuildNone()); }
|
||||
PyObject* stub_chr_CreateInstance(PyObject*, PyObject*) { return stub_call_named("chr.CreateInstance", Py_BuildNone()); }
|
||||
PyObject* stub_chr_DeleteInstance(PyObject*, PyObject*) { return stub_call_named("chr.DeleteInstance", Py_BuildNone()); }
|
||||
PyObject* stub_chr_DeleteInstanceByFade(PyObject*, PyObject*) { return stub_call_named("chr.DeleteInstanceByFade", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SelectInstance(PyObject*, PyObject*) { return stub_call_named("chr.SelectInstance", Py_BuildNone()); }
|
||||
PyObject* stub_chr_HasInstance(PyObject*, PyObject*) { return stub_call_named("chr.HasInstance", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chr_IsEnemy(PyObject*, PyObject*) { return stub_call_named("chr.IsEnemy", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chr_IsNPC(PyObject*, PyObject*) { return stub_call_named("chr.IsNPC", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chr_IsGameMaster(PyObject*, PyObject*) { return stub_call_named("chr.IsGameMaster", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chr_IsPartyMember(PyObject*, PyObject*) { return stub_call_named("chr.IsPartyMember", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chr_Select(PyObject*, PyObject*) { return stub_call_named("chr.Select", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetAddRenderMode(PyObject*, PyObject*) { return stub_call_named("chr.SetAddRenderMode", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetBlendRenderMode(PyObject*, PyObject*) { return stub_call_named("chr.SetBlendRenderMode", Py_BuildNone()); }
|
||||
PyObject* stub_chr_Unselect(PyObject*, PyObject*) { return stub_call_named("chr.Unselect", Py_BuildNone()); }
|
||||
PyObject* stub_chr_Hide(PyObject*, PyObject*) { return stub_call_named("chr.Hide", Py_BuildNone()); }
|
||||
PyObject* stub_chr_Show(PyObject*, PyObject*) { return stub_call_named("chr.Show", Py_BuildNone()); }
|
||||
PyObject* stub_chr_Pick(PyObject*, PyObject*) { return stub_call_named("chr.Pick", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chr_PickAll(PyObject*, PyObject*) { return stub_call_named("chr.PickAll", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chr_SetArmor(PyObject*, PyObject*) { return stub_call_named("chr.SetArmor", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetWeapon(PyObject*, PyObject*) { return stub_call_named("chr.SetWeapon", Py_BuildNone()); }
|
||||
PyObject* stub_chr_ChangeShape(PyObject*, PyObject*) { return stub_call_named("chr.ChangeShape", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetRace(PyObject*, PyObject*) { return stub_call_named("chr.SetRace", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetHair(PyObject*, PyObject*) { return stub_call_named("chr.SetHair", Py_BuildNone()); }
|
||||
PyObject* stub_chr_ChangeHair(PyObject*, PyObject*) { return stub_call_named("chr.ChangeHair", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetVirtualID(PyObject*, PyObject*) { return stub_call_named("chr.SetVirtualID", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetNameString(PyObject*, PyObject*) { return stub_call_named("chr.SetNameString", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetInstanceType(PyObject*, PyObject*) { return stub_call_named("chr.SetInstanceType", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetPixelPosition(PyObject*, PyObject*) { return stub_call_named("chr.SetPixelPosition", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetDirection(PyObject*, PyObject*) { return stub_call_named("chr.SetDirection", Py_BuildNone()); }
|
||||
PyObject* stub_chr_Refresh(PyObject*, PyObject*) { return stub_call_named("chr.Refresh", Py_BuildNone()); }
|
||||
PyObject* stub_chr_Revive(PyObject*, PyObject*) { return stub_call_named("chr.Revive", Py_BuildNone()); }
|
||||
PyObject* stub_chr_Die(PyObject*, PyObject*) { return stub_call_named("chr.Die", Py_BuildNone()); }
|
||||
PyObject* stub_chr_AttachEffectByID(PyObject*, PyObject*) { return stub_call_named("chr.AttachEffectByID", Py_BuildNone()); }
|
||||
PyObject* stub_chr_AttachEffectByName(PyObject*, PyObject*) { return stub_call_named("chr.AttachEffectByName", Py_BuildNone()); }
|
||||
PyObject* stub_chr_LookAt(PyObject*, PyObject*) { return stub_call_named("chr.LookAt", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetMotionMode(PyObject*, PyObject*) { return stub_call_named("chr.SetMotionMode", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetLoopMotion(PyObject*, PyObject*) { return stub_call_named("chr.SetLoopMotion", Py_BuildNone()); }
|
||||
PyObject* stub_chr_BlendLoopMotion(PyObject*, PyObject*) { return stub_call_named("chr.BlendLoopMotion", Py_BuildNone()); }
|
||||
PyObject* stub_chr_PushOnceMotion(PyObject*, PyObject*) { return stub_call_named("chr.PushOnceMotion", Py_BuildNone()); }
|
||||
PyObject* stub_chr_PushLoopMotion(PyObject*, PyObject*) { return stub_call_named("chr.PushLoopMotion", Py_BuildNone()); }
|
||||
PyObject* stub_chr_GetPixelPosition(PyObject*, PyObject*) { return stub_call_named("chr.GetPixelPosition", Py_BuildValue("fff", 0.0, 0.0, 0.0)); }
|
||||
PyObject* stub_chr_SetRotation(PyObject*, PyObject*) { return stub_call_named("chr.SetRotation", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetRotationAll(PyObject*, PyObject*) { return stub_call_named("chr.SetRotationAll", Py_BuildNone()); }
|
||||
PyObject* stub_chr_BlendRotation(PyObject*, PyObject*) { return stub_call_named("chr.BlendRotation", Py_BuildNone()); }
|
||||
PyObject* stub_chr_GetRotation(PyObject*, PyObject*) { return stub_call_named("chr.GetRotation", Py_BuildValue("f", 0.0)); }
|
||||
PyObject* stub_chr_GetRace(PyObject*, PyObject*) { return stub_call_named("chr.GetRace", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chr_GetName(PyObject*, PyObject*) { return stub_call_named("chr.GetName", Py_BuildValue("s", "")); }
|
||||
PyObject* stub_chr_GetNameByVID(PyObject*, PyObject*) { return stub_call_named("chr.GetNameByVID", Py_BuildValue("s", "")); }
|
||||
PyObject* stub_chr_GetGuildID(PyObject*, PyObject*) { return stub_call_named("chr.GetGuildID", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chr_GetProjectPosition(PyObject*, PyObject*) { return stub_call_named("chr.GetProjectPosition", Py_BuildValue("ii", 0, 0)); }
|
||||
PyObject* stub_chr_GetVirtualNumber(PyObject*, PyObject*) { return stub_call_named("chr.GetVirtualNumber", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chr_GetInstanceType(PyObject*, PyObject*) { return stub_call_named("chr.GetInstanceType", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chr_GetBoundBoxOnlyXY(PyObject*, PyObject*) { return stub_call_named("chr.GetBoundBoxOnlyXY", Py_BuildValue("ffff", 0.0, 0.0, 0.0, 0.0)); }
|
||||
PyObject* stub_chr_RaceToJob(PyObject*, PyObject*) { return stub_call_named("chr.RaceToJob", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chr_RaceToSex(PyObject*, PyObject*) { return stub_call_named("chr.RaceToSex", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chr_testGetPKData(PyObject*, PyObject*) { return stub_call_named("chr.testGetPKData", Py_BuildValue("ii", 0, 0)); }
|
||||
PyObject* stub_chr_FaintTest(PyObject*, PyObject*) { return stub_call_named("chr.FaintTest", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetMoveSpeed(PyObject*, PyObject*) { return stub_call_named("chr.SetMoveSpeed", Py_BuildNone()); }
|
||||
PyObject* stub_chr_SetAttackSpeed(PyObject*, PyObject*) { return stub_call_named("chr.SetAttackSpeed", Py_BuildNone()); }
|
||||
PyObject* stub_chr_WeaponTraceSetTexture(PyObject*, PyObject*) { return stub_call_named("chr.WeaponTraceSetTexture", Py_BuildNone()); }
|
||||
PyObject* stub_chr_WeaponTraceUseAlpha(PyObject*, PyObject*) { return stub_call_named("chr.WeaponTraceUseAlpha", Py_BuildNone()); }
|
||||
PyObject* stub_chr_WeaponTraceUseTexture(PyObject*, PyObject*) { return stub_call_named("chr.WeaponTraceUseTexture", Py_BuildNone()); }
|
||||
PyObject* stub_chr_MoveToDestPosition(PyObject*, PyObject*) { return stub_call_named("chr.MoveToDestPosition", Py_BuildNone()); }
|
||||
PyObject* stub_chr_testSetComboType(PyObject*, PyObject*) { return stub_call_named("chr.testSetComboType", Py_BuildNone()); }
|
||||
PyObject* stub_chr_testSetAddRenderMode(PyObject*, PyObject*) { return stub_call_named("chr.testSetAddRenderMode", Py_BuildNone()); }
|
||||
PyObject* stub_chr_testSetModulateRenderMode(PyObject*, PyObject*) { return stub_call_named("chr.testSetModulateRenderMode", Py_BuildNone()); }
|
||||
PyObject* stub_chr_testSetAddRenderModeRGB(PyObject*, PyObject*) { return stub_call_named("chr.testSetAddRenderModeRGB", Py_BuildNone()); }
|
||||
PyObject* stub_chr_testSetModulateRenderModeRGB(PyObject*, PyObject*) { return stub_call_named("chr.testSetModulateRenderModeRGB", Py_BuildNone()); }
|
||||
PyObject* stub_chr_testSetSpecularRenderMode(PyObject*, PyObject*) { return stub_call_named("chr.testSetSpecularRenderMode", Py_BuildNone()); }
|
||||
PyObject* stub_chr_testSetSpecularRenderMode2(PyObject*, PyObject*) { return stub_call_named("chr.testSetSpecularRenderMode2", Py_BuildNone()); }
|
||||
PyObject* stub_chr_testRestoreRenderMode(PyObject*, PyObject*) { return stub_call_named("chr.testRestoreRenderMode", Py_BuildNone()); }
|
||||
PyObject* stub_chr_testSetRideMan(PyObject*, PyObject*) { return stub_call_named("chr.testSetRideMan", Py_BuildNone()); }
|
||||
PyMethodDef methods_chr[] = {
|
||||
{ "DismountHorse", stub_chr_DismountHorse, METH_VARARGS },
|
||||
{ "MountHorse", stub_chr_MountHorse, METH_VARARGS },
|
||||
{ "Destroy", stub_chr_Destroy, METH_VARARGS },
|
||||
{ "Update", stub_chr_Update, METH_VARARGS },
|
||||
{ "Deform", stub_chr_Deform, METH_VARARGS },
|
||||
{ "Render", stub_chr_Render, METH_VARARGS },
|
||||
{ "RenderCollision", stub_chr_RenderCollision, METH_VARARGS },
|
||||
{ "CreateInstance", stub_chr_CreateInstance, METH_VARARGS },
|
||||
{ "DeleteInstance", stub_chr_DeleteInstance, METH_VARARGS },
|
||||
{ "DeleteInstanceByFade", stub_chr_DeleteInstanceByFade, METH_VARARGS },
|
||||
{ "SelectInstance", stub_chr_SelectInstance, METH_VARARGS },
|
||||
{ "HasInstance", stub_chr_HasInstance, METH_VARARGS },
|
||||
{ "IsEnemy", stub_chr_IsEnemy, METH_VARARGS },
|
||||
{ "IsNPC", stub_chr_IsNPC, METH_VARARGS },
|
||||
{ "IsGameMaster", stub_chr_IsGameMaster, METH_VARARGS },
|
||||
{ "IsPartyMember", stub_chr_IsPartyMember, METH_VARARGS },
|
||||
{ "Select", stub_chr_Select, METH_VARARGS },
|
||||
{ "SetAddRenderMode", stub_chr_SetAddRenderMode, METH_VARARGS },
|
||||
{ "SetBlendRenderMode", stub_chr_SetBlendRenderMode, METH_VARARGS },
|
||||
{ "Unselect", stub_chr_Unselect, METH_VARARGS },
|
||||
{ "Hide", stub_chr_Hide, METH_VARARGS },
|
||||
{ "Show", stub_chr_Show, METH_VARARGS },
|
||||
{ "Pick", stub_chr_Pick, METH_VARARGS },
|
||||
{ "PickAll", stub_chr_PickAll, METH_VARARGS },
|
||||
{ "SetArmor", stub_chr_SetArmor, METH_VARARGS },
|
||||
{ "SetWeapon", stub_chr_SetWeapon, METH_VARARGS },
|
||||
{ "ChangeShape", stub_chr_ChangeShape, METH_VARARGS },
|
||||
{ "SetRace", stub_chr_SetRace, METH_VARARGS },
|
||||
{ "SetHair", stub_chr_SetHair, METH_VARARGS },
|
||||
{ "ChangeHair", stub_chr_ChangeHair, METH_VARARGS },
|
||||
{ "SetVirtualID", stub_chr_SetVirtualID, METH_VARARGS },
|
||||
{ "SetNameString", stub_chr_SetNameString, METH_VARARGS },
|
||||
{ "SetInstanceType", stub_chr_SetInstanceType, METH_VARARGS },
|
||||
{ "SetPixelPosition", stub_chr_SetPixelPosition, METH_VARARGS },
|
||||
{ "SetDirection", stub_chr_SetDirection, METH_VARARGS },
|
||||
{ "Refresh", stub_chr_Refresh, METH_VARARGS },
|
||||
{ "Revive", stub_chr_Revive, METH_VARARGS },
|
||||
{ "Die", stub_chr_Die, METH_VARARGS },
|
||||
{ "AttachEffectByID", stub_chr_AttachEffectByID, METH_VARARGS },
|
||||
{ "AttachEffectByName", stub_chr_AttachEffectByName, METH_VARARGS },
|
||||
{ "LookAt", stub_chr_LookAt, METH_VARARGS },
|
||||
{ "SetMotionMode", stub_chr_SetMotionMode, METH_VARARGS },
|
||||
{ "SetLoopMotion", stub_chr_SetLoopMotion, METH_VARARGS },
|
||||
{ "BlendLoopMotion", stub_chr_BlendLoopMotion, METH_VARARGS },
|
||||
{ "PushOnceMotion", stub_chr_PushOnceMotion, METH_VARARGS },
|
||||
{ "PushLoopMotion", stub_chr_PushLoopMotion, METH_VARARGS },
|
||||
{ "GetPixelPosition", stub_chr_GetPixelPosition, METH_VARARGS },
|
||||
{ "SetRotation", stub_chr_SetRotation, METH_VARARGS },
|
||||
{ "SetRotationAll", stub_chr_SetRotationAll, METH_VARARGS },
|
||||
{ "BlendRotation", stub_chr_BlendRotation, METH_VARARGS },
|
||||
{ "GetRotation", stub_chr_GetRotation, METH_VARARGS },
|
||||
{ "GetRace", stub_chr_GetRace, METH_VARARGS },
|
||||
{ "GetName", stub_chr_GetName, METH_VARARGS },
|
||||
{ "GetNameByVID", stub_chr_GetNameByVID, METH_VARARGS },
|
||||
{ "GetGuildID", stub_chr_GetGuildID, METH_VARARGS },
|
||||
{ "GetProjectPosition", stub_chr_GetProjectPosition, METH_VARARGS },
|
||||
{ "GetVirtualNumber", stub_chr_GetVirtualNumber, METH_VARARGS },
|
||||
{ "GetInstanceType", stub_chr_GetInstanceType, METH_VARARGS },
|
||||
{ "GetBoundBoxOnlyXY", stub_chr_GetBoundBoxOnlyXY, METH_VARARGS },
|
||||
{ "RaceToJob", stub_chr_RaceToJob, METH_VARARGS },
|
||||
{ "RaceToSex", stub_chr_RaceToSex, METH_VARARGS },
|
||||
{ "testGetPKData", stub_chr_testGetPKData, METH_VARARGS },
|
||||
{ "FaintTest", stub_chr_FaintTest, METH_VARARGS },
|
||||
{ "SetMoveSpeed", stub_chr_SetMoveSpeed, METH_VARARGS },
|
||||
{ "SetAttackSpeed", stub_chr_SetAttackSpeed, METH_VARARGS },
|
||||
{ "WeaponTraceSetTexture", stub_chr_WeaponTraceSetTexture, METH_VARARGS },
|
||||
{ "WeaponTraceUseAlpha", stub_chr_WeaponTraceUseAlpha, METH_VARARGS },
|
||||
{ "WeaponTraceUseTexture", stub_chr_WeaponTraceUseTexture, METH_VARARGS },
|
||||
{ "MoveToDestPosition", stub_chr_MoveToDestPosition, METH_VARARGS },
|
||||
{ "testSetComboType", stub_chr_testSetComboType, METH_VARARGS },
|
||||
{ "testSetAddRenderMode", stub_chr_testSetAddRenderMode, METH_VARARGS },
|
||||
{ "testSetModulateRenderMode", stub_chr_testSetModulateRenderMode, METH_VARARGS },
|
||||
{ "testSetAddRenderModeRGB", stub_chr_testSetAddRenderModeRGB, METH_VARARGS },
|
||||
{ "testSetModulateRenderModeRGB", stub_chr_testSetModulateRenderModeRGB, METH_VARARGS },
|
||||
{ "testSetSpecularRenderMode", stub_chr_testSetSpecularRenderMode, METH_VARARGS },
|
||||
{ "testSetSpecularRenderMode2", stub_chr_testSetSpecularRenderMode2, METH_VARARGS },
|
||||
{ "testRestoreRenderMode", stub_chr_testRestoreRenderMode, METH_VARARGS },
|
||||
{ "testSetRideMan", stub_chr_testSetRideMan, METH_VARARGS },
|
||||
{ NULL, NULL }
|
||||
};
|
||||
// 40250 UserInterface/PythonCharacterManagerModule.cpp: chrmgr export names.
|
||||
PyObject* stub_chrmgr_SetEmpireNameMode(PyObject*, PyObject*) { return stub_call_named("chrmgr.SetEmpireNameMode", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_GetVIDInfo(PyObject*, PyObject*) { return stub_call_named("chrmgr.GetVIDInfo", Py_BuildValue("s", "")); }
|
||||
PyObject* stub_chrmgr_GetPickedVID(PyObject*, PyObject*) { return stub_call_named("chrmgr.GetPickedVID", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chrmgr_SetShapeModel(PyObject*, PyObject*) { return stub_call_named("chrmgr.SetShapeModel", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_AppendShapeSkin(PyObject*, PyObject*) { return stub_call_named("chrmgr.AppendShapeSkin", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_SetPathName(PyObject*, PyObject*) { return stub_call_named("chrmgr.SetPathName", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_LoadRaceData(PyObject*, PyObject*) { return stub_call_named("chrmgr.LoadRaceData", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_LoadLocalRaceData(PyObject*, PyObject*) { return stub_call_named("chrmgr.LoadLocalRaceData", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_CreateRace(PyObject*, PyObject*) { return stub_call_named("chrmgr.CreateRace", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_SelectRace(PyObject*, PyObject*) { return stub_call_named("chrmgr.SelectRace", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterAttachingBoneName(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterAttachingBoneName", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterMotionMode(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterMotionMode", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterMotion(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterMotion", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_SetMotionRandomWeight(PyObject*, PyObject*) { return stub_call_named("chrmgr.SetMotionRandomWeight", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterNormalAttack(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterNormalAttack", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_ReserveComboAttack(PyObject*, PyObject*) { return stub_call_named("chrmgr.ReserveComboAttack", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterComboAttack(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterComboAttack", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_ReserveComboAttackNew(PyObject*, PyObject*) { return stub_call_named("chrmgr.ReserveComboAttackNew", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterComboAttackNew(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterComboAttackNew", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterMotionData(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterMotionData", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterRaceName(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterRaceName", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterRaceSrcName(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterRaceSrcName", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterCacheMotionData(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterCacheMotionData", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_SetAffect(PyObject*, PyObject*) { return stub_call_named("chrmgr.SetAffect", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_SetEmoticon(PyObject*, PyObject*) { return stub_call_named("chrmgr.SetEmoticon", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_IsPossibleEmoticon(PyObject*, PyObject*) { return stub_call_named("chrmgr.IsPossibleEmoticon", Py_BuildValue("i", 0)); }
|
||||
PyObject* stub_chrmgr_RegisterEffect(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterEffect", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterCacheEffect(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterCacheEffect", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterPointEffect(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterPointEffect", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_ShowPointEffect(PyObject*, PyObject*) { return stub_call_named("chrmgr.ShowPointEffect", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_ToggleDirectionLine(PyObject*, PyObject*) { return stub_call_named("chrmgr.ToggleDirectionLine", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_SetMovingSpeed(PyObject*, PyObject*) { return stub_call_named("chrmgr.SetMovingSpeed", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_SetDustGap(PyObject*, PyObject*) { return stub_call_named("chrmgr.SetDustGap", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_SetHorseDustGap(PyObject*, PyObject*) { return stub_call_named("chrmgr.SetHorseDustGap", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterTitleName(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterTitleName", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterNameColor(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterNameColor", Py_BuildNone()); }
|
||||
PyObject* stub_chrmgr_RegisterTitleColor(PyObject*, PyObject*) { return stub_call_named("chrmgr.RegisterTitleColor", Py_BuildNone()); }
|
||||
PyMethodDef methods_chrmgr[] = {
|
||||
{ "SetEmpireNameMode", stub_chrmgr_SetEmpireNameMode, METH_VARARGS },
|
||||
{ "GetVIDInfo", stub_chrmgr_GetVIDInfo, METH_VARARGS },
|
||||
{ "GetPickedVID", stub_chrmgr_GetPickedVID, METH_VARARGS },
|
||||
{ "SetShapeModel", stub_chrmgr_SetShapeModel, METH_VARARGS },
|
||||
{ "AppendShapeSkin", stub_chrmgr_AppendShapeSkin, METH_VARARGS },
|
||||
{ "SetPathName", stub_chrmgr_SetPathName, METH_VARARGS },
|
||||
{ "LoadRaceData", stub_chrmgr_LoadRaceData, METH_VARARGS },
|
||||
{ "LoadLocalRaceData", stub_chrmgr_LoadLocalRaceData, METH_VARARGS },
|
||||
{ "CreateRace", stub_chrmgr_CreateRace, METH_VARARGS },
|
||||
{ "SelectRace", stub_chrmgr_SelectRace, METH_VARARGS },
|
||||
{ "RegisterAttachingBoneName", stub_chrmgr_RegisterAttachingBoneName, METH_VARARGS },
|
||||
{ "RegisterMotionMode", stub_chrmgr_RegisterMotionMode, METH_VARARGS },
|
||||
{ "RegisterMotion", stub_chrmgr_RegisterMotion, METH_VARARGS },
|
||||
{ "SetMotionRandomWeight", stub_chrmgr_SetMotionRandomWeight, METH_VARARGS },
|
||||
{ "RegisterNormalAttack", stub_chrmgr_RegisterNormalAttack, METH_VARARGS },
|
||||
{ "ReserveComboAttack", stub_chrmgr_ReserveComboAttack, METH_VARARGS },
|
||||
{ "RegisterComboAttack", stub_chrmgr_RegisterComboAttack, METH_VARARGS },
|
||||
{ "ReserveComboAttackNew", stub_chrmgr_ReserveComboAttackNew, METH_VARARGS },
|
||||
{ "RegisterComboAttackNew", stub_chrmgr_RegisterComboAttackNew, METH_VARARGS },
|
||||
{ "RegisterMotionData", stub_chrmgr_RegisterMotionData, METH_VARARGS },
|
||||
{ "RegisterRaceName", stub_chrmgr_RegisterRaceName, METH_VARARGS },
|
||||
{ "RegisterRaceSrcName", stub_chrmgr_RegisterRaceSrcName, METH_VARARGS },
|
||||
{ "RegisterCacheMotionData", stub_chrmgr_RegisterCacheMotionData, METH_VARARGS },
|
||||
{ "SetAffect", stub_chrmgr_SetAffect, METH_VARARGS },
|
||||
{ "SetEmoticon", stub_chrmgr_SetEmoticon, METH_VARARGS },
|
||||
{ "IsPossibleEmoticon", stub_chrmgr_IsPossibleEmoticon, METH_VARARGS },
|
||||
{ "RegisterEffect", stub_chrmgr_RegisterEffect, METH_VARARGS },
|
||||
{ "RegisterCacheEffect", stub_chrmgr_RegisterCacheEffect, METH_VARARGS },
|
||||
{ "RegisterPointEffect", stub_chrmgr_RegisterPointEffect, METH_VARARGS },
|
||||
{ "ShowPointEffect", stub_chrmgr_ShowPointEffect, METH_VARARGS },
|
||||
{ "ToggleDirectionLine", stub_chrmgr_ToggleDirectionLine, METH_VARARGS },
|
||||
{ "SetMovingSpeed", stub_chrmgr_SetMovingSpeed, METH_VARARGS },
|
||||
{ "SetDustGap", stub_chrmgr_SetDustGap, METH_VARARGS },
|
||||
{ "SetHorseDustGap", stub_chrmgr_SetHorseDustGap, METH_VARARGS },
|
||||
{ "RegisterTitleName", stub_chrmgr_RegisterTitleName, METH_VARARGS },
|
||||
{ "RegisterNameColor", stub_chrmgr_RegisterNameColor, METH_VARARGS },
|
||||
{ "RegisterTitleColor", stub_chrmgr_RegisterTitleColor, METH_VARARGS },
|
||||
{ NULL, NULL }
|
||||
};
|
||||
// 40250 UserInterface/PythonEffectModule.cpp: effect export names.
|
||||
PyObject* stub_effect_RegisterEffect(PyObject*, PyObject*) { return stub_call_named("effect.RegisterEffect", Py_BuildNone()); }
|
||||
PyObject* stub_effect_CreateEffect(PyObject*, PyObject*) { return stub_call_named("effect.CreateEffect", Py_BuildValue("i", 0)); }
|
||||
@@ -1437,16 +1197,6 @@ void init_2v0_gameplay_stubs() {
|
||||
PyModule_AddIntConstant(module, "__port_stub__", 1);
|
||||
AddStubConstants_background(module);
|
||||
}
|
||||
{
|
||||
PyObject* module = Py_InitModule("chr", methods_chr);
|
||||
PyModule_AddIntConstant(module, "__port_stub__", 1);
|
||||
AddStubConstants_chr(module);
|
||||
}
|
||||
{
|
||||
PyObject* module = Py_InitModule("chrmgr", methods_chrmgr);
|
||||
PyModule_AddIntConstant(module, "__port_stub__", 1);
|
||||
AddStubConstants_chrmgr(module);
|
||||
}
|
||||
{
|
||||
PyObject* module = Py_InitModule("effect", methods_effect);
|
||||
PyModule_AddIntConstant(module, "__port_stub__", 1);
|
||||
|
||||
@@ -11,6 +11,7 @@
|
||||
#include "UserInterface/AccountConnector.h"
|
||||
#include "UserInterface/PythonPlayer.h"
|
||||
#include "GameLib/FlyingObjectManager.h"
|
||||
#include "GameLib/RaceManager.h"
|
||||
#include "EffectLib/EffectManager.h"
|
||||
#include "GameLib/ItemManager.h"
|
||||
#include "UserInterface/PythonCharacterManager.h"
|
||||
@@ -57,6 +58,7 @@ std::unique_ptr<CAccountConnector> g_account_connector;
|
||||
// (CPythonNetworkStream::SetLoadingPhase). PythonPlayer and FlyingObjectManager are platform/pending stand-ins.
|
||||
std::unique_ptr<CPythonPlayer> g_player;
|
||||
std::unique_ptr<CFlyingManager> g_flying_manager;
|
||||
std::unique_ptr<CRaceManager> g_race_manager;
|
||||
std::unique_ptr<CEffectManager> g_effect_manager;
|
||||
// PORT: CPythonApplication is not constructed by the Godot host yet. GamePhase calls the
|
||||
// 40250 IAbstractApplication singleton, so expose the host's current timer and camera surface.
|
||||
@@ -298,6 +300,7 @@ bool Start(const char* stdlib_path, std::string* error)
|
||||
g_account_connector = std::make_unique<CAccountConnector>();
|
||||
g_player = std::make_unique<CPythonPlayer>();
|
||||
g_flying_manager = std::make_unique<CFlyingManager>();
|
||||
g_race_manager = std::make_unique<CRaceManager>();
|
||||
g_effect_manager = std::make_unique<CEffectManager>();
|
||||
g_game_application = std::make_unique<GameApplicationAdapter>();
|
||||
g_game_singletons = std::make_unique<GameSingletons>();
|
||||
@@ -321,6 +324,8 @@ bool run_main_script_body(const char* lpCmdLine, std::string* error)
|
||||
initgrpText();
|
||||
initwndMgr();
|
||||
initapp();
|
||||
initchr();
|
||||
initchrmgr();
|
||||
initChat();
|
||||
initnet();
|
||||
init_2v0_gameplay_stubs();
|
||||
@@ -491,6 +496,7 @@ void Stop()
|
||||
g_game_singletons.reset();
|
||||
g_game_application.reset();
|
||||
g_effect_manager.reset();
|
||||
g_race_manager.reset();
|
||||
g_flying_manager.reset();
|
||||
g_player.reset();
|
||||
g_account_connector.reset();
|
||||
|
||||
@@ -162,8 +162,6 @@ void CPythonApplication::SaveCameraSetting(const char*) { MT_PLATFORM_STUB(); }
|
||||
bool CPythonApplication::LoadCameraSetting(const char*) { MT_PLATFORM_STUB(); return false; }
|
||||
void CPythonApplication::SetForceSightRange(int) { MT_PLATFORM_STUB(); }
|
||||
|
||||
void CCamera::SetResistance(float) { MT_PLATFORM_STUB(); }
|
||||
void CCamera::SetCameraMaxDistance(float) { MT_PLATFORM_STUB(); }
|
||||
void CMovieMan::PlayLogo(const char*) { MT_PLATFORM_STUB(); }
|
||||
|
||||
float GetDegreeDifference(float, float) { MT_PLATFORM_STUB(); return 0; }
|
||||
|
||||
@@ -1,23 +0,0 @@
|
||||
// Stand-in for the 40250 logic unit EterLib/AttributeInstance.cpp, not ported yet: the members the ported units
|
||||
// reference, as platform_stub.py stubs. Delete this file in the commit that ports the unit into port/
|
||||
// (docs/PORT-PLAN.md).
|
||||
#include "EterLib/StdAfx.h"
|
||||
#include "EterLib/AttributeInstance.h"
|
||||
|
||||
#include "../../PlatformStub.h"
|
||||
|
||||
auto CAttributeInstance::Clear() -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CAttributeInstance::GetHeight(float, float, float *) -> BOOL
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
return mt_platform_stub_return<BOOL>();
|
||||
}
|
||||
|
||||
auto CAttributeInstance::Delete(CAttributeInstance *) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
@@ -28,44 +28,6 @@ auto CActorInstance::SetEventHandler(IEventHandler *) -> void
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CActorInstance::SetRace(DWORD) -> bool
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
return mt_platform_stub_return<bool>();
|
||||
}
|
||||
|
||||
auto CActorInstance::SetHair(DWORD) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CActorInstance::SetVirtualID(DWORD) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CActorInstance::SetShape(DWORD, float) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CActorInstance::ChangeMaterial(const char *) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CActorInstance::GetRace() -> DWORD
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
return mt_platform_stub_return<DWORD>();
|
||||
}
|
||||
|
||||
auto CActorInstance::GetVirtualID() -> DWORD
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
return mt_platform_stub_return<DWORD>();
|
||||
}
|
||||
|
||||
auto CActorInstance::CanAct() -> bool
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
@@ -100,12 +62,6 @@ auto CActorInstance::RefreshActorInstance() -> void
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CActorInstance::GetPartItemID(DWORD) -> DWORD
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
return mt_platform_stub_return<DWORD>();
|
||||
}
|
||||
|
||||
auto CActorInstance::UpdateAttachingInstances() -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
@@ -368,11 +324,6 @@ auto CActorInstance::RenderToShadowMap() -> void
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CActorInstance::UpdateAttribute() -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CActorInstance::CanFishing() -> bool
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
@@ -563,3 +514,46 @@ auto CActorInstance::TEMP_Push(int, int) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CActorInstance::ShowDirectionLine(bool) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CActorInstance::AttachEffectByName(DWORD, const char *, const char *) -> DWORD
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
return mt_platform_stub_return<DWORD>();
|
||||
}
|
||||
|
||||
auto CActorInstance::PushOnceMotion(DWORD, float, float) -> bool
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
return mt_platform_stub_return<bool>();
|
||||
}
|
||||
|
||||
auto CActorInstance::PushLoopMotion(DWORD, float, float) -> bool
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
return mt_platform_stub_return<bool>();
|
||||
}
|
||||
|
||||
auto CActorInstance::SetXYRotation(float, float) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CActorInstance::SetWeaponTraceTexture(const char *) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CActorInstance::UseTextureWeaponTrace() -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CActorInstance::UseAlphaWeaponTrace() -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
@@ -387,3 +387,81 @@ auto CInstanceBase::__EffectContainer_DetachEffect(DWORD) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CInstanceBase::RegisterTitleName(int, const char *) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CInstanceBase::RegisterNameColor(UINT, UINT, UINT, UINT) -> bool
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
return mt_platform_stub_return<bool>();
|
||||
}
|
||||
|
||||
auto CInstanceBase::RegisterTitleColor(UINT, UINT, UINT, UINT) -> bool
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
return mt_platform_stub_return<bool>();
|
||||
}
|
||||
|
||||
auto CInstanceBase::SetDustGap(float) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CInstanceBase::SetHorseDustGap(float) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CInstanceBase::SetEmpireNameMode(bool) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CInstanceBase::SCRIPT_SetAffect(UINT, bool) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CInstanceBase::SetAlpha(float) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CInstanceBase::Revive() -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CInstanceBase::Hide() -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CInstanceBase::Show() -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CInstanceBase::SetDirection(int) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CInstanceBase::SetLoopMotion(WORD, float, float) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CInstanceBase::PushLoopMotion(WORD, float, float) -> void
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
}
|
||||
|
||||
auto CInstanceBase::IsPossibleEmoticon() -> bool
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
return mt_platform_stub_return<bool>();
|
||||
}
|
||||
|
||||
@@ -88,3 +88,9 @@ auto CPythonBackground::CheckAdvancing(CInstanceBase *) -> bool
|
||||
MT_PLATFORM_STUB();
|
||||
return mt_platform_stub_return<bool>();
|
||||
}
|
||||
|
||||
auto CPythonBackground::GetPickingPointWithRayOnlyTerrain(const CRay &, D3DXVECTOR3 *) -> bool
|
||||
{
|
||||
MT_PLATFORM_STUB();
|
||||
return mt_platform_stub_return<bool>();
|
||||
}
|
||||
|
||||
@@ -0,0 +1,200 @@
|
||||
#include "StdAfx.h"
|
||||
#include "../EterBase/Utils.h"
|
||||
#include "AttributeData.h"
|
||||
|
||||
const char c_szAttributeDataFileHeader[] = "AttributeData";
|
||||
const int c_iAttributeDataFileHeaderLength = 13;
|
||||
|
||||
/*DWORD CAttributeData::GetCollisionDataCount() const
|
||||
{
|
||||
return m_CollisionDataVector.size();
|
||||
}
|
||||
|
||||
BOOL CAttributeData::GetCollisionDataPointer(DWORD dwIndex, const TCollisionData ** c_ppCollisionData) const
|
||||
{
|
||||
if (dwIndex >= GetCollisionDataCount())
|
||||
return FALSE;
|
||||
|
||||
*c_ppCollisionData = &m_CollisionDataVector[dwIndex];
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
*/
|
||||
|
||||
const CStaticCollisionDataVector & CAttributeData::GetCollisionDataVector() const
|
||||
{
|
||||
return m_StaticCollisionDataVector;
|
||||
}
|
||||
|
||||
const THeightDataVector & CAttributeData::GetHeightDataVector() const
|
||||
{
|
||||
return m_HeightDataVector;
|
||||
}
|
||||
|
||||
DWORD CAttributeData::GetHeightDataCount() const
|
||||
{
|
||||
return m_HeightDataVector.size();
|
||||
}
|
||||
|
||||
BOOL CAttributeData::GetHeightDataPointer(DWORD dwIndex, const THeightData ** c_ppHeightData) const
|
||||
{
|
||||
if (dwIndex >= GetHeightDataCount())
|
||||
return FALSE;
|
||||
|
||||
*c_ppHeightData = &m_HeightDataVector[dwIndex];
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
float CAttributeData::GetMaximizeRadius()
|
||||
{
|
||||
return m_fMaximizeRadius;
|
||||
}
|
||||
|
||||
size_t CAttributeData::AddCollisionData(const CStaticCollisionData& data)
|
||||
{
|
||||
m_StaticCollisionDataVector.push_back(data);
|
||||
return m_StaticCollisionDataVector.size();
|
||||
}
|
||||
|
||||
bool CAttributeData::OnLoad(int /*iSize*/, const void * c_pvBuf)
|
||||
{
|
||||
if (!c_pvBuf)
|
||||
{
|
||||
// NOTE: 파일이 존재하지 않으면 다른곳에서 그래픽 모델을 기반으로 충돌 데이터를 생성하니 리소스를 파괴하지 않고 유지시킴.
|
||||
return true;
|
||||
}
|
||||
|
||||
const BYTE * c_pbBuf = static_cast<const BYTE *> (c_pvBuf);
|
||||
|
||||
char szHeader[c_iAttributeDataFileHeaderLength+1];
|
||||
memcpy(szHeader, c_pbBuf, c_iAttributeDataFileHeaderLength+1);
|
||||
c_pbBuf += c_iAttributeDataFileHeaderLength+1;
|
||||
if (strcmp(szHeader, c_szAttributeDataFileHeader))
|
||||
return FALSE;
|
||||
|
||||
DWORD dwCollisionDataCount;
|
||||
DWORD dwHeightDataCount;
|
||||
memcpy(&dwCollisionDataCount, c_pbBuf, sizeof(DWORD));
|
||||
c_pbBuf += sizeof(DWORD);
|
||||
memcpy(&dwHeightDataCount, c_pbBuf, sizeof(DWORD));
|
||||
c_pbBuf += sizeof(DWORD);
|
||||
|
||||
m_StaticCollisionDataVector.clear();
|
||||
m_StaticCollisionDataVector.resize(dwCollisionDataCount);
|
||||
m_HeightDataVector.clear();
|
||||
m_HeightDataVector.resize(dwHeightDataCount);
|
||||
|
||||
for (DWORD i = 0; i < dwCollisionDataCount; ++i)
|
||||
{
|
||||
CStaticCollisionData & rCollisionData = m_StaticCollisionDataVector[i];
|
||||
memcpy(&rCollisionData.dwType, c_pbBuf, sizeof(DWORD));
|
||||
c_pbBuf += sizeof(DWORD);
|
||||
memcpy(rCollisionData.szName, c_pbBuf, 32);
|
||||
c_pbBuf += 32;
|
||||
memcpy(&rCollisionData.v3Position, c_pbBuf, sizeof(D3DXVECTOR3));
|
||||
c_pbBuf += sizeof(D3DXVECTOR3);
|
||||
|
||||
switch(rCollisionData.dwType)
|
||||
{
|
||||
case COLLISION_TYPE_PLANE:
|
||||
memcpy(rCollisionData.fDimensions, c_pbBuf, 2*sizeof(float));
|
||||
c_pbBuf += 2*sizeof(float);
|
||||
break;
|
||||
case COLLISION_TYPE_BOX:
|
||||
memcpy(rCollisionData.fDimensions, c_pbBuf, 3*sizeof(float));
|
||||
c_pbBuf += 3*sizeof(float);
|
||||
break;
|
||||
case COLLISION_TYPE_SPHERE:
|
||||
memcpy(rCollisionData.fDimensions, c_pbBuf, sizeof(float));
|
||||
c_pbBuf += sizeof(float);
|
||||
break;
|
||||
case COLLISION_TYPE_CYLINDER:
|
||||
memcpy(rCollisionData.fDimensions, c_pbBuf, 2*sizeof(float));
|
||||
c_pbBuf += 2*sizeof(float);
|
||||
break;
|
||||
case COLLISION_TYPE_AABB:
|
||||
memcpy(rCollisionData.fDimensions, c_pbBuf, 3*sizeof(float));
|
||||
c_pbBuf += 3*sizeof(float);
|
||||
break;
|
||||
case COLLISION_TYPE_OBB:
|
||||
memcpy(rCollisionData.fDimensions, c_pbBuf, 3*sizeof(float));
|
||||
c_pbBuf += 3*sizeof(float);
|
||||
break;
|
||||
}
|
||||
|
||||
memcpy(rCollisionData.quatRotation, c_pbBuf, sizeof(D3DXQUATERNION));
|
||||
c_pbBuf += sizeof(D3DXQUATERNION);
|
||||
}
|
||||
|
||||
for (DWORD j = 0; j < dwHeightDataCount; ++j)
|
||||
{
|
||||
THeightData & rHeightData = m_HeightDataVector[j];
|
||||
memcpy(rHeightData.szName, c_pbBuf, 32);
|
||||
c_pbBuf += 32;
|
||||
|
||||
DWORD dwPrimitiveCount;
|
||||
memcpy(&dwPrimitiveCount, c_pbBuf, sizeof(DWORD));
|
||||
c_pbBuf += sizeof(DWORD);
|
||||
|
||||
rHeightData.v3VertexVector.clear();
|
||||
rHeightData.v3VertexVector.resize(dwPrimitiveCount);
|
||||
memcpy(&rHeightData.v3VertexVector[0], c_pbBuf, dwPrimitiveCount*sizeof(D3DXVECTOR3));
|
||||
c_pbBuf += dwPrimitiveCount*sizeof(D3DXVECTOR3);
|
||||
|
||||
// Getting Maximize Radius
|
||||
for (DWORD k = 0; k < rHeightData.v3VertexVector.size(); ++k)
|
||||
{
|
||||
m_fMaximizeRadius = fMAX(m_fMaximizeRadius, fabs(rHeightData.v3VertexVector[k].x)+50.0f);
|
||||
m_fMaximizeRadius = fMAX(m_fMaximizeRadius, fabs(rHeightData.v3VertexVector[k].y)+50.0f);
|
||||
m_fMaximizeRadius = fMAX(m_fMaximizeRadius, fabs(rHeightData.v3VertexVector[k].z)+50.0f);
|
||||
}
|
||||
// Getting Maximize Radius
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CAttributeData::OnClear()
|
||||
{
|
||||
m_StaticCollisionDataVector.clear();
|
||||
m_HeightDataVector.clear();
|
||||
}
|
||||
|
||||
bool CAttributeData::OnIsEmpty() const
|
||||
{
|
||||
if (!m_StaticCollisionDataVector.empty())
|
||||
return false;
|
||||
if (!m_HeightDataVector.empty())
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CAttributeData::OnIsType(TType type)
|
||||
{
|
||||
if (CAttributeData::Type() == type)
|
||||
return true;
|
||||
|
||||
return CResource::OnIsType(type);
|
||||
}
|
||||
|
||||
CAttributeData::TType CAttributeData::Type()
|
||||
{
|
||||
static TType s_type = StringToType("CAttributeData");
|
||||
return s_type;
|
||||
}
|
||||
|
||||
void CAttributeData::OnSelfDestruct()
|
||||
{
|
||||
Clear();
|
||||
}
|
||||
|
||||
CAttributeData::CAttributeData(const char * c_szFileName) : CResource(c_szFileName)
|
||||
{
|
||||
m_fMaximizeRadius = 0.0f;
|
||||
}
|
||||
|
||||
CAttributeData::~CAttributeData()
|
||||
{
|
||||
}
|
||||
@@ -0,0 +1,222 @@
|
||||
#include "StdAfx.h"
|
||||
#include "../EterBase/Utils.h"
|
||||
#include "AttributeInstance.h"
|
||||
#include "GrpMath.h"
|
||||
|
||||
CDynamicPool<CAttributeInstance> CAttributeInstance::ms_kPool;
|
||||
|
||||
const float c_fStepSize = 50.0f;
|
||||
|
||||
bool CAttributeInstance::Picking(const D3DXVECTOR3 & v, const D3DXVECTOR3 & dir, float & out_x, float & out_y)
|
||||
{
|
||||
if (IsEmpty())
|
||||
return FALSE;
|
||||
//fy *= -1.0f;
|
||||
|
||||
bool bPicked = false;
|
||||
float nx = 0;
|
||||
float ny = 0;
|
||||
|
||||
for (DWORD i = 0; i < m_v3HeightDataVector.size(); ++i)
|
||||
for (DWORD j = 0; j < m_v3HeightDataVector[i].size(); j+=3)
|
||||
{
|
||||
const D3DXVECTOR3 & cv0 = m_v3HeightDataVector[i][j];
|
||||
const D3DXVECTOR3 & cv2 = m_v3HeightDataVector[i][j+1];
|
||||
const D3DXVECTOR3 & cv1 = m_v3HeightDataVector[i][j+2];
|
||||
|
||||
D3DXVECTOR3 n;
|
||||
const auto vvv = (cv1 - cv0);
|
||||
const auto vvv2 = (cv2 - cv0);
|
||||
const auto vvv3 = (cv2 - cv1);
|
||||
D3DXVec3Cross(&n,&vvv,&vvv2);
|
||||
D3DXVECTOR3 x;
|
||||
float t;
|
||||
const auto _vv = (v - cv0);
|
||||
t = - D3DXVec3Dot(&_vv,&n)/D3DXVec3Dot(&dir,&n);
|
||||
|
||||
x = v+t*dir;
|
||||
const auto vvv4 = (x - cv0);
|
||||
const auto vvv5 = (x - cv1);
|
||||
const auto vvv6 = (x - cv2);
|
||||
D3DXVECTOR3 temp;
|
||||
D3DXVec3Cross(&temp,&vvv,&vvv4);
|
||||
if (D3DXVec3Dot(&temp,&n)<0) continue;
|
||||
D3DXVec3Cross(&temp,&vvv3,&vvv5);
|
||||
if (D3DXVec3Dot(&temp,&n)<0) continue;
|
||||
const auto _vv_ = (cv0 - cv2);
|
||||
D3DXVec3Cross(&temp,&_vv_,&vvv6);
|
||||
if (D3DXVec3Dot(&temp,&n)<0) continue;
|
||||
|
||||
if (bPicked)
|
||||
{
|
||||
if ((v.x-x.x)*(v.x-x.x)+(v.y-x.y)*(v.y-x.y)<(v.x-nx)*(v.x-nx)+(v.y-ny)*(v.y-ny))
|
||||
{
|
||||
nx=x.x;
|
||||
ny=x.y;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
nx = x.x;
|
||||
ny = x.y;
|
||||
}
|
||||
bPicked = true;
|
||||
}
|
||||
if (bPicked)
|
||||
{
|
||||
out_x = nx;
|
||||
out_y = ny;
|
||||
}
|
||||
return bPicked;
|
||||
}
|
||||
|
||||
BOOL CAttributeInstance::GetHeight(float fx, float fy, float * pfHeight)
|
||||
{
|
||||
if(IsEmpty())
|
||||
return FALSE;
|
||||
|
||||
fy *= -1.0f;
|
||||
|
||||
if (!IsInHeight(fx, fy))
|
||||
return FALSE;
|
||||
|
||||
BOOL bFlag = FALSE;
|
||||
|
||||
for (DWORD i = 0; i < m_v3HeightDataVector.size(); ++i)
|
||||
for (DWORD j = 0; j < m_v3HeightDataVector[i].size(); j+=3)
|
||||
{
|
||||
const D3DXVECTOR3 & c_rv3Vertex0 = m_v3HeightDataVector[i][j];
|
||||
const D3DXVECTOR3 & c_rv3Vertex1 = m_v3HeightDataVector[i][j+1];
|
||||
const D3DXVECTOR3 & c_rv3Vertex2 = m_v3HeightDataVector[i][j+2];
|
||||
|
||||
if (
|
||||
fx<c_rv3Vertex0.x && fx<c_rv3Vertex1.x && fx<c_rv3Vertex2.x ||
|
||||
fx>c_rv3Vertex0.x && fx>c_rv3Vertex1.x && fx>c_rv3Vertex2.x ||
|
||||
fy<c_rv3Vertex0.y && fy<c_rv3Vertex1.y && fy<c_rv3Vertex2.y ||
|
||||
fy>c_rv3Vertex0.y && fy>c_rv3Vertex1.y && fy>c_rv3Vertex2.y
|
||||
)
|
||||
continue;
|
||||
|
||||
if (IsInTriangle2D(c_rv3Vertex0.x, c_rv3Vertex0.y,
|
||||
c_rv3Vertex1.x, c_rv3Vertex1.y,
|
||||
c_rv3Vertex2.x, c_rv3Vertex2.y, fx, fy))
|
||||
{
|
||||
D3DXVECTOR3 v3Line1 = c_rv3Vertex1 - c_rv3Vertex0;
|
||||
D3DXVECTOR3 v3Line2 = c_rv3Vertex2 - c_rv3Vertex0;
|
||||
D3DXVECTOR3 v3Cross;
|
||||
|
||||
D3DXVec3Cross(&v3Cross, &v3Line1, &v3Line2);
|
||||
D3DXVec3Normalize(&v3Cross, &v3Cross);
|
||||
|
||||
if (0.0f != v3Cross.z)
|
||||
{
|
||||
float fd = (v3Cross.x*c_rv3Vertex0.x + v3Cross.y*c_rv3Vertex0.y + v3Cross.z*c_rv3Vertex0.z);
|
||||
float fm = (v3Cross.x*fx + v3Cross.y*fy);
|
||||
*pfHeight = fMAX((fd - fm) / v3Cross.z, *pfHeight);
|
||||
|
||||
bFlag = TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return bFlag;
|
||||
}
|
||||
|
||||
CAttributeData * CAttributeInstance::GetObjectPointer() const
|
||||
{
|
||||
return m_roAttributeData.GetPointer();
|
||||
}
|
||||
BOOL CAttributeInstance::IsInHeight(float fx, float fy)
|
||||
{
|
||||
float fdx = m_matGlobal._41 - fx;
|
||||
float fdy = m_matGlobal._42 - fy;
|
||||
if (sqrtf(fdx*fdx + fdy*fdy) > m_fHeightRadius)
|
||||
return FALSE;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
void CAttributeInstance::SetObjectPointer(CAttributeData * pAttributeData)
|
||||
{
|
||||
Clear();
|
||||
m_roAttributeData.SetPointer(pAttributeData);
|
||||
}
|
||||
|
||||
void CAttributeInstance::RefreshObject(const D3DXMATRIX & c_rmatGlobal)
|
||||
{
|
||||
assert(!m_roAttributeData.IsNull());
|
||||
|
||||
m_matGlobal = c_rmatGlobal;
|
||||
|
||||
// Height
|
||||
m_fHeightRadius = m_roAttributeData->GetMaximizeRadius();
|
||||
|
||||
DWORD dwHeightDataCount = m_roAttributeData->GetHeightDataCount();
|
||||
m_v3HeightDataVector.clear();
|
||||
m_v3HeightDataVector.resize(dwHeightDataCount);
|
||||
for (DWORD i = 0; i < dwHeightDataCount; ++i)
|
||||
{
|
||||
const THeightData * c_pHeightData;
|
||||
if (!m_roAttributeData->GetHeightDataPointer(i, &c_pHeightData))
|
||||
continue;
|
||||
|
||||
DWORD dwVertexCount = c_pHeightData->v3VertexVector.size();
|
||||
m_v3HeightDataVector[i].clear();
|
||||
m_v3HeightDataVector[i].resize(dwVertexCount);
|
||||
for (DWORD j = 0; j < dwVertexCount; ++j)
|
||||
{
|
||||
D3DXVec3TransformCoord(&m_v3HeightDataVector[i][j], &c_pHeightData->v3VertexVector[j], &m_matGlobal);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const char * CAttributeInstance::GetDataFileName() const
|
||||
{
|
||||
return m_roAttributeData->GetFileName();
|
||||
}
|
||||
|
||||
void CAttributeInstance::CreateSystem(UINT uCapacity)
|
||||
{
|
||||
ms_kPool.Create(uCapacity);
|
||||
}
|
||||
|
||||
void CAttributeInstance::DestroySystem()
|
||||
{
|
||||
ms_kPool.Destroy();
|
||||
}
|
||||
|
||||
CAttributeInstance* CAttributeInstance::New()
|
||||
{
|
||||
return ms_kPool.Alloc();
|
||||
}
|
||||
|
||||
void CAttributeInstance::Delete(CAttributeInstance* pkInst)
|
||||
{
|
||||
ms_kPool.Free(pkInst);
|
||||
}
|
||||
|
||||
BOOL CAttributeInstance::IsEmpty() const
|
||||
{
|
||||
if (!m_v3HeightDataVector.empty())
|
||||
return FALSE;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
void CAttributeInstance::Clear()
|
||||
{
|
||||
m_fHeightRadius = 0.0f;
|
||||
m_fCollisionRadius = 0.0f;
|
||||
D3DXMatrixIdentity(&m_matGlobal);
|
||||
|
||||
m_v3HeightDataVector.clear();
|
||||
|
||||
m_roAttributeData.SetPointer(NULL);
|
||||
}
|
||||
|
||||
CAttributeInstance::CAttributeInstance()
|
||||
{
|
||||
}
|
||||
CAttributeInstance::~CAttributeInstance()
|
||||
{
|
||||
}
|
||||
@@ -0,0 +1,633 @@
|
||||
// Camera.cpp: implementation of the CCamera class.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include "StdAfx.h"
|
||||
#include "../EterBase/Utils.h"
|
||||
#include "Camera.h"
|
||||
|
||||
const float c_fDefaultResistance = 0.3f;
|
||||
|
||||
CCameraManager aCameraManager; // CCameraManager Instance
|
||||
|
||||
void CCamera::SetCameraMaxDistance(float fMax)
|
||||
{
|
||||
CAMERA_MAX_DISTANCE = fMax;
|
||||
}
|
||||
|
||||
float CCamera::GetTargetHeight()
|
||||
{
|
||||
return m_fTarget_;
|
||||
}
|
||||
|
||||
void CCamera::SetTargetHeight(float fTarget)
|
||||
{
|
||||
m_fTarget_=fTarget;
|
||||
}
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// CCamera
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
CCamera::CCamera() :
|
||||
m_fEyeGroundHeightRatio(0.3f),
|
||||
m_fTargetHeightLimitRatio(2.0f),
|
||||
m_fResistance(c_fDefaultResistance),
|
||||
m_isLock(false)
|
||||
{
|
||||
m_fDistance = 1.0f;
|
||||
m_eCameraState = CAMERA_STATE_NORMAL;
|
||||
m_eCameraStatePrev = CAMERA_STATE_NORMAL;
|
||||
m_ulNumScreenBuilding = 0;
|
||||
|
||||
m_fPitchSum = 0.0f;
|
||||
m_fRollSum = 0.0f;
|
||||
|
||||
m_fTerrainCollisionRadius = 50.0f;
|
||||
m_fObjectCollisionRadius = 50.0f;
|
||||
|
||||
m_bDrag = false;
|
||||
|
||||
m_lMousePosX = -1;
|
||||
m_lMousePosY = -1;
|
||||
|
||||
m_fTarget_ = CAMERA_TARGET_STANDARD;
|
||||
|
||||
m_v3AngularAcceleration = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
|
||||
m_v3AngularVelocity = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
|
||||
|
||||
m_bProcessTerrainCollision = true;
|
||||
|
||||
SetViewParams(D3DXVECTOR3(0.0f,0.0f,1.0f), D3DXVECTOR3(0.0f,0.0f,0.0f), D3DXVECTOR3(0.0f,1.0f,0.0f));
|
||||
}
|
||||
|
||||
CCamera::~CCamera()
|
||||
{
|
||||
}
|
||||
|
||||
void CCamera::Lock()
|
||||
{
|
||||
m_isLock = true;
|
||||
}
|
||||
|
||||
void CCamera::Unlock()
|
||||
{
|
||||
m_isLock = false;
|
||||
}
|
||||
|
||||
bool CCamera::IsLock()
|
||||
{
|
||||
return m_isLock;
|
||||
}
|
||||
|
||||
void CCamera::SetResistance(float fResistance)
|
||||
{
|
||||
m_fResistance = c_fDefaultResistance * fResistance;
|
||||
}
|
||||
|
||||
void CCamera::Wheel(int nLen)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
m_v3AngularVelocity.y = (float)(nLen) * m_fResistance;
|
||||
}
|
||||
|
||||
void CCamera::BeginDrag(int nMouseX, int nMouseY)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
m_bDrag = true;
|
||||
m_lMousePosX = nMouseX;
|
||||
m_lMousePosY = nMouseY;
|
||||
m_fPitchSum = 0.0f;
|
||||
m_fRollSum = 0.0f;
|
||||
}
|
||||
|
||||
bool CCamera::IsDraging()
|
||||
{
|
||||
if (IsLock())
|
||||
return false;
|
||||
|
||||
return m_bDrag;
|
||||
}
|
||||
|
||||
bool CCamera::EndDrag()
|
||||
{
|
||||
if (IsLock())
|
||||
return false;
|
||||
|
||||
m_bDrag = false;
|
||||
|
||||
float fSum=sqrt(m_fPitchSum*m_fPitchSum+m_fRollSum*m_fRollSum);
|
||||
|
||||
m_fPitchSum = 0.0f;
|
||||
m_fRollSum = 0.0f;
|
||||
|
||||
if (fSum<1.0f)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CCamera::Drag(int nMouseX, int nMouseY, LPPOINT lpReturnPoint)
|
||||
{
|
||||
if (IsLock())
|
||||
return false;
|
||||
|
||||
if (!m_bDrag)
|
||||
{
|
||||
m_lMousePosX = nMouseX;
|
||||
m_lMousePosY = nMouseY;
|
||||
lpReturnPoint->x = m_lMousePosX;
|
||||
lpReturnPoint->y = m_lMousePosY;
|
||||
return false;
|
||||
}
|
||||
|
||||
long lMouseX = nMouseX;
|
||||
long lMouseY = nMouseY;
|
||||
|
||||
float fNewPitchVelocity = (float)(lMouseY - m_lMousePosY) * m_fResistance;
|
||||
float fNewRotationVelocity = (float)(lMouseX - m_lMousePosX) * m_fResistance;
|
||||
|
||||
m_fPitchSum += fNewPitchVelocity;
|
||||
m_fRollSum += fNewRotationVelocity;
|
||||
|
||||
|
||||
if (CAMERA_STATE_CANTGOLEFT == GetCameraState())
|
||||
fNewRotationVelocity = fMAX(0.0f, fNewRotationVelocity);
|
||||
if (CAMERA_STATE_CANTGORIGHT == GetCameraState())
|
||||
fNewRotationVelocity = fMIN(0.0f, fNewRotationVelocity);
|
||||
if (CAMERA_STATE_CANTGODOWN == GetCameraState())
|
||||
fNewPitchVelocity = fMAX(0.0f, fNewPitchVelocity);
|
||||
|
||||
m_v3AngularVelocity.x = fNewRotationVelocity;
|
||||
m_v3AngularVelocity.z = fNewPitchVelocity;
|
||||
|
||||
lpReturnPoint->x = m_lMousePosX;
|
||||
lpReturnPoint->y = m_lMousePosY;
|
||||
return true;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// Update
|
||||
|
||||
void CCamera::SetCameraState(eCameraState eNewCameraState)
|
||||
{
|
||||
if (eNewCameraState == m_eCameraState)
|
||||
return;
|
||||
|
||||
m_eCameraStatePrev = m_eCameraState;
|
||||
m_eCameraState = eNewCameraState;
|
||||
|
||||
/*
|
||||
if ((CAMERA_STATE_NORMAL == m_eCameraStatePrev))
|
||||
{
|
||||
m_fDistanceBackup = m_fDistance;
|
||||
m_fPitchBackup = m_fPitch;
|
||||
m_fRollBackup = m_fRoll;
|
||||
}
|
||||
else if ((CAMERA_STATE_CANTGODOWN == m_eCameraStatePrev) && (CAMERA_STATE_CANTGODOWN == m_eCameraState) )
|
||||
{
|
||||
m_v3EyeBackup = m_v3Eye;
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
void CCamera::IncreaseNumSrcreenBuilding()
|
||||
{
|
||||
++m_ulNumScreenBuilding;
|
||||
}
|
||||
|
||||
void CCamera::ResetNumScreenBuilding()
|
||||
{
|
||||
m_ulNumScreenBuilding = 0;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// Property
|
||||
void CCamera::SetViewParams( const D3DXVECTOR3 &v3Eye, const D3DXVECTOR3& v3Target, const D3DXVECTOR3& v3Up)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
// Set attributes for the view matrix
|
||||
m_v3Eye = v3Eye;
|
||||
m_v3Target = v3Target;
|
||||
m_v3Up = v3Up;
|
||||
|
||||
SetViewMatrix();
|
||||
}
|
||||
|
||||
void CCamera::SetEye(const D3DXVECTOR3 & v3Eye)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
m_v3Eye = v3Eye;
|
||||
|
||||
SetViewMatrix();
|
||||
}
|
||||
|
||||
void CCamera::SetTarget(const D3DXVECTOR3 & v3Target)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
m_v3Target = v3Target;
|
||||
|
||||
SetViewMatrix();
|
||||
}
|
||||
|
||||
void CCamera::SetUp(const D3DXVECTOR3 & v3Up)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
m_v3Up = v3Up;
|
||||
|
||||
SetViewMatrix();
|
||||
}
|
||||
|
||||
void CCamera::SetViewMatrix()
|
||||
{
|
||||
m_v3View = m_v3Target - m_v3Eye;
|
||||
D3DXVECTOR3 v3CenterRay = -m_v3View;
|
||||
CalculateRoll();
|
||||
m_fDistance = D3DXVec3Length(&m_v3View);
|
||||
assert(m_fDistance >= 0);
|
||||
D3DXVec3Normalize(&m_v3View , &m_v3View);
|
||||
|
||||
D3DXVec3Cross(&m_v3Cross, &m_v3Up, &m_v3View);
|
||||
D3DXVec3Normalize(&m_v3Cross, &m_v3Cross);
|
||||
|
||||
D3DXVec3Cross(&m_v3Up, &m_v3View, &m_v3Cross);
|
||||
D3DXVec3Normalize(&m_v3Up, &m_v3Up);
|
||||
const auto vv = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
|
||||
m_fPitch = D3DXVec3Dot(&m_v3Up, &vv);// / D3DXVec2Length(&v2ViewYZ);
|
||||
if (m_fPitch >= 1)
|
||||
m_fPitch = 1;
|
||||
else if (m_fPitch <= -1)
|
||||
m_fPitch = -1;
|
||||
m_fPitch = acosf(m_fPitch);
|
||||
m_fPitch *= (180.0f / D3DX_PI);
|
||||
if ( 0 < m_v3View.z )
|
||||
m_fPitch = -m_fPitch;
|
||||
|
||||
D3DXMatrixLookAtRH(&m_matView, &m_v3Eye, &m_v3Target, &m_v3Up);
|
||||
|
||||
float fDeterminantD3DMatView = D3DXMatrixfDeterminant(&m_matView);
|
||||
D3DXMatrixInverse(&m_matInverseView, &fDeterminantD3DMatView, &m_matView);
|
||||
|
||||
m_matBillboard = m_matInverseView;
|
||||
m_matBillboard._41 = 0.0f;
|
||||
m_matBillboard._42 = 0.0f;
|
||||
m_matBillboard._43 = 0.0f;
|
||||
|
||||
m_ViewRay.SetStartPoint(m_v3Target);
|
||||
m_ViewRay.SetDirection(v3CenterRay, m_fDistance);
|
||||
|
||||
m_kCameraBottomToTerrainRay.SetStartPoint(m_v3Eye);
|
||||
m_kCameraFrontToTerrainRay.SetStartPoint(m_v3Eye);
|
||||
m_kCameraBackToTerrainRay.SetStartPoint(m_v3Eye);
|
||||
m_kCameraLeftToTerrainRay.SetStartPoint(m_v3Eye);
|
||||
m_kCameraRightToTerrainRay.SetStartPoint(m_v3Eye);
|
||||
m_kTargetToCameraBottomRay.SetStartPoint(m_v3Target);
|
||||
|
||||
m_kCameraBottomToTerrainRay.SetDirection(-m_v3Up, 2.0f * m_fTerrainCollisionRadius);
|
||||
m_kCameraFrontToTerrainRay.SetDirection(m_v3View, 4.0f * m_fTerrainCollisionRadius);
|
||||
m_kCameraBackToTerrainRay.SetDirection(-m_v3View, m_fTerrainCollisionRadius);
|
||||
m_kCameraLeftToTerrainRay.SetDirection(-m_v3Cross, 3.0f * m_fTerrainCollisionRadius);
|
||||
m_kCameraRightToTerrainRay.SetDirection(m_v3Cross, 3.0f * m_fTerrainCollisionRadius);
|
||||
const auto vv2 = (v3CenterRay - m_fTerrainCollisionRadius * m_v3Up);
|
||||
m_kTargetToCameraBottomRay.SetDirection(v3CenterRay - m_fTerrainCollisionRadius * m_v3Up, D3DXVec3Length(&vv2));
|
||||
|
||||
m_kLeftObjectCollisionRay.SetStartPoint(m_v3Target);
|
||||
m_kTopObjectCollisionRay.SetStartPoint(m_v3Target);
|
||||
m_kRightObjectCollisionRay.SetStartPoint(m_v3Target);
|
||||
m_kBottomObjectCollisionRay.SetStartPoint(m_v3Target);
|
||||
const auto vv3 = (v3CenterRay + m_fObjectCollisionRadius * m_v3Cross);
|
||||
const auto vv4 = (v3CenterRay - m_fObjectCollisionRadius * m_v3Cross);
|
||||
const auto vv5 = (v3CenterRay + m_fObjectCollisionRadius * m_v3Up);
|
||||
const auto vv6 = (v3CenterRay + m_fObjectCollisionRadius * m_v3Up);
|
||||
m_kLeftObjectCollisionRay.SetDirection(v3CenterRay + m_fObjectCollisionRadius * m_v3Cross, D3DXVec3Length(&vv3));
|
||||
m_kRightObjectCollisionRay.SetDirection(v3CenterRay - m_fObjectCollisionRadius * m_v3Cross, D3DXVec3Length(&vv4));
|
||||
m_kTopObjectCollisionRay.SetDirection(v3CenterRay + m_fObjectCollisionRadius * m_v3Up, D3DXVec3Length(&vv5));
|
||||
m_kBottomObjectCollisionRay.SetDirection(v3CenterRay - m_fObjectCollisionRadius * m_v3Up, D3DXVec3Length(&vv6));
|
||||
}
|
||||
|
||||
void CCamera::Move(const D3DXVECTOR3 & v3Displacement)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
m_v3Eye += v3Displacement;
|
||||
m_v3Target += v3Displacement;
|
||||
|
||||
SetViewMatrix();
|
||||
}
|
||||
|
||||
void CCamera::Zoom(float fRatio)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
if (fRatio == 1.0f)
|
||||
return;
|
||||
|
||||
D3DXVECTOR3 v3Temp = m_v3Eye - m_v3Target;
|
||||
v3Temp *= fRatio;
|
||||
m_v3Eye = v3Temp + m_v3Target;
|
||||
|
||||
SetViewMatrix();
|
||||
}
|
||||
|
||||
void CCamera::MoveAlongView(float fDistance)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
D3DXVECTOR3 v3Temp;
|
||||
D3DXVec3Normalize(&v3Temp, &m_v3View);
|
||||
|
||||
m_v3Eye += v3Temp * fDistance;
|
||||
m_v3Target += v3Temp * fDistance;
|
||||
|
||||
SetViewMatrix();
|
||||
}
|
||||
|
||||
void CCamera::MoveAlongCross(float fDistance)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
D3DXVECTOR3 v3Temp;
|
||||
D3DXVec3Normalize(&v3Temp, &m_v3Cross);
|
||||
|
||||
m_v3Eye += v3Temp * fDistance;
|
||||
m_v3Target += v3Temp * fDistance;
|
||||
|
||||
SetViewMatrix();
|
||||
}
|
||||
|
||||
void CCamera::MoveAlongUp(FLOAT fDistance)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
D3DXVECTOR3 v3Temp ;
|
||||
D3DXVec3Normalize(&v3Temp, &m_v3Up);
|
||||
m_v3Target += v3Temp * fDistance;
|
||||
m_v3Eye += v3Temp * fDistance;
|
||||
SetViewMatrix();
|
||||
}
|
||||
|
||||
void CCamera::MoveLateral(float fDistance)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
MoveAlongCross(fDistance);
|
||||
}
|
||||
|
||||
void CCamera::MoveFront(float fDistance)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
D3DXVECTOR3 v3Temp = D3DXVECTOR3(m_v3View.x, m_v3View.y, 0.0f);
|
||||
D3DXVec3Normalize(&v3Temp, &v3Temp);
|
||||
|
||||
m_v3Eye += v3Temp * fDistance;
|
||||
m_v3Target += v3Temp * fDistance;
|
||||
|
||||
SetViewMatrix();
|
||||
}
|
||||
|
||||
void CCamera::MoveVertical(float fDistance)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
m_v3Eye.z += fDistance;
|
||||
m_v3Target.z += fDistance;
|
||||
|
||||
SetViewMatrix();
|
||||
}
|
||||
|
||||
//void CCamera::RotateUpper(float fDegree)
|
||||
//{
|
||||
// D3DXMATRIX matRot;
|
||||
// D3DXMatrixRotationAxis(&matRot, &m_v3Cross, -D3DXToRadian(fDegree));
|
||||
// D3DXVec3TransformCoord(&m_v3View, &m_v3View, &matRot) ;
|
||||
// D3DXVec3Cross(&m_v3Up, &m_v3View, &m_v3Cross);
|
||||
//
|
||||
// m_v3Target = m_v3Eye + m_v3View;
|
||||
//
|
||||
// SetViewMatrix() ;
|
||||
//}
|
||||
|
||||
void CCamera::RotateEyeAroundTarget(float fPitchDegree, float fRollDegree)
|
||||
{
|
||||
if (IsLock())
|
||||
return;
|
||||
|
||||
D3DXMATRIX matRot, matRotPitch, matRotRoll;
|
||||
|
||||
// 머리위로 넘어가기 막기...
|
||||
if (m_fPitch + fPitchDegree > 80.0f)
|
||||
{
|
||||
fPitchDegree = 80.0f - m_fPitch;
|
||||
}
|
||||
else if( m_fPitch + fPitchDegree < -80.0f)
|
||||
{
|
||||
fPitchDegree = -80.0f - m_fPitch;
|
||||
}
|
||||
|
||||
D3DXMatrixRotationAxis(&matRotPitch, &m_v3Cross, D3DXToRadian(fPitchDegree));
|
||||
|
||||
D3DXMatrixRotationZ(&matRotRoll, -D3DXToRadian(fRollDegree));
|
||||
matRot = matRotPitch * matRotRoll;
|
||||
|
||||
D3DXVECTOR3 v3Temp = m_v3Eye - m_v3Target;
|
||||
D3DXVec3TransformCoord(&m_v3Eye, &v3Temp, &matRot);
|
||||
m_v3Eye += m_v3Target;
|
||||
|
||||
SetUp(D3DXVECTOR3(0.0f, 0.0f, 1.0f));
|
||||
|
||||
m_fRoll += fRollDegree;
|
||||
|
||||
if (m_fRoll > 360.0f)
|
||||
m_fRoll -= 360.0f;
|
||||
else if (m_fRoll < -360.0f)
|
||||
m_fRoll += 360.0f;
|
||||
}
|
||||
|
||||
void CCamera::RotateEyeAroundPoint(const D3DXVECTOR3 & v3Point, float fPitchDegree, float fRollDegree)
|
||||
{
|
||||
// if (IsLock())
|
||||
// return;
|
||||
|
||||
D3DXMATRIX matRot, matRotPitch, matRotRoll;
|
||||
|
||||
D3DXMatrixRotationAxis(&matRotPitch, &m_v3Cross, D3DXToRadian(fPitchDegree));
|
||||
|
||||
D3DXMatrixRotationZ(&matRotRoll, -D3DXToRadian(fRollDegree));
|
||||
matRot = matRotPitch * matRotRoll;
|
||||
|
||||
D3DXVECTOR3 v3Temp = m_v3Eye - v3Point;
|
||||
D3DXVec3TransformCoord(&m_v3Eye, &v3Temp, &matRot);
|
||||
m_v3Eye += v3Point;
|
||||
|
||||
const auto vv2 = (v3Temp + m_v3Up);
|
||||
D3DXVec3TransformCoord(&m_v3Up, &vv2, &matRot);
|
||||
m_v3Up -= (m_v3Eye - v3Point);
|
||||
|
||||
v3Temp = m_v3Target - v3Point;
|
||||
D3DXVec3TransformCoord(&m_v3Target, &v3Temp, &matRot);
|
||||
m_v3Target += v3Point;
|
||||
|
||||
SetViewMatrix();
|
||||
}
|
||||
|
||||
void CCamera::Pitch(const float fPitchDelta)
|
||||
{
|
||||
// if (IsLock())
|
||||
// return;
|
||||
|
||||
RotateEyeAroundTarget(fPitchDelta, 0.0f);
|
||||
}
|
||||
|
||||
void CCamera::Roll(const float fRollDelta)
|
||||
{
|
||||
// if (IsLock())
|
||||
// return;
|
||||
|
||||
RotateEyeAroundTarget(0.0f, fRollDelta);
|
||||
}
|
||||
|
||||
void CCamera::SetDistance(const float fdistance)
|
||||
{
|
||||
// if (IsLock())
|
||||
// return;
|
||||
|
||||
Zoom(fdistance/m_fDistance);
|
||||
}
|
||||
|
||||
void CCamera::CalculateRoll()
|
||||
{
|
||||
D3DXVECTOR2 v2ViewXY;
|
||||
v2ViewXY.x = m_v3View.x;
|
||||
v2ViewXY.y = m_v3View.y;
|
||||
D3DXVec2Normalize(&v2ViewXY, &v2ViewXY);
|
||||
const auto vv = D3DXVECTOR2(0.0f, 1.0f);
|
||||
float fDot = D3DXVec2Dot(&v2ViewXY, &vv);
|
||||
if (fDot >= 1)
|
||||
fDot = 1;
|
||||
else if (fDot <= -1)
|
||||
fDot = -1;
|
||||
fDot = acosf(fDot);
|
||||
fDot *= (180.0f / D3DX_PI);
|
||||
float fCross = D3DXVec2CCW (&v2ViewXY, &vv);
|
||||
if ( 0 > fCross)
|
||||
{
|
||||
fDot = -fDot;
|
||||
}
|
||||
|
||||
m_fRoll = fDot;
|
||||
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// CCameraMananger
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
CCameraManager::CCameraManager() :
|
||||
m_pCurrentCamera(NULL),
|
||||
m_pPreviousCamera(NULL)
|
||||
{
|
||||
AddCamera(DEFAULT_PERSPECTIVE_CAMERA);
|
||||
AddCamera(DEFAULT_ORTHO_CAMERA);
|
||||
|
||||
SetCurrentCamera(DEFAULT_PERSPECTIVE_CAMERA);
|
||||
}
|
||||
|
||||
CCameraManager::~CCameraManager()
|
||||
{
|
||||
for (TCameraMap::iterator itor = m_CameraMap.begin(); itor != m_CameraMap.end(); ++itor)
|
||||
{
|
||||
delete (*itor).second;
|
||||
}
|
||||
m_CameraMap.clear();
|
||||
}
|
||||
|
||||
CCamera * CCameraManager::GetCurrentCamera()
|
||||
{
|
||||
if (!m_pCurrentCamera)
|
||||
assert(false);
|
||||
return m_pCurrentCamera;
|
||||
}
|
||||
|
||||
void CCameraManager::SetCurrentCamera(unsigned char ucCameraNum)
|
||||
{
|
||||
if (m_pCurrentCamera != m_CameraMap[ucCameraNum])
|
||||
m_pPreviousCamera = m_pCurrentCamera;
|
||||
|
||||
m_pCurrentCamera = m_CameraMap[ucCameraNum];
|
||||
}
|
||||
|
||||
void CCameraManager::ResetToPreviousCamera()
|
||||
{
|
||||
if (!m_pPreviousCamera)
|
||||
assert(false);
|
||||
m_pCurrentCamera = m_pPreviousCamera;
|
||||
m_pPreviousCamera = NULL;
|
||||
}
|
||||
|
||||
bool CCameraManager::isCurrentCamera(unsigned char ucCameraNum)
|
||||
{
|
||||
if (m_CameraMap[ucCameraNum] == m_pCurrentCamera)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
// 잡스러운 함수들...
|
||||
bool CCameraManager::AddCamera(unsigned char ucCameraNum)
|
||||
{
|
||||
if(m_CameraMap.end() != m_CameraMap.find(ucCameraNum))
|
||||
return false;
|
||||
m_CameraMap.insert(TCameraMap::value_type(ucCameraNum, new CCamera));
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CCameraManager::RemoveCamera(unsigned char ucCameraNum)
|
||||
{
|
||||
TCameraMap::iterator itor = m_CameraMap.find(ucCameraNum);
|
||||
if(m_CameraMap.end() == itor)
|
||||
return false;
|
||||
m_CameraMap.erase(itor);
|
||||
return true;
|
||||
}
|
||||
|
||||
unsigned char CCameraManager::GetCurrentCameraNum()
|
||||
{
|
||||
if (!m_pCurrentCamera)
|
||||
return NO_CURRENT_CAMERA;
|
||||
for (TCameraMap::iterator itor = m_CameraMap.begin(); itor != m_CameraMap.end(); ++itor)
|
||||
if(m_pCurrentCamera == (*itor).second)
|
||||
return (*itor).first;
|
||||
return NO_CURRENT_CAMERA;
|
||||
}
|
||||
|
||||
bool CCameraManager::isTerrainCollisionEnable()
|
||||
{
|
||||
return m_pCurrentCamera->isTerrainCollisionEnable();
|
||||
}
|
||||
|
||||
void CCameraManager::SetTerrainCollision(bool bEnable)
|
||||
{
|
||||
m_pCurrentCamera->SetTerrainCollision(bEnable);
|
||||
}
|
||||
@@ -0,0 +1,696 @@
|
||||
#include "StdAfx.h"
|
||||
#include "../EterBase/CRC32.h"
|
||||
#include <string>
|
||||
#include "../EterPack/EterPackManager.h"
|
||||
|
||||
#include "Pool.h"
|
||||
#include "TextFileLoader.h"
|
||||
|
||||
std::map<DWORD, CTextFileLoader*> CTextFileLoader::ms_kMap_dwNameKey_pkTextFileLoader;
|
||||
bool CTextFileLoader::ms_isCacheMode=false;
|
||||
|
||||
CDynamicPool<CTextFileLoader::SGroupNode> CTextFileLoader::SGroupNode::ms_kPool;
|
||||
|
||||
CTokenVector* CTextFileLoader::SGroupNode::GetTokenVector(const std::string& c_rstGroupName)
|
||||
{
|
||||
DWORD dwGroupNameKey=GenNameKey(c_rstGroupName.c_str(), c_rstGroupName.length());
|
||||
|
||||
std::map<DWORD, CTokenVector>::iterator f=m_kMap_dwKey_kVct_stToken.find(dwGroupNameKey);
|
||||
if (m_kMap_dwKey_kVct_stToken.end()==f)
|
||||
return NULL;
|
||||
|
||||
return &f->second;
|
||||
}
|
||||
|
||||
bool CTextFileLoader::SGroupNode::IsExistTokenVector(const std::string& c_rstGroupName)
|
||||
{
|
||||
DWORD dwGroupNameKey=GenNameKey(c_rstGroupName.c_str(), c_rstGroupName.length());
|
||||
|
||||
if (m_kMap_dwKey_kVct_stToken.end()==m_kMap_dwKey_kVct_stToken.find(dwGroupNameKey))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CTextFileLoader::SGroupNode::InsertTokenVector(const std::string& c_rstGroupName, const CTokenVector& c_rkVct_stToken)
|
||||
{
|
||||
DWORD dwGroupNameKey=GenNameKey(c_rstGroupName.c_str(), c_rstGroupName.length());
|
||||
|
||||
m_kMap_dwKey_kVct_stToken.insert(std::map<DWORD, CTokenVector>::value_type(dwGroupNameKey, c_rkVct_stToken));
|
||||
}
|
||||
|
||||
DWORD CTextFileLoader::SGroupNode::GenNameKey(const char* c_szGroupName, UINT uGroupNameLen)
|
||||
{
|
||||
return GetCRC32(c_szGroupName, uGroupNameLen);
|
||||
}
|
||||
|
||||
const std::string& CTextFileLoader::SGroupNode::GetGroupName()
|
||||
{
|
||||
return m_strGroupName;
|
||||
}
|
||||
|
||||
bool CTextFileLoader::SGroupNode::IsGroupNameKey(DWORD dwGroupNameKey)
|
||||
{
|
||||
if (dwGroupNameKey==m_dwGroupNameKey)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void CTextFileLoader::SGroupNode::SetGroupName(const std::string& c_rstGroupName)
|
||||
{
|
||||
m_strGroupName=c_rstGroupName;
|
||||
stl_lowers(m_strGroupName);
|
||||
|
||||
m_dwGroupNameKey=GenNameKey(m_strGroupName.c_str(), m_strGroupName.length());
|
||||
}
|
||||
|
||||
|
||||
CTextFileLoader::SGroupNode* CTextFileLoader::SGroupNode::New()
|
||||
{
|
||||
return ms_kPool.Alloc();
|
||||
}
|
||||
|
||||
void CTextFileLoader::SGroupNode::Delete(SGroupNode* pkNode)
|
||||
{
|
||||
pkNode->m_kMap_dwKey_kVct_stToken.clear();
|
||||
pkNode->ChildNodeVector.clear();
|
||||
pkNode->m_strGroupName="";
|
||||
pkNode->m_dwGroupNameKey=0;
|
||||
ms_kPool.Free(pkNode);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void CTextFileLoader::SGroupNode::DestroySystem()
|
||||
{
|
||||
ms_kPool.Destroy();
|
||||
}
|
||||
|
||||
|
||||
CTextFileLoader* CTextFileLoader::Cache(const char* c_szFileName)
|
||||
{
|
||||
DWORD dwNameKey=GetCRC32(c_szFileName, strlen(c_szFileName));
|
||||
std::map<DWORD, CTextFileLoader*>::iterator f=ms_kMap_dwNameKey_pkTextFileLoader.find(dwNameKey);
|
||||
if (ms_kMap_dwNameKey_pkTextFileLoader.end()!=f)
|
||||
{
|
||||
if (!ms_isCacheMode)
|
||||
{
|
||||
delete f->second;
|
||||
|
||||
CTextFileLoader* pkNewTextFileLoader=new CTextFileLoader;
|
||||
pkNewTextFileLoader->Load(c_szFileName);
|
||||
f->second=pkNewTextFileLoader;
|
||||
}
|
||||
f->second->SetTop();
|
||||
return f->second;
|
||||
}
|
||||
|
||||
CTextFileLoader* pkNewTextFileLoader=new CTextFileLoader;
|
||||
pkNewTextFileLoader->Load(c_szFileName);
|
||||
|
||||
ms_kMap_dwNameKey_pkTextFileLoader.insert(std::map<DWORD, CTextFileLoader*>::value_type(dwNameKey, pkNewTextFileLoader));
|
||||
return pkNewTextFileLoader;
|
||||
}
|
||||
|
||||
void CTextFileLoader::SetCacheMode()
|
||||
{
|
||||
ms_isCacheMode=true;
|
||||
}
|
||||
|
||||
void CTextFileLoader::DestroySystem()
|
||||
{
|
||||
{
|
||||
std::map<DWORD, CTextFileLoader*>::iterator i;
|
||||
for (i=ms_kMap_dwNameKey_pkTextFileLoader.begin(); i!=ms_kMap_dwNameKey_pkTextFileLoader.end(); ++i)
|
||||
delete i->second;
|
||||
ms_kMap_dwNameKey_pkTextFileLoader.clear();
|
||||
}
|
||||
|
||||
SGroupNode::DestroySystem();
|
||||
}
|
||||
|
||||
void CTextFileLoader::Destroy()
|
||||
{
|
||||
__DestroyGroupNodeVector();
|
||||
}
|
||||
|
||||
CTextFileLoader::CTextFileLoader()
|
||||
{
|
||||
SetTop();
|
||||
|
||||
m_acBufData=NULL;
|
||||
m_dwBufSize=0;
|
||||
m_dwBufCapacity=0;
|
||||
|
||||
m_GlobalNode.m_strGroupName = "global";
|
||||
m_GlobalNode.pParentNode = NULL;
|
||||
|
||||
m_kVct_pkNode.reserve(128);
|
||||
}
|
||||
|
||||
CTextFileLoader::~CTextFileLoader()
|
||||
{
|
||||
Destroy();
|
||||
|
||||
if (m_acBufData)
|
||||
delete [] m_acBufData;
|
||||
}
|
||||
|
||||
void CTextFileLoader::__DestroyGroupNodeVector()
|
||||
{
|
||||
std::vector<SGroupNode*>::iterator i;
|
||||
for (i=m_kVct_pkNode.begin(); i!=m_kVct_pkNode.end(); ++i)
|
||||
SGroupNode::Delete(*i);
|
||||
m_kVct_pkNode.clear();
|
||||
}
|
||||
|
||||
const char * CTextFileLoader::GetFileName()
|
||||
{
|
||||
return m_strFileName.c_str();
|
||||
}
|
||||
|
||||
bool CTextFileLoader::IsEmpty()
|
||||
{
|
||||
return m_strFileName.empty();
|
||||
}
|
||||
|
||||
bool CTextFileLoader::Load(const char * c_szFileName)
|
||||
{
|
||||
m_strFileName = "";
|
||||
|
||||
const VOID* pvData;
|
||||
CMappedFile kFile;
|
||||
if (!CEterPackManager::Instance().Get(kFile, c_szFileName, &pvData))
|
||||
return false;
|
||||
|
||||
if (m_dwBufCapacity<kFile.Size())
|
||||
{
|
||||
m_dwBufCapacity=kFile.Size();
|
||||
|
||||
if (m_acBufData)
|
||||
delete [] m_acBufData;
|
||||
|
||||
m_acBufData=new char[m_dwBufCapacity];
|
||||
}
|
||||
|
||||
m_dwBufSize=kFile.Size();
|
||||
memcpy(m_acBufData, pvData, m_dwBufSize);
|
||||
|
||||
m_strFileName = c_szFileName;
|
||||
m_dwcurLineIndex = 0;
|
||||
|
||||
m_textFileLoader.Bind(m_dwBufSize, m_acBufData);
|
||||
return LoadGroup(&m_GlobalNode);
|
||||
}
|
||||
|
||||
bool CTextFileLoader::LoadGroup(TGroupNode * pGroupNode)
|
||||
{
|
||||
CTokenVector stTokenVector;
|
||||
int nLocalGroupDepth = 0;
|
||||
|
||||
for (; m_dwcurLineIndex < m_textFileLoader.GetLineCount(); ++m_dwcurLineIndex)
|
||||
{
|
||||
int iRet;
|
||||
|
||||
if ((iRet = m_textFileLoader.SplitLine2(m_dwcurLineIndex, &stTokenVector)) != 0)
|
||||
{
|
||||
if (iRet == -2)
|
||||
TraceError("cannot find \" in %s:%lu", m_strFileName.c_str(), m_dwcurLineIndex);
|
||||
continue;
|
||||
}
|
||||
|
||||
stl_lowers(stTokenVector[0]);
|
||||
|
||||
if ('{' == stTokenVector[0][0])
|
||||
{
|
||||
nLocalGroupDepth++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if ('}' == stTokenVector[0][0]) {
|
||||
nLocalGroupDepth--;
|
||||
break;
|
||||
}
|
||||
|
||||
// Group
|
||||
if (0 == stTokenVector[0].compare("group"))
|
||||
{
|
||||
if (2 != stTokenVector.size())
|
||||
{
|
||||
assert(!"There is no group name!");
|
||||
continue;
|
||||
}
|
||||
|
||||
TGroupNode * pNewNode = TGroupNode::New();
|
||||
m_kVct_pkNode.push_back(pNewNode);
|
||||
|
||||
pNewNode->pParentNode = pGroupNode;
|
||||
pNewNode->SetGroupName(stTokenVector[1]);
|
||||
pGroupNode->ChildNodeVector.push_back(pNewNode);
|
||||
|
||||
++m_dwcurLineIndex;
|
||||
|
||||
if( false == LoadGroup(pNewNode) )
|
||||
return false;
|
||||
}
|
||||
// List
|
||||
else if (0 == stTokenVector[0].compare("list"))
|
||||
{
|
||||
if (2 != stTokenVector.size())
|
||||
{
|
||||
assert(!"There is no list name!");
|
||||
continue;
|
||||
}
|
||||
|
||||
CTokenVector stSubTokenVector;
|
||||
|
||||
stl_lowers(stTokenVector[1]);
|
||||
std::string key = stTokenVector[1];
|
||||
|
||||
stTokenVector.clear();
|
||||
|
||||
++m_dwcurLineIndex;
|
||||
for (; m_dwcurLineIndex < m_textFileLoader.GetLineCount(); ++m_dwcurLineIndex)
|
||||
{
|
||||
if (!m_textFileLoader.SplitLine(m_dwcurLineIndex, &stSubTokenVector))
|
||||
continue;
|
||||
|
||||
if ('{' == stSubTokenVector[0][0])
|
||||
continue;
|
||||
|
||||
if ('}' == stSubTokenVector[0][0])
|
||||
break;
|
||||
|
||||
for (DWORD j = 0; j < stSubTokenVector.size(); ++j)
|
||||
{
|
||||
stTokenVector.push_back(stSubTokenVector[j]);
|
||||
}
|
||||
}
|
||||
|
||||
pGroupNode->InsertTokenVector(key, stTokenVector);
|
||||
//pGroupNode->LocalTokenVectorMap.insert(std::make_pair(key, stTokenVector));
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string key = stTokenVector[0];
|
||||
|
||||
if (1 == stTokenVector.size())
|
||||
{
|
||||
TraceError("CTextFileLoader::LoadGroup : must have a value (filename: %s line: %d key: %s)",
|
||||
m_strFileName.c_str(),
|
||||
m_dwcurLineIndex,
|
||||
key.c_str());
|
||||
break;
|
||||
}
|
||||
|
||||
stTokenVector.erase(stTokenVector.begin());
|
||||
pGroupNode->InsertTokenVector(key, stTokenVector);
|
||||
//pGroupNode->LocalTokenVectorMap.insert(std::make_pair(key, stTokenVector));
|
||||
}
|
||||
}
|
||||
|
||||
return (nLocalGroupDepth == 0);
|
||||
}
|
||||
|
||||
void CTextFileLoader::SetTop()
|
||||
{
|
||||
m_pcurNode = &m_GlobalNode;
|
||||
}
|
||||
|
||||
DWORD CTextFileLoader::GetChildNodeCount()
|
||||
{
|
||||
if (!m_pcurNode)
|
||||
{
|
||||
assert(!"Node to access has not set!");
|
||||
return 0;
|
||||
}
|
||||
|
||||
return m_pcurNode->ChildNodeVector.size();
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::SetChildNode(const char * c_szKey)
|
||||
{
|
||||
if (!m_pcurNode)
|
||||
{
|
||||
assert(!"Node to access has not set!");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
DWORD dwKey=SGroupNode::GenNameKey(c_szKey, strlen(c_szKey));
|
||||
|
||||
for (DWORD i = 0; i < m_pcurNode->ChildNodeVector.size(); ++i)
|
||||
{
|
||||
TGroupNode * pGroupNode = m_pcurNode->ChildNodeVector[i];
|
||||
if (pGroupNode->IsGroupNameKey(dwKey))
|
||||
{
|
||||
m_pcurNode = pGroupNode;
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
BOOL CTextFileLoader::SetChildNode(const std::string & c_rstrKeyHead, DWORD dwIndex)
|
||||
{
|
||||
char szKey[32+1];
|
||||
_snprintf(szKey, sizeof(szKey), "%s%02u", c_rstrKeyHead.c_str(), dwIndex);
|
||||
|
||||
return SetChildNode(szKey);
|
||||
}
|
||||
BOOL CTextFileLoader::SetChildNode(DWORD dwIndex)
|
||||
{
|
||||
if (!m_pcurNode)
|
||||
{
|
||||
assert(!"Node to access has not set!");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (dwIndex >= m_pcurNode->ChildNodeVector.size())
|
||||
{
|
||||
assert(!"Node index to set is too large to access!");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
m_pcurNode = m_pcurNode->ChildNodeVector[dwIndex];
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::SetParentNode()
|
||||
{
|
||||
if (!m_pcurNode)
|
||||
{
|
||||
assert(!"Node to access has not set!");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (NULL == m_pcurNode->pParentNode)
|
||||
{
|
||||
assert(!"Current group node is already top!");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
m_pcurNode = m_pcurNode->pParentNode;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetCurrentNodeName(std::string * pstrName)
|
||||
{
|
||||
if (!m_pcurNode)
|
||||
return FALSE;
|
||||
if (NULL == m_pcurNode->pParentNode)
|
||||
return FALSE;
|
||||
|
||||
*pstrName = m_pcurNode->GetGroupName();
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::IsToken(const std::string & c_rstrKey)
|
||||
{
|
||||
if (!m_pcurNode)
|
||||
{
|
||||
assert(!"Node to access has not set!");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
return m_pcurNode->IsExistTokenVector(c_rstrKey);
|
||||
//return m_pcurNode->LocalTokenVectorMap.end() != m_pcurNode->LocalTokenVectorMap.find(c_rstrKey);
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenVector(const std::string & c_rstrKey, CTokenVector ** ppTokenVector)
|
||||
{
|
||||
if (!m_pcurNode)
|
||||
{
|
||||
assert(!"Node to access has not set!");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
CTokenVector* pkRetTokenVector=m_pcurNode->GetTokenVector(c_rstrKey);
|
||||
if (!pkRetTokenVector)
|
||||
return FALSE;
|
||||
|
||||
*ppTokenVector = pkRetTokenVector;
|
||||
|
||||
//CTokenVectorMap::iterator itor = m_pcurNode->LocalTokenVectorMap.find(c_rstrKey);
|
||||
//if (m_pcurNode->LocalTokenVectorMap.end() == itor)
|
||||
//{
|
||||
//Tracef(" CTextFileLoader::GetTokenVector - Failed to find the key %s [%s :: %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
|
||||
// return FALSE;
|
||||
//}
|
||||
|
||||
//*ppTokenVector = &itor->second;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenBoolean(const std::string & c_rstrKey, BOOL * pData)
|
||||
{
|
||||
CTokenVector * pTokenVector;
|
||||
if (!GetTokenVector(c_rstrKey, &pTokenVector))
|
||||
return FALSE;
|
||||
|
||||
if (pTokenVector->empty())
|
||||
{
|
||||
//Tracef(" CTextFileLoader::GetTokenBoolean - Failed to find the value %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
*pData = BOOL(atoi(pTokenVector->at(0).c_str()));
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenByte(const std::string & c_rstrKey, BYTE * pData)
|
||||
{
|
||||
CTokenVector * pTokenVector;
|
||||
if (!GetTokenVector(c_rstrKey, &pTokenVector))
|
||||
return FALSE;
|
||||
|
||||
if (pTokenVector->empty())
|
||||
{
|
||||
//Tracef(" CTextFileLoader::GetTokenByte - Failed to find the value %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
*pData = BYTE(atoi(pTokenVector->at(0).c_str()));
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenWord(const std::string & c_rstrKey, WORD * pData)
|
||||
{
|
||||
CTokenVector * pTokenVector;
|
||||
if (!GetTokenVector(c_rstrKey, &pTokenVector))
|
||||
return FALSE;
|
||||
|
||||
if (pTokenVector->empty())
|
||||
{
|
||||
//Tracef(" CTextFileLoader::GetTokenWord - Failed to find the value %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
*pData = WORD(atoi(pTokenVector->at(0).c_str()));
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenInteger(const std::string & c_rstrKey, int * pData)
|
||||
{
|
||||
CTokenVector * pTokenVector;
|
||||
if (!GetTokenVector(c_rstrKey, &pTokenVector))
|
||||
return FALSE;
|
||||
|
||||
if (pTokenVector->empty())
|
||||
{
|
||||
//Tracef(" CTextFileLoader::GetTokenInteger - Failed to find the value %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
*pData = atoi(pTokenVector->at(0).c_str());
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenDoubleWord(const std::string & c_rstrKey, DWORD * pData)
|
||||
{
|
||||
return GetTokenInteger(c_rstrKey, *(int **)(&pData));
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenFloat(const std::string & c_rstrKey, float * pData)
|
||||
{
|
||||
CTokenVector * pTokenVector;
|
||||
if (!GetTokenVector(c_rstrKey, &pTokenVector))
|
||||
return FALSE;
|
||||
|
||||
if (pTokenVector->empty())
|
||||
{
|
||||
//Tracef(" CTextFileLoader::GetTokenFloat - Failed to find the value %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
*pData = atof(pTokenVector->at(0).c_str());
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenVector2(const std::string & c_rstrKey, D3DXVECTOR2 * pVector2)
|
||||
{
|
||||
CTokenVector * pTokenVector;
|
||||
if (!GetTokenVector(c_rstrKey, &pTokenVector))
|
||||
return FALSE;
|
||||
|
||||
if (pTokenVector->size() != 2)
|
||||
{
|
||||
//Tracef(" CTextFileLoader::GetTokenVector2 - This key should have 2 values %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
pVector2->x = atof(pTokenVector->at(0).c_str());
|
||||
pVector2->y = atof(pTokenVector->at(1).c_str());
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenVector3(const std::string & c_rstrKey, D3DXVECTOR3 * pVector3)
|
||||
{
|
||||
CTokenVector * pTokenVector;
|
||||
if (!GetTokenVector(c_rstrKey, &pTokenVector))
|
||||
return FALSE;
|
||||
|
||||
if (pTokenVector->size() != 3)
|
||||
{
|
||||
//Tracef(" CTextFileLoader::GetTokenVector3 - This key should have 3 values %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
pVector3->x = atof(pTokenVector->at(0).c_str());
|
||||
pVector3->y = atof(pTokenVector->at(1).c_str());
|
||||
pVector3->z = atof(pTokenVector->at(2).c_str());
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenVector4(const std::string & c_rstrKey, D3DXVECTOR4 * pVector4)
|
||||
{
|
||||
CTokenVector * pTokenVector;
|
||||
if (!GetTokenVector(c_rstrKey, &pTokenVector))
|
||||
return FALSE;
|
||||
|
||||
if (pTokenVector->size() != 4)
|
||||
{
|
||||
//Tracef(" CTextFileLoader::GetTokenVector3 - This key should have 3 values %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
pVector4->x = atof(pTokenVector->at(0).c_str());
|
||||
pVector4->y = atof(pTokenVector->at(1).c_str());
|
||||
pVector4->z = atof(pTokenVector->at(2).c_str());
|
||||
pVector4->w = atof(pTokenVector->at(3).c_str());
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
BOOL CTextFileLoader::GetTokenPosition(const std::string & c_rstrKey, D3DXVECTOR3 * pVector)
|
||||
{
|
||||
return GetTokenVector3(c_rstrKey, pVector);
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenQuaternion(const std::string & c_rstrKey, D3DXQUATERNION * pQ)
|
||||
{
|
||||
CTokenVector * pTokenVector;
|
||||
if (!GetTokenVector(c_rstrKey, &pTokenVector))
|
||||
return FALSE;
|
||||
|
||||
if (pTokenVector->size() != 4)
|
||||
{
|
||||
//Tracef(" CTextFileLoader::GetTokenVector3 - This key should have 3 values %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
pQ->x = atof(pTokenVector->at(0).c_str());
|
||||
pQ->y = atof(pTokenVector->at(1).c_str());
|
||||
pQ->z = atof(pTokenVector->at(2).c_str());
|
||||
pQ->w = atof(pTokenVector->at(3).c_str());
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenDirection(const std::string & c_rstrKey, D3DVECTOR * pVector)
|
||||
{
|
||||
CTokenVector * pTokenVector;
|
||||
if (!GetTokenVector(c_rstrKey, &pTokenVector))
|
||||
return FALSE;
|
||||
|
||||
if (pTokenVector->size() != 3)
|
||||
{
|
||||
//Tracef(" CTextFileLoader::GetTokenDirection - This key should have 3 values %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
pVector->x = atof(pTokenVector->at(0).c_str());
|
||||
pVector->y = atof(pTokenVector->at(1).c_str());
|
||||
pVector->z = atof(pTokenVector->at(2).c_str());
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenColor(const std::string & c_rstrKey, D3DXCOLOR * pColor)
|
||||
{
|
||||
CTokenVector * pTokenVector;
|
||||
if (!GetTokenVector(c_rstrKey, &pTokenVector))
|
||||
return FALSE;
|
||||
|
||||
if (pTokenVector->size() != 4)
|
||||
{
|
||||
//Tracef(" CTextFileLoader::GetTokenColor - This key should have 4 values %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
pColor->r = atof(pTokenVector->at(0).c_str());
|
||||
pColor->g = atof(pTokenVector->at(1).c_str());
|
||||
pColor->b = atof(pTokenVector->at(2).c_str());
|
||||
pColor->a = atof(pTokenVector->at(3).c_str());
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenColor(const std::string & c_rstrKey, D3DCOLORVALUE * pColor)
|
||||
{
|
||||
CTokenVector * pTokenVector;
|
||||
if (!GetTokenVector(c_rstrKey, &pTokenVector))
|
||||
return FALSE;
|
||||
|
||||
if (pTokenVector->size() != 4)
|
||||
{
|
||||
//Tracef(" CTextFileLoader::GetTokenColor - This key should have 4 values %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
pColor->r = atof(pTokenVector->at(0).c_str());
|
||||
pColor->g = atof(pTokenVector->at(1).c_str());
|
||||
pColor->b = atof(pTokenVector->at(2).c_str());
|
||||
pColor->a = atof(pTokenVector->at(3).c_str());
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CTextFileLoader::GetTokenString(const std::string & c_rstrKey, std::string * pString)
|
||||
{
|
||||
CTokenVector * pTokenVector;
|
||||
if (!GetTokenVector(c_rstrKey, &pTokenVector))
|
||||
return FALSE;
|
||||
|
||||
if (pTokenVector->empty())
|
||||
{
|
||||
//Tracef(" CTextFileLoader::GetTokenString - Failed to find the value %s [%s : %s]\n", m_File.GetFileName(), m_pcurNode->strGroupName.c_str(), c_rstrKey.c_str());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
*pString = pTokenVector->at(0);
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
@@ -0,0 +1,237 @@
|
||||
#include "StdAfx.h"
|
||||
#include "../EterPack/EterPackManager.h"
|
||||
|
||||
#include "TextFileLoader.h"
|
||||
|
||||
void PrintfTabs(FILE * File, int iTabCount, const char * c_szString, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, c_szString);
|
||||
|
||||
static char szBuf[1024];
|
||||
_vsnprintf(szBuf, sizeof(szBuf), c_szString, args);
|
||||
va_end(args);
|
||||
|
||||
for (int i = 0; i < iTabCount; ++i)
|
||||
fprintf(File, " ");
|
||||
|
||||
fprintf(File, szBuf);
|
||||
}
|
||||
|
||||
bool LoadTextData(const char * c_szFileName, CTokenMap & rstTokenMap)
|
||||
{
|
||||
LPCVOID pMotionData;
|
||||
CMappedFile File;
|
||||
|
||||
if (!CEterPackManager::Instance().Get(File, c_szFileName, &pMotionData))
|
||||
return false;
|
||||
|
||||
CMemoryTextFileLoader textFileLoader;
|
||||
CTokenVector stTokenVector;
|
||||
|
||||
textFileLoader.Bind(File.Size(), pMotionData);
|
||||
|
||||
for (DWORD i = 0; i < textFileLoader.GetLineCount(); ++i)
|
||||
{
|
||||
if (!textFileLoader.SplitLine(i, &stTokenVector))
|
||||
continue;
|
||||
|
||||
if (2 != stTokenVector.size())
|
||||
return false;
|
||||
|
||||
stl_lowers(stTokenVector[0]);
|
||||
stl_lowers(stTokenVector[1]);
|
||||
|
||||
rstTokenMap[stTokenVector[0]] = stTokenVector[1];
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool LoadMultipleTextData(const char * c_szFileName, CTokenVectorMap & rstTokenVectorMap)
|
||||
{
|
||||
LPCVOID pModelData;
|
||||
CMappedFile File;
|
||||
|
||||
if (!CEterPackManager::Instance().Get(File, c_szFileName, &pModelData))
|
||||
return false;
|
||||
|
||||
DWORD i;
|
||||
|
||||
CMemoryTextFileLoader textFileLoader;
|
||||
CTokenVector stTokenVector;
|
||||
|
||||
textFileLoader.Bind(File.Size(), pModelData);
|
||||
|
||||
for (i = 0; i < textFileLoader.GetLineCount(); ++i)
|
||||
{
|
||||
if (!textFileLoader.SplitLine(i, &stTokenVector))
|
||||
continue;
|
||||
|
||||
stl_lowers(stTokenVector[0]);
|
||||
|
||||
// Start or End
|
||||
if (0 == stTokenVector[0].compare("start"))
|
||||
{
|
||||
CTokenVector stSubTokenVector;
|
||||
|
||||
stl_lowers(stTokenVector[1]);
|
||||
std::string key = stTokenVector[1];
|
||||
stTokenVector.clear();
|
||||
|
||||
for (i=i+1; i < textFileLoader.GetLineCount(); ++i)
|
||||
{
|
||||
if (!textFileLoader.SplitLine(i, &stSubTokenVector))
|
||||
continue;
|
||||
|
||||
stl_lowers(stSubTokenVector[0]);
|
||||
|
||||
if (0 == stSubTokenVector[0].compare("end"))
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
for (DWORD j = 0; j < stSubTokenVector.size(); ++j)
|
||||
{
|
||||
stTokenVector.push_back(stSubTokenVector[j]);
|
||||
}
|
||||
}
|
||||
|
||||
rstTokenVectorMap.insert(CTokenVectorMap::value_type(key, stTokenVector));
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string key = stTokenVector[0];
|
||||
stTokenVector.erase(stTokenVector.begin());
|
||||
rstTokenVectorMap.insert(CTokenVectorMap::value_type(key, stTokenVector));
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
D3DXVECTOR3 TokenToVector(CTokenVector & rVector)
|
||||
{
|
||||
if (3 != rVector.size())
|
||||
{
|
||||
assert(!"Size of token vector which will be converted to vector is not 3");
|
||||
return D3DXVECTOR3(0.0f, 0.0f, 0.0f);
|
||||
}
|
||||
|
||||
return D3DXVECTOR3(atof(rVector[0].c_str()),
|
||||
atof(rVector[1].c_str()),
|
||||
atof(rVector[2].c_str()));
|
||||
}
|
||||
|
||||
D3DXCOLOR TokenToColor(CTokenVector & rVector)
|
||||
{
|
||||
if (4 != rVector.size())
|
||||
{
|
||||
assert(!"Size of token vector which will be converted to color is not 4");
|
||||
return D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
|
||||
}
|
||||
|
||||
return D3DXCOLOR(atof(rVector[0].c_str()),
|
||||
atof(rVector[1].c_str()),
|
||||
atof(rVector[2].c_str()),
|
||||
atof(rVector[3].c_str()));
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// PORT: lines 142-296 of 40250 EterLib/Util.cpp (default code page and font face, with the Win32
|
||||
// EnumFontFamExProc callback) live in platform/EterLib/Util.cpp, which owns the font backend.
|
||||
|
||||
|
||||
int __base64_get( const int c )
|
||||
{
|
||||
if( 'A' <= c && c <= 'Z' )
|
||||
return c-'A';
|
||||
if( 'a' <= c && c <= 'z' )
|
||||
return c - 'a' + 26;
|
||||
if( '0' <= c && c <= '9' )
|
||||
return c - '0' + 52;
|
||||
if( c == '+' )
|
||||
return 62;
|
||||
if( c == '/' )
|
||||
return 63;
|
||||
if( c == '=' ) // end of line
|
||||
return -1;
|
||||
return -2; // non value;
|
||||
}
|
||||
|
||||
void __strcat1(char * str,int i)
|
||||
{
|
||||
char result[2];
|
||||
result[0] = i;
|
||||
result[1] = NULL;
|
||||
strcat(str,result);
|
||||
}
|
||||
|
||||
void base64_decode(const char * str,char * resultStr)
|
||||
{
|
||||
int nCount=0, i=0, r, result;
|
||||
int length = strlen(str);
|
||||
char szDest[5]="";
|
||||
|
||||
strcpy(resultStr,"");
|
||||
while(nCount < length)
|
||||
{
|
||||
i=0;
|
||||
strcpy(szDest, "");
|
||||
while(nCount<length && i<4) // 4개의 바이트를 얻는다.
|
||||
{
|
||||
r = str[nCount++];
|
||||
result = __base64_get(r);
|
||||
if(result!=-2)
|
||||
{
|
||||
if(result!=-1)
|
||||
szDest[i++] = result;
|
||||
else szDest[i++] = '@'; // It's end (64번은 디코딩시 사용되지 않기 때문)
|
||||
}
|
||||
}
|
||||
|
||||
if(i==4) // 4개의 소스를 모두 얻어냈다. 디코드 시작
|
||||
{
|
||||
if( nCount+3 >= length ) // 데이터의 끝에 도달했다.
|
||||
{
|
||||
if( szDest[1] == '@' )
|
||||
{
|
||||
__strcat1(resultStr,(szDest[0]<<2));
|
||||
break;
|
||||
}// exit while loop
|
||||
else
|
||||
__strcat1(resultStr,(szDest[0]<<2 | szDest[1]>>4)); // 1 Byte
|
||||
if( szDest[2] == '@' )
|
||||
{
|
||||
__strcat1(resultStr,(szDest[1]<<4));
|
||||
break;
|
||||
}
|
||||
else
|
||||
__strcat1(resultStr,(szDest[1]<<4 | szDest[2]>>2)); // 2 Byte
|
||||
if( szDest[3] == '@' )
|
||||
{
|
||||
__strcat1(resultStr,(szDest[2]<<6));
|
||||
break;
|
||||
}
|
||||
else
|
||||
__strcat1(resultStr,(szDest[2]<<6 | szDest[3])); // 3 Byte
|
||||
}
|
||||
else
|
||||
{
|
||||
__strcat1(resultStr,(szDest[0]<<2 | szDest[1]>>4)); // 1 Byte
|
||||
__strcat1(resultStr,(szDest[1]<<4 | szDest[2]>>2)); // 2 Byte
|
||||
__strcat1(resultStr,(szDest[2]<<6 | szDest[3])); // 3 Byte
|
||||
}
|
||||
}
|
||||
|
||||
}// end of while
|
||||
|
||||
for (i = 0; i < strlen(resultStr); i++)
|
||||
{
|
||||
char c = resultStr[i];
|
||||
int xx = i + 5;
|
||||
resultStr[i] = char(c ^ xx);
|
||||
}
|
||||
// E
|
||||
}
|
||||
@@ -0,0 +1,362 @@
|
||||
#include "StdAfx.h"
|
||||
#include "GameType.h"
|
||||
#include "../EffectLib/EffectManager.h"
|
||||
|
||||
extern float g_fGameFPS = 60.0f;
|
||||
|
||||
CDynamicPool<NRaceData::TCollisionData> NRaceData::g_CollisionDataPool;
|
||||
CDynamicPool<NRaceData::TAttachingEffectData> NRaceData::g_EffectDataPool;
|
||||
CDynamicPool<NRaceData::TAttachingObjectData> NRaceData::g_ObjectDataPool;
|
||||
|
||||
void NRaceData::DestroySystem()
|
||||
{
|
||||
g_CollisionDataPool.Destroy();
|
||||
g_EffectDataPool.Destroy();
|
||||
g_ObjectDataPool.Destroy();
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
// Character Attaching Collision Data
|
||||
BOOL NRaceData::LoadAttackData(CTextFileLoader & rTextFileLoader, TAttackData * pData)
|
||||
{
|
||||
if (!rTextFileLoader.GetTokenInteger("attacktype", &pData->iAttackType))
|
||||
{
|
||||
pData->iAttackType = ATTACK_TYPE_SPLASH;
|
||||
}
|
||||
if (!rTextFileLoader.GetTokenInteger("hittingtype", &pData->iHittingType))
|
||||
return false;
|
||||
if (!rTextFileLoader.GetTokenFloat("stiffentime", &pData->fStiffenTime))
|
||||
return false;
|
||||
if (!rTextFileLoader.GetTokenFloat("invisibletime", &pData->fInvisibleTime))
|
||||
return false;
|
||||
if (!rTextFileLoader.GetTokenFloat("externalforce", &pData->fExternalForce))
|
||||
return false;
|
||||
if (!rTextFileLoader.GetTokenInteger("hitlimitcount", &pData->iHitLimitCount))
|
||||
{
|
||||
pData->iHitLimitCount = 0;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NRaceData::THitData::Load(CTextFileLoader & rTextFileLoader)
|
||||
{
|
||||
if (!rTextFileLoader.GetTokenFloat("attackingstarttime", &fAttackStartTime))
|
||||
return false;
|
||||
if (!rTextFileLoader.GetTokenFloat("attackingendtime", &fAttackEndTime))
|
||||
return false;
|
||||
|
||||
if (!rTextFileLoader.GetTokenString("attackingbone", &strBoneName))
|
||||
strBoneName = "";
|
||||
if (!rTextFileLoader.GetTokenFloat("weaponlength",&fWeaponLength))
|
||||
fWeaponLength = 0.0f;
|
||||
|
||||
mapHitPosition.clear();
|
||||
|
||||
CTokenVector * tv;
|
||||
if (rTextFileLoader.GetTokenVector("hitposition",&tv))
|
||||
{
|
||||
CTokenVector::iterator it=tv->begin();
|
||||
|
||||
while(it!=tv->end())
|
||||
{
|
||||
float time;
|
||||
NRaceData::THitTimePosition hp;
|
||||
time = atof(it++->c_str());
|
||||
hp.v3LastPosition.x = atof(it++->c_str());
|
||||
hp.v3LastPosition.y = atof(it++->c_str());
|
||||
hp.v3LastPosition.z = atof(it++->c_str());
|
||||
hp.v3Position.x = atof(it++->c_str());
|
||||
hp.v3Position.y = atof(it++->c_str());
|
||||
hp.v3Position.z = atof(it++->c_str());
|
||||
|
||||
mapHitPosition[time] = hp;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
BOOL NRaceData::LoadMotionAttackData(CTextFileLoader & rTextFileLoader, TMotionAttackData * pData)
|
||||
{
|
||||
if (!LoadAttackData(rTextFileLoader, pData))
|
||||
return FALSE;
|
||||
|
||||
// NOTE : 기존의 AttackingType이 MotionType으로 바뀌었음
|
||||
// 기존 데이타의 경우 없으면 기존 것으로 읽게끔..
|
||||
if (!rTextFileLoader.GetTokenInteger("motiontype", &pData->iMotionType))
|
||||
{
|
||||
if (!rTextFileLoader.GetTokenInteger("attackingtype", &pData->iMotionType))
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
pData->HitDataContainer.clear();
|
||||
|
||||
DWORD dwHitDataCount;
|
||||
if (!rTextFileLoader.GetTokenDoubleWord("hitdatacount", &dwHitDataCount))
|
||||
{
|
||||
pData->HitDataContainer.push_back(SHitData());
|
||||
THitData & rHitData = *(pData->HitDataContainer.rbegin());
|
||||
if (!rHitData.Load(rTextFileLoader))
|
||||
return FALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (DWORD i = 0; i < dwHitDataCount; ++i)
|
||||
{
|
||||
if (!rTextFileLoader.SetChildNode(i))
|
||||
return FALSE;
|
||||
|
||||
pData->HitDataContainer.push_back(SHitData());
|
||||
THitData & rHitData = *(pData->HitDataContainer.rbegin());
|
||||
if (!rHitData.Load(rTextFileLoader))
|
||||
return FALSE;
|
||||
|
||||
rTextFileLoader.SetParentNode();
|
||||
}
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL NRaceData::LoadCollisionData(CTextFileLoader & rTextFileLoader, TCollisionData * pCollisionData)
|
||||
{
|
||||
if (!rTextFileLoader.GetTokenInteger("collisiontype", &pCollisionData->iCollisionType))
|
||||
return false;
|
||||
|
||||
DWORD dwSphereDataCount;
|
||||
if (!rTextFileLoader.GetTokenDoubleWord("spheredatacount", &dwSphereDataCount))
|
||||
return false;
|
||||
|
||||
pCollisionData->SphereDataVector.clear();
|
||||
pCollisionData->SphereDataVector.resize(dwSphereDataCount);
|
||||
for (DWORD i = 0; i < dwSphereDataCount; ++i)
|
||||
{
|
||||
TSphereData & r = pCollisionData->SphereDataVector[i].GetAttribute();
|
||||
|
||||
if (!rTextFileLoader.SetChildNode("spheredata", i))
|
||||
return false;
|
||||
|
||||
if (!rTextFileLoader.GetTokenFloat("radius", &r.fRadius))
|
||||
return false;
|
||||
if (!rTextFileLoader.GetTokenPosition("position", &r.v3Position))
|
||||
return false;
|
||||
|
||||
rTextFileLoader.SetParentNode();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void NRaceData::SaveEffectData(FILE * File, int iTabCount, const TAttachingEffectData & c_rEffectData)
|
||||
{
|
||||
PrintfTabs(File, iTabCount, "EffectScriptName \"%s\"\n", c_rEffectData.strFileName.c_str());
|
||||
|
||||
PrintfTabs(File, iTabCount, "EffectPosition %f %f %f\n", c_rEffectData.v3Position.x, c_rEffectData.v3Position.y, c_rEffectData.v3Position.z);
|
||||
PrintfTabs(File, iTabCount, "EffectRotation %f %f %f\n", c_rEffectData.v3Rotation.x, c_rEffectData.v3Rotation.y, c_rEffectData.v3Rotation.z);
|
||||
}
|
||||
|
||||
void NRaceData::SaveObjectData(FILE * File, int iTabCount, const TAttachingObjectData & c_rObjectData)
|
||||
{
|
||||
PrintfTabs(File, iTabCount, "ObjectScriptName \"%s\"\n", c_rObjectData.strFileName.c_str());
|
||||
}
|
||||
|
||||
BOOL NRaceData::LoadEffectData(CTextFileLoader & rTextFileLoader, TAttachingEffectData * pEffectData)
|
||||
{
|
||||
if (!rTextFileLoader.GetTokenString("effectscriptname",&pEffectData->strFileName))
|
||||
return false;
|
||||
|
||||
if (!rTextFileLoader.GetTokenPosition("effectposition",&pEffectData->v3Position))
|
||||
{
|
||||
pEffectData->v3Position = D3DXVECTOR3(0.0f,0.0f,0.0f);
|
||||
}
|
||||
|
||||
if (!rTextFileLoader.GetTokenPosition("effectrotation",&pEffectData->v3Rotation))
|
||||
{
|
||||
//pEffectData->qRotation = D3DXQUATERNION(0.0f,0.0f,0.0f,1.0f);
|
||||
pEffectData->v3Rotation = D3DXVECTOR3(0.0f,0.0f,0.0f);
|
||||
}
|
||||
|
||||
/*if (!*/
|
||||
// TODO DELETEME FIXME
|
||||
CEffectManager::Instance().RegisterEffect(pEffectData->strFileName.c_str());
|
||||
/*) return false;*/
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
BOOL NRaceData::LoadObjectData(CTextFileLoader & rTextFileLoader, TAttachingObjectData * pObjectData)
|
||||
{
|
||||
if (!rTextFileLoader.GetTokenString("objectscriptname",&pObjectData->strFileName))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void NRaceData::SaveAttackData(FILE * File, int iTabCount, const TAttackData & c_rData)
|
||||
{
|
||||
PrintfTabs(File, iTabCount, "AttackType %d\n", c_rData.iAttackType);
|
||||
PrintfTabs(File, iTabCount, "HittingType %d\n", c_rData.iHittingType);
|
||||
PrintfTabs(File, iTabCount, "StiffenTime %f\n", c_rData.fStiffenTime);
|
||||
PrintfTabs(File, iTabCount, "InvisibleTime %f\n", c_rData.fInvisibleTime);
|
||||
PrintfTabs(File, iTabCount, "ExternalForce %f\n", c_rData.fExternalForce);
|
||||
PrintfTabs(File, iTabCount, "HitLimitCount %d\n", c_rData.iHitLimitCount);
|
||||
}
|
||||
|
||||
void NRaceData::SaveMotionAttackData(FILE * File, int iTabCount, const TMotionAttackData & c_rData)
|
||||
{
|
||||
SaveAttackData(File, iTabCount, c_rData);
|
||||
|
||||
PrintfTabs(File, iTabCount, "\n");
|
||||
PrintfTabs(File, iTabCount, "MotionType %d\n", c_rData.iMotionType);
|
||||
PrintfTabs(File, iTabCount, "HitDataCount %d\n", c_rData.HitDataContainer.size());
|
||||
|
||||
DWORD dwHitDataNumber = 0;
|
||||
THitDataContainer::const_iterator itor = c_rData.HitDataContainer.begin();
|
||||
for (; itor != c_rData.HitDataContainer.end(); ++itor, ++dwHitDataNumber)
|
||||
{
|
||||
const THitData & c_rHitData = *itor;
|
||||
|
||||
PrintfTabs(File, iTabCount, "Group HitData%02d\n", dwHitDataNumber);
|
||||
PrintfTabs(File, iTabCount, "{\n");
|
||||
PrintfTabs(File, iTabCount+1, "AttackingStartTime %f\n", c_rHitData.fAttackStartTime);
|
||||
PrintfTabs(File, iTabCount+1, "AttackingEndTime %f\n", c_rHitData.fAttackEndTime);
|
||||
|
||||
PrintfTabs(File, iTabCount+1, "AttackingBone \"%s\"\n", c_rHitData.strBoneName.c_str());
|
||||
PrintfTabs(File, iTabCount+1, "WeaponLength %f\n", c_rHitData.fWeaponLength);
|
||||
PrintfTabs(File, iTabCount+1, "List HitPosition\n");
|
||||
PrintfTabs(File, iTabCount+1, "{\n");
|
||||
|
||||
NRaceData::THitTimePositionMap::const_iterator it;
|
||||
for(it = c_rHitData.mapHitPosition.begin(); it!= c_rHitData.mapHitPosition.end();++it)
|
||||
{
|
||||
PrintfTabs(File, iTabCount+2, "%f %f %f %f %f %f %f\n", it->first,
|
||||
it->second.v3LastPosition.x, it->second.v3LastPosition.y, it->second.v3LastPosition.z,
|
||||
it->second.v3Position.x, it->second.v3Position.y, it->second.v3Position.z);
|
||||
}
|
||||
PrintfTabs(File, iTabCount+1, "}\n");
|
||||
PrintfTabs(File, iTabCount, "}\n");
|
||||
}
|
||||
}
|
||||
|
||||
void NRaceData::SaveCollisionData(FILE * File, int iTabCount, const TCollisionData & c_rCollisionData)
|
||||
{
|
||||
PrintfTabs(File, iTabCount, "CollisionType %d\n", c_rCollisionData.iCollisionType);
|
||||
PrintfTabs(File, iTabCount, "\n");
|
||||
|
||||
const CSphereCollisionInstanceVector & c_rSphereDataVector = c_rCollisionData.SphereDataVector;
|
||||
|
||||
PrintfTabs(File, iTabCount, "SphereDataCount %d\n", c_rSphereDataVector.size());
|
||||
|
||||
for (DWORD i = 0; i < c_rSphereDataVector.size(); ++i)
|
||||
{
|
||||
const TSphereData & c_rAttr = c_rSphereDataVector[i].GetAttribute();
|
||||
|
||||
PrintfTabs(File, iTabCount, "Group SphereData%02d\n", i);
|
||||
|
||||
PrintfTabs(File, iTabCount, "{\n");
|
||||
|
||||
PrintfTabs(File, iTabCount+1, "Radius %f\n",
|
||||
c_rAttr.fRadius);
|
||||
|
||||
PrintfTabs(File, iTabCount+1, "Position %f %f %f\n",
|
||||
c_rAttr.v3Position.x,
|
||||
c_rAttr.v3Position.y,
|
||||
c_rAttr.v3Position.z);
|
||||
|
||||
PrintfTabs(File, iTabCount, "}\n");
|
||||
}
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
// Attaching Data
|
||||
void NRaceData::SaveAttachingData(FILE * File, int iTabCount, const TAttachingDataVector & c_rAttachingDataVector)
|
||||
{
|
||||
DWORD dwAttachingDataCount = c_rAttachingDataVector.size();
|
||||
|
||||
PrintfTabs(File, iTabCount, "AttachingDataCount %d\n", dwAttachingDataCount);
|
||||
PrintfTabs(File, iTabCount, "\n");
|
||||
|
||||
for (DWORD i = 0; i < dwAttachingDataCount; ++i)
|
||||
{
|
||||
const NRaceData::TAttachingData & c_rAttachingData = c_rAttachingDataVector[i];
|
||||
|
||||
PrintfTabs(File, iTabCount, "Group AttachingData%02d\n", i);
|
||||
PrintfTabs(File, iTabCount, "{\n", i);
|
||||
|
||||
PrintfTabs(File, iTabCount+1, "AttachingDataType %d\n", c_rAttachingData.dwType);
|
||||
PrintfTabs(File, iTabCount+1, "\n", i);
|
||||
|
||||
PrintfTabs(File, iTabCount+1, "isAttaching %d\n", c_rAttachingData.isAttaching);
|
||||
PrintfTabs(File, iTabCount+1, "AttachingModelIndex %d\n", c_rAttachingData.dwAttachingModelIndex);
|
||||
PrintfTabs(File, iTabCount+1, "AttachingBoneName \"%s\"\n", c_rAttachingData.strAttachingBoneName.c_str());
|
||||
PrintfTabs(File, iTabCount+1, "\n");
|
||||
|
||||
switch (c_rAttachingData.dwType)
|
||||
{
|
||||
case NRaceData::ATTACHING_DATA_TYPE_COLLISION_DATA:
|
||||
NRaceData::SaveCollisionData(File, iTabCount+1, *c_rAttachingData.pCollisionData);
|
||||
break;
|
||||
case NRaceData::ATTACHING_DATA_TYPE_EFFECT:
|
||||
NRaceData::SaveEffectData(File, iTabCount+1, *c_rAttachingData.pEffectData);
|
||||
break;
|
||||
case NRaceData::ATTACHING_DATA_TYPE_OBJECT:
|
||||
NRaceData::SaveObjectData(File, iTabCount+1, *c_rAttachingData.pObjectData);
|
||||
break;
|
||||
}
|
||||
|
||||
PrintfTabs(File, iTabCount, "}\n");
|
||||
|
||||
if (i != dwAttachingDataCount-1)
|
||||
PrintfTabs(File, iTabCount, "\n");
|
||||
}
|
||||
}
|
||||
|
||||
BOOL NRaceData::LoadAttachingData(CTextFileLoader & rTextFileLoader, TAttachingDataVector * pAttachingDataVector)
|
||||
{
|
||||
DWORD dwDataCount;
|
||||
if (!rTextFileLoader.GetTokenDoubleWord("attachingdatacount", &dwDataCount))
|
||||
return false;
|
||||
|
||||
pAttachingDataVector->clear();
|
||||
pAttachingDataVector->resize(dwDataCount);
|
||||
|
||||
for (DWORD i = 0; i < dwDataCount; ++i)
|
||||
{
|
||||
NRaceData::TAttachingData & rAttachingData = pAttachingDataVector->at(i);
|
||||
if (!rTextFileLoader.SetChildNode("attachingdata", i))
|
||||
return false;
|
||||
|
||||
if (!rTextFileLoader.GetTokenDoubleWord("attachingdatatype", &rAttachingData.dwType))
|
||||
return false;
|
||||
|
||||
if (!rTextFileLoader.GetTokenInteger("isattaching", &rAttachingData.isAttaching))
|
||||
return false;
|
||||
if (!rTextFileLoader.GetTokenDoubleWord("attachingmodelindex", &rAttachingData.dwAttachingModelIndex))
|
||||
return false;
|
||||
if (!rTextFileLoader.GetTokenString("attachingbonename", &rAttachingData.strAttachingBoneName))
|
||||
return false;
|
||||
|
||||
switch (rAttachingData.dwType)
|
||||
{
|
||||
case NRaceData::ATTACHING_DATA_TYPE_COLLISION_DATA:
|
||||
rAttachingData.pCollisionData = g_CollisionDataPool.Alloc();
|
||||
if (!NRaceData::LoadCollisionData(rTextFileLoader, rAttachingData.pCollisionData))
|
||||
return false;
|
||||
break;
|
||||
case NRaceData::ATTACHING_DATA_TYPE_EFFECT:
|
||||
rAttachingData.pEffectData = g_EffectDataPool.Alloc();
|
||||
if (!NRaceData::LoadEffectData(rTextFileLoader, rAttachingData.pEffectData))
|
||||
return false;
|
||||
break;
|
||||
case NRaceData::ATTACHING_DATA_TYPE_OBJECT:
|
||||
rAttachingData.pObjectData = g_ObjectDataPool.Alloc();
|
||||
if (!NRaceData::LoadObjectData(rTextFileLoader, rAttachingData.pObjectData))
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
|
||||
rTextFileLoader.SetParentNode();
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
@@ -0,0 +1,186 @@
|
||||
#include "StdAfx.h"
|
||||
#include "../EterLib/ResourceManager.h"
|
||||
|
||||
#include "RaceData.h"
|
||||
#include "RaceMotionData.h"
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
BOOL CRaceData::LoadRaceData(const char * c_szFileName)
|
||||
{
|
||||
CTextFileLoader TextFileLoader;
|
||||
if (!TextFileLoader.Load(c_szFileName))
|
||||
return FALSE;
|
||||
|
||||
TextFileLoader.SetTop();
|
||||
|
||||
TextFileLoader.GetTokenString("basemodelfilename", &m_strBaseModelFileName);
|
||||
TextFileLoader.GetTokenString("treefilename", &m_strTreeFileName);
|
||||
TextFileLoader.GetTokenString("attributefilename", &m_strAttributeFileName);
|
||||
TextFileLoader.GetTokenString("smokebonename", &m_strSmokeBoneName);
|
||||
TextFileLoader.GetTokenString("motionlistfilename", &m_strMotionListFileName);
|
||||
|
||||
if (!m_strTreeFileName.empty())
|
||||
{
|
||||
CFileNameHelper::StringPath(m_strTreeFileName);
|
||||
}
|
||||
|
||||
CTokenVector* pSmokeTokenVector;
|
||||
if (TextFileLoader.GetTokenVector("smokefilename", &pSmokeTokenVector))
|
||||
{
|
||||
if (pSmokeTokenVector->size()%2!=0)
|
||||
{
|
||||
TraceError("SmokeFileName ArgCount[%d]%2==0", pSmokeTokenVector->size());
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
UINT uLineCount=pSmokeTokenVector->size()/2;
|
||||
|
||||
for (UINT uLine=0; uLine<uLineCount; ++uLine)
|
||||
{
|
||||
int eSmoke=atoi(pSmokeTokenVector->at(uLine*2+0).c_str());
|
||||
if (eSmoke<0 || eSmoke>=SMOKE_NUM)
|
||||
{
|
||||
TraceError("SmokeFileName SmokeNum[%d] OUT OF RANGE", eSmoke);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
const std::string& c_rstrEffectFileName = pSmokeTokenVector->at(uLine*2+1);
|
||||
|
||||
DWORD& rdwCRCEft=m_adwSmokeEffectID[eSmoke];
|
||||
if (!CEffectManager::Instance().RegisterEffect2(c_rstrEffectFileName.c_str(), &rdwCRCEft))
|
||||
{
|
||||
TraceError("CRaceData::RegisterEffect2(%s) ERROR", c_rstrEffectFileName.c_str());
|
||||
rdwCRCEft=0;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (TextFileLoader.SetChildNode("shapedata"))
|
||||
{
|
||||
std::string strPathName;
|
||||
DWORD dwShapeDataCount = 0;
|
||||
if (TextFileLoader.GetTokenString("pathname", &strPathName) &&
|
||||
TextFileLoader.GetTokenDoubleWord("shapedatacount", &dwShapeDataCount))
|
||||
{
|
||||
for (DWORD i = 0; i < dwShapeDataCount; ++i)
|
||||
{
|
||||
if (!TextFileLoader.SetChildNode("shapedata", i))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
/////////////////////////
|
||||
// Temporary - 이벤트를 위한 임시 기능
|
||||
TextFileLoader.GetTokenString("specialpath", &strPathName);
|
||||
/////////////////////////
|
||||
|
||||
DWORD dwShapeIndex;
|
||||
if (!TextFileLoader.GetTokenDoubleWord("shapeindex", &dwShapeIndex))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
// LOCAL_PATH_SUPPORT
|
||||
std::string strModel;
|
||||
if (TextFileLoader.GetTokenString("model", &strModel))
|
||||
{
|
||||
SetShapeModel(dwShapeIndex, (strPathName + strModel).c_str());
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!TextFileLoader.GetTokenString("local_model", &strModel))
|
||||
continue;
|
||||
|
||||
SetShapeModel(dwShapeIndex, strModel.c_str());
|
||||
}
|
||||
// END_OF_LOCAL_PATH_SUPPORT
|
||||
|
||||
|
||||
|
||||
std::string strSourceSkin;
|
||||
std::string strTargetSkin;
|
||||
|
||||
// LOCAL_PATH_SUPPORT
|
||||
if (TextFileLoader.GetTokenString("local_sourceskin", &strSourceSkin) &&
|
||||
TextFileLoader.GetTokenString("local_targetskin", &strTargetSkin))
|
||||
{
|
||||
AppendShapeSkin(dwShapeIndex, 0, strSourceSkin.c_str(), strTargetSkin.c_str());
|
||||
}
|
||||
// END_OF_LOCAL_PATH_SUPPORT
|
||||
|
||||
if (TextFileLoader.GetTokenString("sourceskin", &strSourceSkin) &&
|
||||
TextFileLoader.GetTokenString("targetskin", &strTargetSkin))
|
||||
{
|
||||
AppendShapeSkin(dwShapeIndex, 0, (strPathName + strSourceSkin).c_str(), (strPathName + strTargetSkin).c_str());
|
||||
}
|
||||
|
||||
if (TextFileLoader.GetTokenString("sourceskin2", &strSourceSkin) &&
|
||||
TextFileLoader.GetTokenString("targetskin2", &strTargetSkin))
|
||||
{
|
||||
AppendShapeSkin(dwShapeIndex, 0, (strPathName + strSourceSkin).c_str(), (strPathName + strTargetSkin).c_str());
|
||||
}
|
||||
|
||||
TextFileLoader.SetParentNode();
|
||||
}
|
||||
}
|
||||
|
||||
TextFileLoader.SetParentNode();
|
||||
}
|
||||
|
||||
if (TextFileLoader.SetChildNode("hairdata"))
|
||||
{
|
||||
std::string strPathName;
|
||||
DWORD dwHairDataCount = 0;
|
||||
if (TextFileLoader.GetTokenString("pathname", &strPathName) &&
|
||||
TextFileLoader.GetTokenDoubleWord("hairdatacount", &dwHairDataCount))
|
||||
{
|
||||
|
||||
for (DWORD i = 0; i < dwHairDataCount; ++i)
|
||||
{
|
||||
if (!TextFileLoader.SetChildNode("hairdata", i))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
/////////////////////////
|
||||
// Temporary - 이벤트를 위한 임시 기능
|
||||
TextFileLoader.GetTokenString("specialpath", &strPathName);
|
||||
/////////////////////////
|
||||
|
||||
DWORD dwShapeIndex;
|
||||
if (!TextFileLoader.GetTokenDoubleWord("hairindex", &dwShapeIndex))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
std::string strModel;
|
||||
std::string strSourceSkin;
|
||||
std::string strTargetSkin;
|
||||
if (TextFileLoader.GetTokenString("model", &strModel) &&
|
||||
TextFileLoader.GetTokenString("sourceskin", &strSourceSkin) &&
|
||||
TextFileLoader.GetTokenString("targetskin", &strTargetSkin))
|
||||
{
|
||||
SetHairSkin(dwShapeIndex, 0, (strPathName + strModel).c_str(), (strPathName + strSourceSkin).c_str(), (strPathName + strTargetSkin).c_str());
|
||||
}
|
||||
|
||||
TextFileLoader.SetParentNode();
|
||||
}
|
||||
}
|
||||
|
||||
TextFileLoader.SetParentNode();
|
||||
}
|
||||
|
||||
|
||||
if (TextFileLoader.SetChildNode("attachingdata"))
|
||||
{
|
||||
if (!NRaceData::LoadAttachingData(TextFileLoader, &m_AttachingDataVector))
|
||||
return FALSE;
|
||||
|
||||
TextFileLoader.SetParentNode();
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
@@ -0,0 +1,617 @@
|
||||
#include "StdAfx.h"
|
||||
#include "../EffectLib/EffectManager.h"
|
||||
#include "FlyingObjectManager.h"
|
||||
#include "RaceMotionData.h"
|
||||
|
||||
CDynamicPool<CRaceMotionData> CRaceMotionData::ms_kPool;
|
||||
|
||||
void CRaceMotionData::CreateSystem(UINT uCapacity)
|
||||
{
|
||||
ms_kPool.Create(uCapacity);
|
||||
}
|
||||
|
||||
void CRaceMotionData::DestroySystem()
|
||||
{
|
||||
ms_kPool.Clear();
|
||||
}
|
||||
|
||||
CRaceMotionData* CRaceMotionData::New()
|
||||
{
|
||||
return ms_kPool.Alloc();
|
||||
}
|
||||
|
||||
void CRaceMotionData::Delete(CRaceMotionData* pkData)
|
||||
{
|
||||
pkData->Destroy();
|
||||
|
||||
ms_kPool.Free(pkData);
|
||||
}
|
||||
|
||||
void CRaceMotionData::SetName(UINT eName)
|
||||
{
|
||||
m_eName=eName;
|
||||
|
||||
switch (m_eName)
|
||||
{
|
||||
case NAME_NONE:
|
||||
SetType(TYPE_NONE);
|
||||
break;
|
||||
case NAME_WAIT:
|
||||
case NAME_INTRO_WAIT:
|
||||
case NAME_STOP:
|
||||
SetType(TYPE_WAIT);
|
||||
break;
|
||||
case NAME_WALK:
|
||||
case NAME_RUN:
|
||||
SetType(TYPE_MOVE);
|
||||
break;
|
||||
case NAME_DAMAGE:
|
||||
case NAME_DAMAGE_BACK:
|
||||
SetType(TYPE_DAMAGE);
|
||||
break;
|
||||
case NAME_DAMAGE_FLYING:
|
||||
case NAME_DAMAGE_FLYING_BACK:
|
||||
SetType(TYPE_KNOCKDOWN);
|
||||
break;
|
||||
case NAME_STAND_UP:
|
||||
case NAME_STAND_UP_BACK:
|
||||
SetType(TYPE_STANDUP);
|
||||
break;
|
||||
case NAME_SPAWN:
|
||||
case NAME_CHANGE_WEAPON:
|
||||
case NAME_INTRO_SELECTED:
|
||||
case NAME_INTRO_NOT_SELECTED:
|
||||
case NAME_SPECIAL_1:
|
||||
case NAME_SPECIAL_2:
|
||||
case NAME_SPECIAL_3:
|
||||
case NAME_SPECIAL_4:
|
||||
case NAME_SPECIAL_5:
|
||||
case NAME_SPECIAL_6:
|
||||
case NAME_CLAP:
|
||||
case NAME_DANCE_1:
|
||||
case NAME_DANCE_2:
|
||||
case NAME_DANCE_3:
|
||||
case NAME_DANCE_4:
|
||||
case NAME_DANCE_5:
|
||||
case NAME_DANCE_6:
|
||||
case NAME_CONGRATULATION:
|
||||
case NAME_FORGIVE:
|
||||
case NAME_ANGRY:
|
||||
case NAME_ATTRACTIVE:
|
||||
case NAME_SAD:
|
||||
case NAME_SHY:
|
||||
case NAME_CHEERUP:
|
||||
case NAME_BANTER:
|
||||
case NAME_JOY:
|
||||
case NAME_CHEERS_1:
|
||||
case NAME_CHEERS_2:
|
||||
case NAME_KISS_WITH_WARRIOR:
|
||||
case NAME_KISS_WITH_ASSASSIN:
|
||||
case NAME_KISS_WITH_SURA:
|
||||
case NAME_KISS_WITH_SHAMAN:
|
||||
case NAME_FRENCH_KISS_WITH_WARRIOR:
|
||||
case NAME_FRENCH_KISS_WITH_ASSASSIN:
|
||||
case NAME_FRENCH_KISS_WITH_SURA:
|
||||
case NAME_FRENCH_KISS_WITH_SHAMAN:
|
||||
case NAME_SLAP_HIT_WITH_WARRIOR:
|
||||
case NAME_SLAP_HIT_WITH_ASSASSIN:
|
||||
case NAME_SLAP_HIT_WITH_SURA:
|
||||
case NAME_SLAP_HIT_WITH_SHAMAN:
|
||||
case NAME_SLAP_HURT_WITH_WARRIOR:
|
||||
case NAME_SLAP_HURT_WITH_ASSASSIN:
|
||||
case NAME_SLAP_HURT_WITH_SURA:
|
||||
case NAME_SLAP_HURT_WITH_SHAMAN:
|
||||
case NAME_DIG:
|
||||
SetType(TYPE_EVENT);
|
||||
break;
|
||||
case NAME_DEAD:
|
||||
case NAME_DEAD_BACK:
|
||||
SetType(TYPE_DIE);
|
||||
break;
|
||||
case NAME_NORMAL_ATTACK:
|
||||
SetType(TYPE_ATTACK);
|
||||
break;
|
||||
case NAME_COMBO_ATTACK_1:
|
||||
case NAME_COMBO_ATTACK_2:
|
||||
case NAME_COMBO_ATTACK_3:
|
||||
case NAME_COMBO_ATTACK_4:
|
||||
case NAME_COMBO_ATTACK_5:
|
||||
case NAME_COMBO_ATTACK_6:
|
||||
case NAME_COMBO_ATTACK_7:
|
||||
case NAME_COMBO_ATTACK_8:
|
||||
SetType(TYPE_COMBO);
|
||||
break;
|
||||
case NAME_FISHING_THROW:
|
||||
case NAME_FISHING_WAIT:
|
||||
case NAME_FISHING_REACT:
|
||||
case NAME_FISHING_CATCH:
|
||||
case NAME_FISHING_FAIL:
|
||||
case NAME_FISHING_STOP:
|
||||
SetType(TYPE_FISHING);
|
||||
break;
|
||||
default:
|
||||
if (eName>=NAME_SKILL && eName<=NAME_SKILL+SKILL_NUM)
|
||||
SetType(TYPE_SKILL);
|
||||
else
|
||||
TraceError("CRaceMotionData::SetName - UNKNOWN NAME %d", eName);
|
||||
break;
|
||||
}
|
||||
}
|
||||
void CRaceMotionData::SetType(UINT eType)
|
||||
{
|
||||
m_eType=eType;
|
||||
|
||||
switch (m_eType)
|
||||
{
|
||||
case TYPE_ATTACK:
|
||||
case TYPE_COMBO:
|
||||
case TYPE_SKILL:
|
||||
m_isLock=TRUE;
|
||||
break;
|
||||
default:
|
||||
m_isLock=FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
UINT CRaceMotionData::GetType() const
|
||||
{
|
||||
return m_eType;
|
||||
}
|
||||
|
||||
bool CRaceMotionData::IsLock() const
|
||||
{
|
||||
return m_isLock ? true : false;
|
||||
}
|
||||
|
||||
int CRaceMotionData::GetLoopCount() const
|
||||
{
|
||||
return m_iLoopCount;
|
||||
}
|
||||
|
||||
float CRaceMotionData::GetMotionDuration()
|
||||
{
|
||||
return m_fMotionDuration;
|
||||
}
|
||||
|
||||
void CRaceMotionData::SetMotionDuration(float fDuration)
|
||||
{
|
||||
m_fMotionDuration = fDuration;
|
||||
}
|
||||
|
||||
// Combo
|
||||
BOOL CRaceMotionData::IsComboInputTimeData() const
|
||||
{
|
||||
return m_isComboMotion;
|
||||
}
|
||||
|
||||
float CRaceMotionData::GetComboInputStartTime() const
|
||||
{
|
||||
assert(m_isComboMotion);
|
||||
return m_ComboInputData.fInputStartTime;
|
||||
}
|
||||
|
||||
float CRaceMotionData::GetNextComboTime() const
|
||||
{
|
||||
assert(m_isComboMotion);
|
||||
return m_ComboInputData.fNextComboTime;
|
||||
}
|
||||
|
||||
float CRaceMotionData::GetComboInputEndTime() const
|
||||
{
|
||||
assert(m_isComboMotion);
|
||||
return m_ComboInputData.fInputEndTime;
|
||||
}
|
||||
|
||||
// Attacking
|
||||
BOOL CRaceMotionData::isAttackingMotion() const
|
||||
{
|
||||
return m_isAttackingMotion;
|
||||
}
|
||||
|
||||
const NRaceData::TMotionAttackData * CRaceMotionData::GetMotionAttackDataPointer() const
|
||||
{
|
||||
return & m_MotionAttackData;
|
||||
}
|
||||
|
||||
const NRaceData::TMotionAttackData & CRaceMotionData::GetMotionAttackDataReference() const
|
||||
{
|
||||
assert(m_isAttackingMotion);
|
||||
return m_MotionAttackData;
|
||||
}
|
||||
|
||||
BOOL CRaceMotionData::HasSplashMotionEvent() const
|
||||
{
|
||||
return m_hasSplashEvent;
|
||||
}
|
||||
|
||||
// Skill
|
||||
BOOL CRaceMotionData::IsCancelEnableSkill() const
|
||||
{
|
||||
return m_bCancelEnableSkill;
|
||||
}
|
||||
|
||||
// Loop
|
||||
BOOL CRaceMotionData::IsLoopMotion() const
|
||||
{
|
||||
return m_isLoopMotion;
|
||||
}
|
||||
|
||||
float CRaceMotionData::GetLoopStartTime() const
|
||||
{
|
||||
return m_fLoopStartTime;
|
||||
}
|
||||
|
||||
float CRaceMotionData::GetLoopEndTime() const
|
||||
{
|
||||
return m_fLoopEndTime;
|
||||
}
|
||||
|
||||
// Motion Event Data
|
||||
DWORD CRaceMotionData::GetMotionEventDataCount() const
|
||||
{
|
||||
return m_MotionEventDataVector.size();
|
||||
}
|
||||
|
||||
BOOL CRaceMotionData::GetMotionEventDataPointer(BYTE byIndex, const CRaceMotionData::TMotionEventData ** c_ppData) const
|
||||
{
|
||||
if (byIndex >= m_MotionEventDataVector.size())
|
||||
return FALSE;
|
||||
|
||||
*c_ppData = m_MotionEventDataVector[byIndex];
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL CRaceMotionData::GetMotionAttackingEventDataPointer(BYTE byIndex, const CRaceMotionData::TMotionAttackingEventData ** c_ppData) const
|
||||
{
|
||||
if (byIndex >= m_MotionEventDataVector.size())
|
||||
return FALSE;
|
||||
|
||||
const CRaceMotionData::TMotionEventData * pData = m_MotionEventDataVector[byIndex];
|
||||
const CRaceMotionData::TMotionAttackingEventData * pAttackingEvent = (const CRaceMotionData::TMotionAttackingEventData *)pData;
|
||||
|
||||
if (MOTION_EVENT_TYPE_SPECIAL_ATTACKING == pAttackingEvent->iType)
|
||||
return FALSE;
|
||||
|
||||
*c_ppData = pAttackingEvent;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
int CRaceMotionData::GetEventType(DWORD dwIndex) const
|
||||
{
|
||||
if (dwIndex >= m_MotionEventDataVector.size())
|
||||
return MOTION_EVENT_TYPE_NONE;
|
||||
|
||||
return m_MotionEventDataVector[dwIndex]->iType;
|
||||
}
|
||||
|
||||
float CRaceMotionData::GetEventStartTime(DWORD dwIndex) const
|
||||
{
|
||||
if (dwIndex >= m_MotionEventDataVector.size())
|
||||
return 0.0f;
|
||||
|
||||
return m_MotionEventDataVector[dwIndex]->fStartingTime;
|
||||
}
|
||||
|
||||
const NSound::TSoundInstanceVector * CRaceMotionData::GetSoundInstanceVectorPointer() const
|
||||
{
|
||||
return &m_SoundInstanceVector;
|
||||
}
|
||||
|
||||
void CRaceMotionData::SetAccumulationPosition(const TPixelPosition & c_rPos)
|
||||
{
|
||||
m_accumulationPosition = c_rPos;
|
||||
m_isAccumulationMotion = TRUE;
|
||||
}
|
||||
|
||||
bool CRaceMotionData::LoadMotionData(const char * c_szFileName)
|
||||
{
|
||||
const float c_fFrameTime = 1.0f / g_fGameFPS;
|
||||
|
||||
CTextFileLoader* pkTextFileLoader=CTextFileLoader::Cache(c_szFileName);
|
||||
if (!pkTextFileLoader)
|
||||
return false;
|
||||
|
||||
CTextFileLoader& rkTextFileLoader=*pkTextFileLoader;
|
||||
|
||||
if (rkTextFileLoader.IsEmpty())
|
||||
return false;
|
||||
|
||||
rkTextFileLoader.SetTop();
|
||||
|
||||
if (!rkTextFileLoader.GetTokenString("motionfilename", &m_strMotionFileName))
|
||||
return false;
|
||||
|
||||
if (!rkTextFileLoader.GetTokenFloat("motionduration", &m_fMotionDuration))
|
||||
return false;
|
||||
|
||||
CTokenVector * pTokenVector;
|
||||
|
||||
if (rkTextFileLoader.GetTokenVector("accumulation", &pTokenVector))
|
||||
{
|
||||
if (pTokenVector->size() != 3)
|
||||
{
|
||||
TraceError("CRaceMotioNData::LoadMotionData : syntax error on accumulation, vector size %d", pTokenVector->size());
|
||||
return false;
|
||||
}
|
||||
|
||||
TPixelPosition pos(atof(pTokenVector->at(0).c_str()),
|
||||
atof(pTokenVector->at(1).c_str()),
|
||||
atof(pTokenVector->at(2).c_str()));
|
||||
|
||||
SetAccumulationPosition(pos);
|
||||
}
|
||||
|
||||
std::string strNodeName;
|
||||
for (DWORD i = 0; i < rkTextFileLoader.GetChildNodeCount(); ++i)
|
||||
{
|
||||
CTextFileLoader::CGotoChild GotoChild(&rkTextFileLoader, i);
|
||||
|
||||
rkTextFileLoader.GetCurrentNodeName(&strNodeName);
|
||||
|
||||
if (0 == strNodeName.compare("comboinputdata"))
|
||||
{
|
||||
m_isComboMotion = TRUE;
|
||||
|
||||
if (!rkTextFileLoader.GetTokenFloat("preinputtime", &m_ComboInputData.fInputStartTime))
|
||||
return false;
|
||||
if (!rkTextFileLoader.GetTokenFloat("directinputtime", &m_ComboInputData.fNextComboTime))
|
||||
return false;
|
||||
if (!rkTextFileLoader.GetTokenFloat("inputlimittime", &m_ComboInputData.fInputEndTime))
|
||||
return false;
|
||||
}
|
||||
else if (0 == strNodeName.compare("attackingdata"))
|
||||
{
|
||||
m_isAttackingMotion = TRUE;
|
||||
|
||||
if (!NRaceData::LoadMotionAttackData(rkTextFileLoader, &m_MotionAttackData))
|
||||
return false;
|
||||
}
|
||||
else if (0 == strNodeName.compare("loopdata"))
|
||||
{
|
||||
m_isLoopMotion = TRUE;
|
||||
if (!rkTextFileLoader.GetTokenInteger("motionloopcount", &m_iLoopCount))
|
||||
{
|
||||
m_iLoopCount = -1;
|
||||
}
|
||||
if (!rkTextFileLoader.GetTokenInteger("loopcancelenable", &m_bCancelEnableSkill))
|
||||
{
|
||||
m_bCancelEnableSkill = FALSE;
|
||||
}
|
||||
if (!rkTextFileLoader.GetTokenFloat("loopstarttime", &m_fLoopStartTime))
|
||||
return false;
|
||||
if (!rkTextFileLoader.GetTokenFloat("loopendtime", &m_fLoopEndTime))
|
||||
return false;
|
||||
}
|
||||
else if (0 == strNodeName.compare("motioneventdata"))
|
||||
{
|
||||
DWORD dwMotionEventDataCount;
|
||||
|
||||
if (!rkTextFileLoader.GetTokenDoubleWord("motioneventdatacount", &dwMotionEventDataCount))
|
||||
continue;
|
||||
|
||||
stl_wipe(m_MotionEventDataVector);
|
||||
|
||||
m_MotionEventDataVector.resize(dwMotionEventDataCount, NULL);
|
||||
|
||||
for (DWORD j = 0; j < m_MotionEventDataVector.size(); ++j)
|
||||
{
|
||||
if (!rkTextFileLoader.SetChildNode("event", j))
|
||||
return false;
|
||||
|
||||
int iType;
|
||||
if (!rkTextFileLoader.GetTokenInteger("motioneventtype", &iType))
|
||||
return false;
|
||||
|
||||
TMotionEventData * pData = NULL;
|
||||
switch(iType)
|
||||
{
|
||||
case MOTION_EVENT_TYPE_FLY:
|
||||
pData = new TMotionFlyEventData;
|
||||
break;
|
||||
case MOTION_EVENT_TYPE_EFFECT:
|
||||
pData = new TMotionEffectEventData;
|
||||
break;
|
||||
case MOTION_EVENT_TYPE_SCREEN_WAVING:
|
||||
pData = new TScreenWavingEventData;
|
||||
break;
|
||||
case MOTION_EVENT_TYPE_SPECIAL_ATTACKING:
|
||||
pData = new TMotionAttackingEventData;
|
||||
m_hasSplashEvent = TRUE;
|
||||
break;
|
||||
case MOTION_EVENT_TYPE_SOUND:
|
||||
pData = new TMotionSoundEventData;
|
||||
break;
|
||||
case MOTION_EVENT_TYPE_CHARACTER_SHOW:
|
||||
pData = new TMotionCharacterShowEventData;
|
||||
break;
|
||||
case MOTION_EVENT_TYPE_CHARACTER_HIDE:
|
||||
pData = new TMotionCharacterHideEventData;
|
||||
break;
|
||||
case MOTION_EVENT_TYPE_WARP:
|
||||
pData = new TMotionWarpEventData;
|
||||
break;
|
||||
case MOTION_EVENT_TYPE_EFFECT_TO_TARGET:
|
||||
pData = new TMotionEffectToTargetEventData;
|
||||
break;
|
||||
default:
|
||||
assert(!" CRaceMotionData::LoadMotionData - Strange Event Type");
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
m_MotionEventDataVector[j] = pData;
|
||||
m_MotionEventDataVector[j]->Load(rkTextFileLoader);
|
||||
m_MotionEventDataVector[j]->iType = iType;
|
||||
if (!rkTextFileLoader.GetTokenFloat("startingtime", &m_MotionEventDataVector[j]->fStartingTime))
|
||||
return false;
|
||||
|
||||
m_MotionEventDataVector[j]->dwFrame = (m_MotionEventDataVector[j]->fStartingTime / c_fFrameTime);
|
||||
|
||||
rkTextFileLoader.SetParentNode();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::string strSoundFileNameTemp=c_szFileName;
|
||||
strSoundFileNameTemp = CFileNameHelper::NoExtension(strSoundFileNameTemp);
|
||||
strSoundFileNameTemp+= ".mss";
|
||||
|
||||
if (strSoundFileNameTemp.length() > 13)
|
||||
{
|
||||
const char * c_szHeader = &strSoundFileNameTemp[13];
|
||||
|
||||
m_strSoundScriptDataFileName = "sound/";
|
||||
m_strSoundScriptDataFileName += c_szHeader;
|
||||
|
||||
LoadSoundScriptData(m_strSoundScriptDataFileName.c_str());
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
#ifdef WORLD_EDITOR
|
||||
bool CRaceMotionData::SaveMotionData(const char * c_szFileName)
|
||||
{
|
||||
FILE * File;
|
||||
|
||||
SetFileAttributes(c_szFileName, FILE_ATTRIBUTE_NORMAL);
|
||||
File = fopen(c_szFileName, "w");
|
||||
|
||||
if (!File)
|
||||
{
|
||||
TraceError("CRaceMotionData::SaveMotionData : cannot open file for writing (filename: %s)", c_szFileName);
|
||||
return false;
|
||||
}
|
||||
|
||||
fprintf(File, "ScriptType MotionData\n");
|
||||
fprintf(File, "\n");
|
||||
|
||||
fprintf(File, "MotionFileName \"%s\"\n", m_strMotionFileName.c_str());
|
||||
fprintf(File, "MotionDuration %f\n", m_fMotionDuration);
|
||||
|
||||
if (m_isAccumulationMotion)
|
||||
fprintf(File, "Accumulation %.2f\t%.2f\t%.2f\n", m_accumulationPosition.x, m_accumulationPosition.y, m_accumulationPosition.z);
|
||||
|
||||
fprintf(File, "\n");
|
||||
|
||||
if (m_isComboMotion)
|
||||
{
|
||||
fprintf(File, "Group ComboInputData\n");
|
||||
fprintf(File, "{\n");
|
||||
fprintf(File, " PreInputTime %f\n", m_ComboInputData.fInputStartTime);
|
||||
fprintf(File, " DirectInputTime %f\n", m_ComboInputData.fNextComboTime);
|
||||
fprintf(File, " InputLimitTime %f\n", m_ComboInputData.fInputEndTime);
|
||||
fprintf(File, "}\n");
|
||||
fprintf(File, "\n");
|
||||
}
|
||||
|
||||
if (m_isAttackingMotion)
|
||||
{
|
||||
fprintf(File, "Group AttackingData\n");
|
||||
fprintf(File, "{\n");
|
||||
NRaceData::SaveMotionAttackData(File, 1, m_MotionAttackData);
|
||||
fprintf(File, "}\n");
|
||||
fprintf(File, "\n");
|
||||
}
|
||||
|
||||
if (m_isLoopMotion)
|
||||
{
|
||||
fprintf(File, "Group LoopData\n");
|
||||
fprintf(File, "{\n");
|
||||
fprintf(File, " MotionLoopCount %d\n", m_iLoopCount);
|
||||
fprintf(File, " LoopCancelEnable %d\n", m_bCancelEnableSkill);
|
||||
fprintf(File, " LoopStartTime %f\n", m_fLoopStartTime);
|
||||
fprintf(File, " LoopEndTime %f\n", m_fLoopEndTime);
|
||||
fprintf(File, "}\n");
|
||||
fprintf(File, "\n");
|
||||
}
|
||||
|
||||
if (!m_MotionEventDataVector.empty())
|
||||
{
|
||||
fprintf(File, "Group MotionEventData\n");
|
||||
fprintf(File, "{\n");
|
||||
fprintf(File, " MotionEventDataCount %d\n", m_MotionEventDataVector.size());
|
||||
|
||||
for (DWORD j = 0; j < m_MotionEventDataVector.size(); ++j)
|
||||
{
|
||||
TMotionEventData * c_pData = m_MotionEventDataVector[j];
|
||||
|
||||
fprintf(File, " Group Event%02d\n", j);
|
||||
fprintf(File, " {\n");
|
||||
fprintf(File, " MotionEventType %d\n", c_pData->iType);
|
||||
fprintf(File, " StartingTime %f\n", c_pData->fStartingTime);
|
||||
c_pData->Save(File, 2);
|
||||
fprintf(File, " }\n");
|
||||
}
|
||||
fprintf(File, "}\n");
|
||||
}
|
||||
|
||||
fclose(File);
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
bool CRaceMotionData::LoadSoundScriptData(const char * c_szFileName)
|
||||
{
|
||||
NSound::TSoundDataVector SoundDataVector;
|
||||
if (!NSound::LoadSoundInformationPiece(c_szFileName, SoundDataVector))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
NSound::DataToInstance(SoundDataVector, &m_SoundInstanceVector);
|
||||
return true;
|
||||
}
|
||||
|
||||
const char * CRaceMotionData::GetMotionFileName() const
|
||||
{
|
||||
return m_strMotionFileName.c_str();
|
||||
}
|
||||
|
||||
const char * CRaceMotionData::GetSoundScriptFileName() const
|
||||
{
|
||||
return m_strSoundScriptDataFileName.c_str();
|
||||
}
|
||||
|
||||
void CRaceMotionData::Initialize()
|
||||
{
|
||||
m_iLoopCount = 0;
|
||||
m_fMotionDuration = 0.0f;
|
||||
m_accumulationPosition.x = 0.0f;
|
||||
m_accumulationPosition.y = 0.0f;
|
||||
m_accumulationPosition.z = 0.0f;
|
||||
m_fLoopStartTime = 0.0f;
|
||||
m_fLoopEndTime = 0.0f;
|
||||
|
||||
m_isAccumulationMotion = FALSE;
|
||||
m_isComboMotion = FALSE;
|
||||
m_isLoopMotion = FALSE;
|
||||
m_isAttackingMotion = FALSE;
|
||||
m_bCancelEnableSkill = FALSE;
|
||||
|
||||
m_hasSplashEvent = FALSE;
|
||||
|
||||
m_isLock = FALSE;
|
||||
|
||||
m_eType=TYPE_NONE;
|
||||
m_eName=NAME_NONE;
|
||||
|
||||
m_MotionEventDataVector.clear();
|
||||
m_SoundInstanceVector.clear();
|
||||
}
|
||||
|
||||
void CRaceMotionData::Destroy()
|
||||
{
|
||||
stl_wipe(m_MotionEventDataVector);
|
||||
Initialize();
|
||||
}
|
||||
|
||||
CRaceMotionData::CRaceMotionData()
|
||||
{
|
||||
Initialize();
|
||||
}
|
||||
|
||||
CRaceMotionData::~CRaceMotionData()
|
||||
{
|
||||
Destroy();
|
||||
}
|
||||
@@ -0,0 +1,354 @@
|
||||
#include "StdAfx.h"
|
||||
#include "PythonBackground.h"
|
||||
#include "../EterLib/Camera.h"
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// 메세지
|
||||
|
||||
extern void SetHeightLog(bool isLog);
|
||||
|
||||
float CCamera::CAMERA_MIN_DISTANCE = 200.0f;
|
||||
float CCamera::CAMERA_MAX_DISTANCE = 2500.0f;
|
||||
|
||||
void CCamera::ProcessTerrainCollision()
|
||||
{
|
||||
CPythonBackground & rPythonBackground = CPythonBackground::Instance();
|
||||
D3DXVECTOR3 v3CollisionPoint;
|
||||
|
||||
if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kTargetToCameraBottomRay, &v3CollisionPoint))
|
||||
{
|
||||
SetCameraState(CAMERA_STATE_CANTGODOWN);
|
||||
D3DXVECTOR3 v3CheckVector = m_v3Eye - 2.0f * m_fTerrainCollisionRadius * m_v3Up;
|
||||
v3CheckVector.z = rPythonBackground.GetHeight(floorf(v3CheckVector.x), floorf(v3CheckVector.y));
|
||||
D3DXVECTOR3 v3NewEye = v3CheckVector + 2.0f * m_fTerrainCollisionRadius * m_v3Up;
|
||||
if (v3NewEye.z > m_v3Eye.z)
|
||||
{
|
||||
//printf("ToCameraBottom(%f, %f, %f) TCR %f, UP(%f, %f, %f), new %f > old %f",
|
||||
// v3CheckVector.x, v3CheckVector.y, v3CheckVector.z,
|
||||
// m_fTerrainCollisionRadius,
|
||||
// m_v3Up.x, m_v3Up.y, m_v3Up.z,
|
||||
// v3NewEye.z, m_v3Eye.z);
|
||||
SetEye(v3NewEye);
|
||||
}
|
||||
/*
|
||||
SetCameraState(CAMERA_STATE_NORMAL);
|
||||
D3DXVECTOR3 v3NewEye = v3CollisionPoint;
|
||||
SetEye(v3NewEye);
|
||||
*/
|
||||
}
|
||||
else
|
||||
SetCameraState(CAMERA_STATE_NORMAL);
|
||||
|
||||
if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraBottomToTerrainRay, &v3CollisionPoint))
|
||||
{
|
||||
SetCameraState(CAMERA_STATE_CANTGODOWN);
|
||||
auto d3dd = (m_v3Eye - v3CollisionPoint);
|
||||
if (D3DXVec3Length(&d3dd) < 2.0f * m_fTerrainCollisionRadius)
|
||||
{
|
||||
D3DXVECTOR3 v3NewEye = v3CollisionPoint + 2.0f * m_fTerrainCollisionRadius * m_v3Up;
|
||||
//printf("CameraBottomToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
|
||||
SetEye(v3NewEye);
|
||||
}
|
||||
}
|
||||
else
|
||||
SetCameraState(CAMERA_STATE_NORMAL);
|
||||
/*
|
||||
if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraFrontToTerrainRay, &v3CollisionPoint))
|
||||
{
|
||||
if (D3DXVec3Length(&(m_v3Eye - v3CollisionPoint)) < 4.0f * m_fTerrainCollisionRadius)
|
||||
{
|
||||
D3DXVECTOR3 v3NewEye = v3CollisionPoint - 4.0f * m_fTerrainCollisionRadius * m_v3View;
|
||||
//printf("CameraFrontToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
|
||||
SetEye(v3NewEye);
|
||||
}
|
||||
}
|
||||
|
||||
if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraBackToTerrainRay, &v3CollisionPoint))
|
||||
{
|
||||
if (D3DXVec3Length(&(m_v3Eye - v3CollisionPoint)) < m_fTerrainCollisionRadius)
|
||||
{
|
||||
D3DXVECTOR3 v3NewEye = v3CollisionPoint + m_fTerrainCollisionRadius * m_v3View;
|
||||
//printf("CameraBackToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
|
||||
SetEye(v3NewEye);
|
||||
}
|
||||
}
|
||||
|
||||
// Left
|
||||
if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraLeftToTerrainRay, &v3CollisionPoint))
|
||||
{
|
||||
SetCameraState(CAMERA_STATE_CANTGOLEFT);
|
||||
if (D3DXVec3Length(&(m_v3Eye - v3CollisionPoint)) < 3.0f * m_fTerrainCollisionRadius)
|
||||
{
|
||||
D3DXVECTOR3 v3NewEye = v3CollisionPoint + 3.0f * m_fTerrainCollisionRadius * m_v3Cross;
|
||||
//printf("CameraLeftToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
|
||||
SetEye(v3NewEye);
|
||||
}
|
||||
}
|
||||
else
|
||||
SetCameraState(CAMERA_STATE_NORMAL);
|
||||
|
||||
// Right
|
||||
if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraRightToTerrainRay, &v3CollisionPoint))
|
||||
{
|
||||
SetCameraState(CAMERA_STATE_CANTGORIGHT);
|
||||
if (D3DXVec3Length(&(m_v3Eye - v3CollisionPoint)) < 3.0f * m_fTerrainCollisionRadius)
|
||||
{
|
||||
D3DXVECTOR3 v3NewEye = v3CollisionPoint - 3.0f * m_fTerrainCollisionRadius * m_v3Cross;
|
||||
//printf("CameraRightToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
|
||||
SetEye(v3NewEye);
|
||||
}
|
||||
}
|
||||
else
|
||||
SetCameraState(CAMERA_STATE_NORMAL);
|
||||
*/
|
||||
}
|
||||
|
||||
struct CameraCollisionChecker
|
||||
{
|
||||
bool m_isBlocked;
|
||||
std::vector<D3DXVECTOR3>* m_pkVct_v3Position;
|
||||
CDynamicSphereInstance * m_pdsi;
|
||||
|
||||
CameraCollisionChecker(CDynamicSphereInstance * pdsi, std::vector<D3DXVECTOR3>* pkVct_v3Position) : m_pdsi(pdsi), m_pkVct_v3Position(pkVct_v3Position), m_isBlocked(false)
|
||||
{
|
||||
}
|
||||
void operator () (CGraphicObjectInstance* pOpponent)
|
||||
{
|
||||
if (pOpponent->CollisionDynamicSphere(*m_pdsi))
|
||||
{
|
||||
m_pkVct_v3Position->push_back(pOpponent->GetPosition());
|
||||
m_isBlocked = true;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
void CCamera::ProcessBuildingCollision()
|
||||
{
|
||||
float fMoveAmountSmall = 2.0f;
|
||||
float fMoveAmountLarge = 4.0f;
|
||||
|
||||
D3DXVECTOR3 v3CheckVector;
|
||||
|
||||
CDynamicSphereInstance s;
|
||||
s.fRadius = m_fObjectCollisionRadius;
|
||||
s.v3LastPosition = m_v3Eye;
|
||||
|
||||
Vector3d aVector3d;
|
||||
aVector3d.Set(m_v3Eye.x, m_v3Eye.y, m_v3Eye.z);
|
||||
|
||||
// 뒤
|
||||
|
||||
CCullingManager & rkCullingMgr = CCullingManager::Instance();
|
||||
|
||||
{
|
||||
v3CheckVector = m_v3Eye - m_fObjectCollisionRadius * m_v3View;
|
||||
s.v3Position = v3CheckVector;
|
||||
|
||||
std::vector<D3DXVECTOR3> kVct_kPosition;
|
||||
CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
|
||||
rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
|
||||
bool bCollide = kCameraCollisionChecker.m_isBlocked;
|
||||
|
||||
if (bCollide)
|
||||
{
|
||||
if (m_v3AngularVelocity.y > 0.0f)
|
||||
{
|
||||
m_v3AngularVelocity.y = 0.0f;
|
||||
m_v3AngularVelocity.z += fMoveAmountLarge;
|
||||
}
|
||||
// m_v3AngularVelocity.y = fMAX(fMoveAmountSmall, m_v3AngularVelocity.y);
|
||||
//// m_v3AngularVelocity.y += fMoveAmountSmall;
|
||||
|
||||
if (kVct_kPosition.size() > 1)
|
||||
{
|
||||
// m_v3AngularVelocity.z = fMAX(fMoveAmountSmall, m_v3AngularVelocity.z);
|
||||
m_v3AngularVelocity.z += fMoveAmountSmall;
|
||||
}
|
||||
else
|
||||
{
|
||||
auto d3dd = (kVct_kPosition[0] - m_v3Eye);
|
||||
D3DXVec3Cross(&v3CheckVector, &d3dd, &m_v3View);
|
||||
float fDot = D3DXVec3Dot(&v3CheckVector, &m_v3Up);
|
||||
if (fDot < 0)
|
||||
{
|
||||
// m_v3AngularVelocity.x = fMIN(-fMoveAmountSmall, m_v3AngularVelocity.x);
|
||||
m_v3AngularVelocity.x -= fMoveAmountSmall;
|
||||
}
|
||||
else if(fDot > 0)
|
||||
{
|
||||
// m_v3AngularVelocity.x = fMAX(fMoveAmountSmall, m_v3AngularVelocity.x);
|
||||
m_v3AngularVelocity.x += fMoveAmountSmall;
|
||||
}
|
||||
else
|
||||
{
|
||||
// m_v3AngularVelocity.z = fMAX(fMoveAmountSmall, m_v3AngularVelocity.z);
|
||||
m_v3AngularVelocity.z += fMoveAmountSmall;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 위
|
||||
{
|
||||
v3CheckVector = m_v3Eye + 2.0f * m_fObjectCollisionRadius * m_v3Up;
|
||||
s.v3Position = v3CheckVector;
|
||||
|
||||
std::vector<D3DXVECTOR3> kVct_kPosition;
|
||||
CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
|
||||
rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
|
||||
bool bCollide = kCameraCollisionChecker.m_isBlocked;
|
||||
|
||||
if (bCollide)
|
||||
{
|
||||
m_v3AngularVelocity.z = fMIN(-fMoveAmountSmall, m_v3AngularVelocity.y);
|
||||
// m_v3AngularVelocity.z -= 1.0f;
|
||||
}
|
||||
}
|
||||
|
||||
// 좌
|
||||
{
|
||||
v3CheckVector = m_v3Eye + 3.0f * m_fObjectCollisionRadius * m_v3Cross;
|
||||
s.v3Position = v3CheckVector;
|
||||
|
||||
std::vector<D3DXVECTOR3> kVct_kPosition;
|
||||
CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
|
||||
rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
|
||||
bool bCollide = kCameraCollisionChecker.m_isBlocked;
|
||||
|
||||
if (bCollide)
|
||||
{
|
||||
if (m_v3AngularVelocity.x > 0.0f)
|
||||
{
|
||||
m_v3AngularVelocity.x = 0.0f;
|
||||
m_v3AngularVelocity.y += fMoveAmountLarge;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 우
|
||||
{
|
||||
v3CheckVector = m_v3Eye - 3.0f * m_fObjectCollisionRadius * m_v3Cross;
|
||||
s.v3Position = v3CheckVector;
|
||||
|
||||
std::vector<D3DXVECTOR3> kVct_kPosition;
|
||||
CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
|
||||
rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
|
||||
bool bCollide = kCameraCollisionChecker.m_isBlocked;
|
||||
|
||||
if (bCollide)
|
||||
{
|
||||
if (m_v3AngularVelocity.x < 0.0f)
|
||||
{
|
||||
m_v3AngularVelocity.x = 0.0f;
|
||||
m_v3AngularVelocity.y += fMoveAmountLarge;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 아래
|
||||
{
|
||||
v3CheckVector = m_v3Eye - 2.0f * m_fTerrainCollisionRadius * m_v3Up;
|
||||
s.v3Position = v3CheckVector;
|
||||
|
||||
std::vector<D3DXVECTOR3> kVct_kPosition;
|
||||
CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
|
||||
rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
|
||||
bool bCollide = kCameraCollisionChecker.m_isBlocked;
|
||||
|
||||
if (bCollide)
|
||||
{
|
||||
if (m_v3AngularVelocity.z < 0.0f)
|
||||
{
|
||||
m_v3AngularVelocity.z = 0.0f;
|
||||
m_v3AngularVelocity.y += fMoveAmountLarge;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 앞
|
||||
{
|
||||
v3CheckVector = m_v3Eye + 4.0f * m_fObjectCollisionRadius * m_v3View;
|
||||
s.v3Position = v3CheckVector;
|
||||
|
||||
std::vector<D3DXVECTOR3> kVct_kPosition;
|
||||
CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
|
||||
rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
|
||||
bool bCollide = kCameraCollisionChecker.m_isBlocked;
|
||||
|
||||
if (bCollide)
|
||||
{
|
||||
if (m_v3AngularVelocity.y < 0.0f)
|
||||
{
|
||||
m_v3AngularVelocity.y = 0.0f;
|
||||
m_v3AngularVelocity.z += fMoveAmountLarge;
|
||||
}
|
||||
|
||||
if (kVct_kPosition.size() > 1)
|
||||
{
|
||||
// m_v3AngularVelocity.z = fMAX(fMoveAmountLarge, m_v3AngularVelocity.z);
|
||||
m_v3AngularVelocity.z += fMoveAmountLarge;
|
||||
}
|
||||
else
|
||||
{
|
||||
auto d3dd = (kVct_kPosition[0] - m_v3Eye);
|
||||
D3DXVec3Cross(&v3CheckVector, &d3dd, &m_v3View);
|
||||
float fDot = D3DXVec3Dot(&v3CheckVector, &m_v3Up);
|
||||
if (fDot < 0)
|
||||
{
|
||||
// m_v3AngularVelocity.x = fMIN(-fMoveAmountSmall, m_v3AngularVelocity.x);
|
||||
m_v3AngularVelocity.x -= fMoveAmountSmall;
|
||||
}
|
||||
else if(fDot > 0)
|
||||
{
|
||||
// m_v3AngularVelocity.x = fMAX(fMoveAmountSmall, m_v3AngularVelocity.x);
|
||||
m_v3AngularVelocity.x += fMoveAmountSmall;
|
||||
}
|
||||
else
|
||||
{
|
||||
// m_v3AngularVelocity.z = fMAX(fMoveAmountSmall, m_v3AngularVelocity.z);
|
||||
m_v3AngularVelocity.z += fMoveAmountSmall;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CCamera::Update()
|
||||
{
|
||||
// ProcessBuildingCollision();
|
||||
|
||||
RotateEyeAroundTarget(m_v3AngularVelocity.z, m_v3AngularVelocity.x);
|
||||
|
||||
float fNewDistance=fMAX(CAMERA_MIN_DISTANCE, fMIN( CAMERA_MAX_DISTANCE, GetDistance() - m_v3AngularVelocity.y ) );
|
||||
SetDistance(fNewDistance);
|
||||
|
||||
if (m_bProcessTerrainCollision)
|
||||
ProcessTerrainCollision();
|
||||
|
||||
m_v3AngularVelocity *= 0.5f;
|
||||
if (fabs(m_v3AngularVelocity.x) < 1.0f)
|
||||
m_v3AngularVelocity.x = 0.0f;
|
||||
if (fabs(m_v3AngularVelocity.y) < 1.0f)
|
||||
m_v3AngularVelocity.y = 0.0f;
|
||||
if (fabs(m_v3AngularVelocity.z) < 1.0f)
|
||||
m_v3AngularVelocity.z = 0.0f;
|
||||
|
||||
const float CAMERA_MOVABLE_DISTANCE = CAMERA_MAX_DISTANCE - CAMERA_MIN_DISTANCE;
|
||||
const float CAMERA_TARGET_DELTA = CAMERA_TARGET_FACE - CAMERA_TARGET_STANDARD;
|
||||
float fCameraCurMovableDistance=CAMERA_MAX_DISTANCE - GetDistance();
|
||||
float fNewTargetHeight = CAMERA_TARGET_STANDARD + CAMERA_TARGET_DELTA * fCameraCurMovableDistance / CAMERA_MOVABLE_DISTANCE;
|
||||
|
||||
SetTargetHeight(fNewTargetHeight);
|
||||
|
||||
// Cinematic
|
||||
#ifdef __20040725_CAMERA_WORK__
|
||||
m_MovementPosition += m_MovementSpeed;
|
||||
|
||||
if (0.0f != m_MovementPosition.m_fViewDir)
|
||||
MoveFront(m_MovementPosition.m_fViewDir);
|
||||
if (0.0f != m_MovementPosition.m_fCrossDir)
|
||||
MoveAlongCross(m_MovementPosition.m_fCrossDir);
|
||||
if (0.0f != m_MovementPosition.m_fUpDir)
|
||||
MoveVertical(m_MovementPosition.m_fUpDir);
|
||||
#endif
|
||||
}
|
||||
@@ -0,0 +1,844 @@
|
||||
#include "StdAfx.h"
|
||||
#include "PythonCharacterManager.h"
|
||||
#include "PythonBackground.h"
|
||||
#include "InstanceBase.h"
|
||||
#include "../GameLib/RaceManager.h"
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// RaceData 관련 시작
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
PyObject * chrmgrSetEmpireNameMode(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iEnable;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iEnable))
|
||||
return Py_BadArgument();
|
||||
|
||||
CInstanceBase::SetEmpireNameMode(iEnable ? true : false);
|
||||
CPythonCharacterManager::Instance().RefreshAllPCTextTail();
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrRegisterTitleName(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
|
||||
return Py_BadArgument();
|
||||
char * szTitleName;
|
||||
if (!PyTuple_GetString(poArgs, 1, &szTitleName))
|
||||
return Py_BadArgument();
|
||||
|
||||
CInstanceBase::RegisterTitleName(iIndex, szTitleName);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrRegisterNameColor(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int index;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &index))
|
||||
return Py_BadArgument();
|
||||
|
||||
int ir;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &ir))
|
||||
return Py_BadArgument();
|
||||
int ig;
|
||||
if (!PyTuple_GetInteger(poArgs, 2, &ig))
|
||||
return Py_BadArgument();
|
||||
int ib;
|
||||
if (!PyTuple_GetInteger(poArgs, 3, &ib))
|
||||
return Py_BadArgument();
|
||||
|
||||
CInstanceBase::RegisterNameColor(index, ir, ig, ib);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrRegisterTitleColor(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
|
||||
return Py_BadArgument();
|
||||
int ir;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &ir))
|
||||
return Py_BadArgument();
|
||||
int ig;
|
||||
if (!PyTuple_GetInteger(poArgs, 2, &ig))
|
||||
return Py_BadArgument();
|
||||
int ib;
|
||||
if (!PyTuple_GetInteger(poArgs, 3, &ib))
|
||||
return Py_BadArgument();
|
||||
|
||||
CInstanceBase::RegisterTitleColor(iIndex, ir, ig, ib);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrGetPickedVID(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
|
||||
|
||||
DWORD dwPickedActorID;
|
||||
if (rkChrMgr.OLD_GetPickedInstanceVID(&dwPickedActorID))
|
||||
return Py_BuildValue("i", dwPickedActorID);
|
||||
else
|
||||
return Py_BuildValue("i", -1);
|
||||
}
|
||||
|
||||
PyObject * chrmgrGetVIDInfo(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int nVID;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &nVID))
|
||||
return Py_BadArgument();
|
||||
|
||||
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
|
||||
|
||||
char szDetail[256]="";
|
||||
CInstanceBase* pkInstBase=rkChrMgr.GetInstancePtr(nVID);
|
||||
if (pkInstBase)
|
||||
{
|
||||
TPixelPosition kPPosInst;
|
||||
pkInstBase->NEW_GetPixelPosition(&kPPosInst);
|
||||
|
||||
LONG xInst=kPPosInst.x;
|
||||
LONG yInst=kPPosInst.y;
|
||||
|
||||
CPythonBackground& rkBG=CPythonBackground::Instance();
|
||||
rkBG.LocalPositionToGlobalPosition(xInst, yInst);
|
||||
sprintf(szDetail, "pos=(%d, %d)", xInst, yInst);
|
||||
}
|
||||
|
||||
|
||||
char szInfo[1024];
|
||||
sprintf(szInfo, "VID %d (isRegistered=%d, isAlive=%d, isDead=%d) %s",
|
||||
nVID,
|
||||
rkChrMgr.IsRegisteredVID(nVID),
|
||||
rkChrMgr.IsAliveVID(nVID),
|
||||
rkChrMgr.IsDeadVID(nVID),
|
||||
szDetail
|
||||
);
|
||||
|
||||
return Py_BuildValue("s", szInfo);
|
||||
}
|
||||
|
||||
|
||||
PyObject * chrmgrSetPathName(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
char * szPathName;
|
||||
if (!PyTuple_GetString(poArgs, 0, &szPathName))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceManager::Instance().SetPathName(szPathName);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrCreateRace(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iRace;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iRace))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceManager::Instance().CreateRace(iRace);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrSelectRace(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iRace;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iRace))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceManager::Instance().SelectRace(iRace);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrRegisterAttachingBoneName(PyObject * poSelf, PyObject * poArgs)
|
||||
{
|
||||
int iPartIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iPartIndex))
|
||||
return Py_BadArgument();
|
||||
char * szBoneName;
|
||||
if (!PyTuple_GetString(poArgs, 1, &szBoneName))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
pRaceData->RegisterAttachingBoneName(iPartIndex, szBoneName);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrRegisterMotionMode(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iMotionIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iMotionIndex))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
pRaceData->RegisterMotionMode(iMotionIndex);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
|
||||
|
||||
PyObject * chrmgrSetMotionRandomWeight(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iMode;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iMotion;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iSubMotion;
|
||||
if (!PyTuple_GetInteger(poArgs, 2, &iSubMotion))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iPercentage;
|
||||
if (!PyTuple_GetInteger(poArgs, 3, &iPercentage))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
if (!pRaceData->SetMotionRandomWeight(iMode, iMotion, iSubMotion, iPercentage))
|
||||
Py_BuildException("Failed to SetMotionRandomWeight");
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrRegisterNormalAttack(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iMode;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iMotion;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
pRaceData->RegisterNormalAttack(iMode, iMotion);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// 없어질 함수들
|
||||
PyObject * chrmgrReserveComboAttack(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iMode;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iCount;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iCount))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
pRaceData->ReserveComboAttack(iMode, 0, iCount);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrRegisterComboAttack(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iMode;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iComboIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iComboIndex))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iMotionIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 2, &iMotionIndex))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
pRaceData->RegisterComboAttack(iMode, 0, iComboIndex, iMotionIndex);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
// 없어질 함수들
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
PyObject * chrmgrReserveComboAttackNew(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iMotionMode;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iMotionMode))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iComboType;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iComboType))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iCount;
|
||||
if (!PyTuple_GetInteger(poArgs, 2, &iCount))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
pRaceData->ReserveComboAttack(iMotionMode, iComboType, iCount);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrRegisterComboAttackNew(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iMotionMode;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iMotionMode))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iComboType;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iComboType))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iComboIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 2, &iComboIndex))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iMotionIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 3, &iMotionIndex))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
pRaceData->RegisterComboAttack(iMotionMode, iComboType, iComboIndex, iMotionIndex);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrLoadRaceData(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
char* szFileName;
|
||||
if (!PyTuple_GetString(poArgs, 0, &szFileName))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
const char * c_szFullFileName = CRaceManager::Instance().GetFullPathFileName(szFileName);
|
||||
if (!pRaceData->LoadRaceData(c_szFullFileName))
|
||||
{
|
||||
TraceError("Failed to load race data : %s\n", c_szFullFileName);
|
||||
}
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrLoadLocalRaceData(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
char* szFileName;
|
||||
if (!PyTuple_GetString(poArgs, 0, &szFileName))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
if (!pRaceData->LoadRaceData(szFileName))
|
||||
{
|
||||
TraceError("Failed to load race data : %s\n", szFileName);
|
||||
}
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
/*
|
||||
PyObject * chrmgrRegisterMotion(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iMode;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iMotion;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
|
||||
return Py_BadArgument();
|
||||
|
||||
char* szFileName;
|
||||
if (!PyTuple_GetString(poArgs, 2, &szFileName))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iWeight = 0;
|
||||
PyTuple_GetInteger(poArgs, 3, &iWeight);
|
||||
iWeight = MIN(100, iWeight);
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
pRaceData->NEW_RegisterMotion(iMode, iMotion, CRaceManager::Instance().GetFullPathFileName(szFileName), iWeight);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
*/
|
||||
|
||||
PyObject * chrmgrRegisterCacheMotionData(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iMode;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iMotion;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
|
||||
return Py_BadArgument();
|
||||
|
||||
char * szFileName;
|
||||
if (!PyTuple_GetString(poArgs, 2, &szFileName))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iWeight = 0;
|
||||
PyTuple_GetInteger(poArgs, 3, &iWeight);
|
||||
iWeight = MIN(100, iWeight);
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
const char * c_szFullFileName = CRaceManager::Instance().GetFullPathFileName(szFileName);
|
||||
CGraphicThing* pkMotionThing=pRaceData->RegisterMotionData(iMode, iMotion, c_szFullFileName, iWeight);
|
||||
|
||||
if (pkMotionThing)
|
||||
CResourceManager::Instance().LoadStaticCache(pkMotionThing->GetFileName());
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrRegisterMotionData(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iMode;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iMotion;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
|
||||
return Py_BadArgument();
|
||||
|
||||
char * szFileName;
|
||||
if (!PyTuple_GetString(poArgs, 2, &szFileName))
|
||||
return Py_BadArgument();
|
||||
|
||||
int iWeight = 0;
|
||||
PyTuple_GetInteger(poArgs, 3, &iWeight);
|
||||
iWeight = MIN(100, iWeight);
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
const char * c_szFullFileName = CRaceManager::Instance().GetFullPathFileName(szFileName);
|
||||
pRaceData->RegisterMotionData(iMode, iMotion, c_szFullFileName, iWeight);
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrRegisterRaceSrcName(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
char * szName;
|
||||
if (!PyTuple_GetString(poArgs, 0, &szName))
|
||||
return Py_BadArgument();
|
||||
|
||||
char * szSrcName;
|
||||
if (!PyTuple_GetString(poArgs, 1, &szSrcName))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceManager::Instance().RegisterRaceSrcName(szName, szSrcName);
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrRegisterRaceName(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iRaceIndex;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iRaceIndex))
|
||||
return Py_BadArgument();
|
||||
|
||||
char * szName;
|
||||
if (!PyTuple_GetString(poArgs, 1, &szName))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceManager::Instance().RegisterRaceName(iRaceIndex, szName);
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrSetShapeModel(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int eShape;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &eShape))
|
||||
return Py_BadArgument();
|
||||
|
||||
char * szFileName;
|
||||
if (!PyTuple_GetString(poArgs, 1, &szFileName))
|
||||
return Py_BadArgument();
|
||||
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
pRaceData->SetShapeModel(eShape, szFileName);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrAppendShapeSkin(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int eShape;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &eShape))
|
||||
return Py_BadArgument();
|
||||
|
||||
int ePart;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &ePart))
|
||||
return Py_BadArgument();
|
||||
|
||||
char * szSrcFileName;
|
||||
if (!PyTuple_GetString(poArgs, 2, &szSrcFileName))
|
||||
return Py_BadArgument();
|
||||
|
||||
char * szDstFileName;
|
||||
if (!PyTuple_GetString(poArgs, 3, &szDstFileName))
|
||||
return Py_BadArgument();
|
||||
|
||||
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
|
||||
if (!pRaceData)
|
||||
return Py_BuildException("RaceData has not selected!");
|
||||
|
||||
pRaceData->AppendShapeSkin(eShape, ePart, szSrcFileName, szDstFileName);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// RaceData 관련 끝
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
PyObject * chrmgrSetMovingSpeed(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
#ifndef _DISTRIBUTE
|
||||
int nMovSpd;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &nMovSpd))
|
||||
return Py_BadArgument();
|
||||
|
||||
if (nMovSpd<0)
|
||||
return Py_BuildException("MovingSpeed < 0");
|
||||
|
||||
CInstanceBase * pkInst = CPythonCharacterManager::Instance().GetSelectedInstancePtr();
|
||||
|
||||
if (!pkInst)
|
||||
return Py_BuildException("MainCharacter has not selected!");
|
||||
|
||||
pkInst->SetMoveSpeed(nMovSpd);
|
||||
#endif
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrRegisterEffect(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int eEftType;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &eEftType))
|
||||
return Py_BadArgument();
|
||||
|
||||
char * szBoneName;
|
||||
if (!PyTuple_GetString(poArgs, 1, &szBoneName))
|
||||
return Py_BadArgument();
|
||||
|
||||
char * szPathName;
|
||||
if (!PyTuple_GetString(poArgs, 2, &szPathName))
|
||||
return Py_BadArgument();
|
||||
|
||||
CInstanceBase::RegisterEffect(eEftType, szBoneName, szPathName, false);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrRegisterCacheEffect(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int eEftType;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &eEftType))
|
||||
return Py_BadArgument();
|
||||
|
||||
char * szBoneName;
|
||||
if (!PyTuple_GetString(poArgs, 1, &szBoneName))
|
||||
return Py_BadArgument();
|
||||
|
||||
char * szPathName;
|
||||
if (!PyTuple_GetString(poArgs, 2, &szPathName))
|
||||
return Py_BadArgument();
|
||||
|
||||
CInstanceBase::RegisterEffect(eEftType, szBoneName, szPathName, true);
|
||||
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrSetDustGap(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int nGap;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &nGap))
|
||||
return Py_BadArgument();
|
||||
|
||||
CInstanceBase::SetDustGap(nGap);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrSetHorseDustGap(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int nGap;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &nGap))
|
||||
return Py_BadArgument();
|
||||
|
||||
CInstanceBase::SetHorseDustGap(nGap);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrToggleDirectionLine(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
static bool s_isVisible=true;
|
||||
CActorInstance::ShowDirectionLine(s_isVisible);
|
||||
|
||||
s_isVisible=!s_isVisible;
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrRegisterPointEffect(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int iEft;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &iEft))
|
||||
return Py_BadArgument();
|
||||
|
||||
char * szFileName;
|
||||
if (!PyTuple_GetString(poArgs, 1, &szFileName))
|
||||
return Py_BadArgument();
|
||||
|
||||
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
|
||||
rkChrMgr.RegisterPointEffect(iEft, szFileName);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrShowPointEffect(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int nVID;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &nVID))
|
||||
return Py_BadArgument();
|
||||
|
||||
int nEft;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &nEft))
|
||||
return Py_BadArgument();
|
||||
|
||||
CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
|
||||
rkChrMgr.ShowPointEffect(nEft, nVID >= 0 ? nVID : 0xffffffff);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
|
||||
void CPythonCharacterManager::SCRIPT_SetAffect(DWORD dwVID, DWORD eState, BOOL isVisible)
|
||||
{
|
||||
CInstanceBase * pkInstSel = (dwVID == 0xffffffff) ? GetSelectedInstancePtr() : GetInstancePtr(dwVID);
|
||||
if (!pkInstSel)
|
||||
return;
|
||||
|
||||
pkInstSel->SCRIPT_SetAffect(eState, isVisible ? true : false);
|
||||
}
|
||||
|
||||
PyObject * chrmgrSetAffect(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int nVID;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &nVID))
|
||||
return Py_BadArgument();
|
||||
|
||||
int nEft;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &nEft))
|
||||
return Py_BadArgument();
|
||||
|
||||
int nVisible;
|
||||
if (!PyTuple_GetInteger(poArgs, 2, &nVisible))
|
||||
return Py_BadArgument();
|
||||
|
||||
CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
|
||||
rkChrMgr.SCRIPT_SetAffect(nVID >= 0 ? nVID : 0xffffffff, nEft, nVisible);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
void CPythonCharacterManager::SetEmoticon(DWORD dwVID, DWORD eState)
|
||||
{
|
||||
CInstanceBase * pkInstSel = (dwVID == 0xffffffff) ? GetSelectedInstancePtr() : GetInstancePtr(dwVID);
|
||||
if (!pkInstSel)
|
||||
return;
|
||||
|
||||
pkInstSel->SetEmoticon(eState);
|
||||
}
|
||||
|
||||
bool CPythonCharacterManager::IsPossibleEmoticon(DWORD dwVID)
|
||||
{
|
||||
CInstanceBase * pkInstSel = (dwVID == 0xffffffff) ? GetSelectedInstancePtr() : GetInstancePtr(dwVID);
|
||||
if (!pkInstSel)
|
||||
return false;
|
||||
|
||||
return pkInstSel->IsPossibleEmoticon();
|
||||
}
|
||||
|
||||
PyObject * chrmgrSetEmoticon(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int nVID;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &nVID))
|
||||
return Py_BadArgument();
|
||||
|
||||
int nEft;
|
||||
if (!PyTuple_GetInteger(poArgs, 1, &nEft))
|
||||
return Py_BadArgument();
|
||||
|
||||
CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
|
||||
rkChrMgr.SetEmoticon(nVID >= 0 ? nVID : 0xffffffff, nEft);
|
||||
return Py_BuildNone();
|
||||
}
|
||||
|
||||
PyObject * chrmgrIsPossibleEmoticon(PyObject* poSelf, PyObject* poArgs)
|
||||
{
|
||||
int nVID;
|
||||
if (!PyTuple_GetInteger(poArgs, 0, &nVID))
|
||||
return Py_BadArgument();
|
||||
|
||||
CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
|
||||
int result = rkChrMgr.IsPossibleEmoticon(nVID >= 0 ? nVID : 0xffffffff);
|
||||
|
||||
return Py_BuildValue("i", result);
|
||||
}
|
||||
|
||||
void initchrmgr()
|
||||
{
|
||||
static PyMethodDef s_methods[] =
|
||||
{
|
||||
// RaceData 관련
|
||||
{ "SetEmpireNameMode", chrmgrSetEmpireNameMode, METH_VARARGS },
|
||||
{ "GetVIDInfo", chrmgrGetVIDInfo, METH_VARARGS },
|
||||
{ "GetPickedVID", chrmgrGetPickedVID, METH_VARARGS },
|
||||
{ "SetShapeModel", chrmgrSetShapeModel, METH_VARARGS },
|
||||
{ "AppendShapeSkin", chrmgrAppendShapeSkin, METH_VARARGS },
|
||||
{ "SetPathName", chrmgrSetPathName, METH_VARARGS },
|
||||
{ "LoadRaceData", chrmgrLoadRaceData, METH_VARARGS },
|
||||
{ "LoadLocalRaceData", chrmgrLoadLocalRaceData, METH_VARARGS },
|
||||
{ "CreateRace", chrmgrCreateRace, METH_VARARGS },
|
||||
{ "SelectRace", chrmgrSelectRace, METH_VARARGS },
|
||||
{ "RegisterAttachingBoneName", chrmgrRegisterAttachingBoneName, METH_VARARGS },
|
||||
{ "RegisterMotionMode", chrmgrRegisterMotionMode, METH_VARARGS },
|
||||
//{ "RegisterMotion", chrmgrRegisterMotion, METH_VARARGS },
|
||||
{ "SetMotionRandomWeight", chrmgrSetMotionRandomWeight, METH_VARARGS },
|
||||
{ "RegisterNormalAttack", chrmgrRegisterNormalAttack, METH_VARARGS },
|
||||
{ "ReserveComboAttack", chrmgrReserveComboAttack, METH_VARARGS },
|
||||
{ "RegisterComboAttack", chrmgrRegisterComboAttack, METH_VARARGS },
|
||||
{ "ReserveComboAttackNew", chrmgrReserveComboAttackNew, METH_VARARGS },
|
||||
{ "RegisterComboAttackNew", chrmgrRegisterComboAttackNew, METH_VARARGS },
|
||||
{ "RegisterMotionData", chrmgrRegisterMotionData, METH_VARARGS },
|
||||
{ "RegisterRaceName", chrmgrRegisterRaceName, METH_VARARGS },
|
||||
{ "RegisterRaceSrcName", chrmgrRegisterRaceSrcName, METH_VARARGS },
|
||||
{ "RegisterCacheMotionData", chrmgrRegisterCacheMotionData, METH_VARARGS },
|
||||
|
||||
// ETC
|
||||
{ "SetAffect", chrmgrSetAffect, METH_VARARGS },
|
||||
{ "SetEmoticon", chrmgrSetEmoticon, METH_VARARGS },
|
||||
{ "IsPossibleEmoticon", chrmgrIsPossibleEmoticon, METH_VARARGS },
|
||||
{ "RegisterEffect", chrmgrRegisterEffect, METH_VARARGS },
|
||||
{ "RegisterCacheEffect", chrmgrRegisterCacheEffect, METH_VARARGS },
|
||||
{ "RegisterPointEffect", chrmgrRegisterPointEffect, METH_VARARGS },
|
||||
{ "ShowPointEffect", chrmgrShowPointEffect, METH_VARARGS },
|
||||
{ "ToggleDirectionLine", chrmgrToggleDirectionLine, METH_VARARGS },
|
||||
{ "SetMovingSpeed", chrmgrSetMovingSpeed, METH_VARARGS },
|
||||
{ "SetDustGap", chrmgrSetDustGap, METH_VARARGS },
|
||||
{ "SetHorseDustGap", chrmgrSetHorseDustGap, METH_VARARGS },
|
||||
|
||||
{ "RegisterTitleName", chrmgrRegisterTitleName, METH_VARARGS },
|
||||
{ "RegisterNameColor", chrmgrRegisterNameColor, METH_VARARGS },
|
||||
{ "RegisterTitleColor", chrmgrRegisterTitleColor, METH_VARARGS },
|
||||
|
||||
{ NULL, NULL, NULL },
|
||||
};
|
||||
|
||||
PyObject * poModule = Py_InitModule("chrmgr", s_methods);
|
||||
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_MOB", CInstanceBase::NAMECOLOR_NORMAL_MOB);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_NPC", CInstanceBase::NAMECOLOR_NORMAL_NPC);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_PC", CInstanceBase::NAMECOLOR_NORMAL_PC);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_EMPIRE_MOB", CInstanceBase::NAMECOLOR_EMPIRE_MOB);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_EMPIRE_NPC", CInstanceBase::NAMECOLOR_EMPIRE_NPC);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_EMPIRE_PC", CInstanceBase::NAMECOLOR_EMPIRE_PC);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_FUNC", CInstanceBase::NAMECOLOR_FUNC);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_PK", CInstanceBase::NAMECOLOR_PK);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_PVP", CInstanceBase::NAMECOLOR_PVP);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_PARTY", CInstanceBase::NAMECOLOR_PARTY);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_WARP", CInstanceBase::NAMECOLOR_WARP);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_WAYPOINT", CInstanceBase::NAMECOLOR_WAYPOINT);
|
||||
PyModule_AddIntConstant(poModule, "NAMECOLOR_EXTRA", CInstanceBase::NAMECOLOR_EXTRA);
|
||||
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SPAWN_DISAPPEAR", CInstanceBase::EFFECT_SPAWN_DISAPPEAR);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SPAWN_APPEAR", CInstanceBase::EFFECT_SPAWN_APPEAR);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DUST", CInstanceBase::EFFECT_DUST);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_HORSE_DUST", CInstanceBase::EFFECT_HORSE_DUST);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_STUN", CInstanceBase::EFFECT_STUN);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_HIT", CInstanceBase::EFFECT_HIT);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_FLAME_ATTACK", CInstanceBase::EFFECT_FLAME_ATTACK);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_FLAME_HIT", CInstanceBase::EFFECT_FLAME_HIT);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_FLAME_ATTACH", CInstanceBase::EFFECT_FLAME_ATTACH);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_ELECTRIC_ATTACK", CInstanceBase::EFFECT_ELECTRIC_ATTACK);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_ELECTRIC_HIT", CInstanceBase::EFFECT_ELECTRIC_HIT);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_ELECTRIC_ATTACH", CInstanceBase::EFFECT_ELECTRIC_ATTACH);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SELECT", CInstanceBase::EFFECT_SELECT);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_TARGET", CInstanceBase::EFFECT_TARGET);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_CRITICAL", CInstanceBase::EFFECT_CRITICAL);
|
||||
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_TARGET", CInstanceBase::EFFECT_DAMAGE_TARGET);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_NOT_TARGET", CInstanceBase::EFFECT_DAMAGE_NOT_TARGET);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_SELFDAMAGE", CInstanceBase::EFFECT_DAMAGE_SELFDAMAGE);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_SELFDAMAGE2", CInstanceBase::EFFECT_DAMAGE_SELFDAMAGE2);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_POISON", CInstanceBase::EFFECT_DAMAGE_POISON);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_MISS", CInstanceBase::EFFECT_DAMAGE_MISS);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_TARGETMISS", CInstanceBase::EFFECT_DAMAGE_TARGETMISS);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_CRITICAL", CInstanceBase::EFFECT_DAMAGE_CRITICAL);
|
||||
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_LEVELUP", CInstanceBase::EFFECT_LEVELUP);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SKILLUP", CInstanceBase::EFFECT_SKILLUP);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_HPUP_RED", CInstanceBase::EFFECT_HPUP_RED);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SPUP_BLUE", CInstanceBase::EFFECT_SPUP_BLUE);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SPEEDUP_GREEN", CInstanceBase::EFFECT_SPEEDUP_GREEN);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DXUP_PURPLE", CInstanceBase::EFFECT_DXUP_PURPLE);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_PENETRATE", CInstanceBase::EFFECT_PENETRATE);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_BLOCK", CInstanceBase::EFFECT_BLOCK);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_DODGE", CInstanceBase::EFFECT_DODGE);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_FIRECRACKER", CInstanceBase::EFFECT_FIRECRACKER);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SPIN_TOP", CInstanceBase::EFFECT_SPIN_TOP);
|
||||
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_WEAPON", CInstanceBase::EFFECT_WEAPON);
|
||||
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_AFFECT", CInstanceBase::EFFECT_AFFECT);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_EMOTICON", CInstanceBase::EFFECT_EMOTICON);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_EMPIRE", CInstanceBase::EFFECT_EMPIRE);
|
||||
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_REFINED", CInstanceBase::EFFECT_REFINED);
|
||||
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_SUCCESS", CInstanceBase::EFFECT_SUCCESS) ;
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_FAIL", CInstanceBase::EFFECT_FAIL) ;
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_FR_SUCCESS", CInstanceBase::EFFECT_FR_SUCCESS) ;
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_LEVELUP_ON_14_FOR_GERMANY", CInstanceBase::EFFECT_LEVELUP_ON_14_FOR_GERMANY ); //레벨업 14일때 ( 독일전용 )
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_LEVELUP_UNDER_15_FOR_GERMANY", CInstanceBase::EFFECT_LEVELUP_UNDER_15_FOR_GERMANY );//레벨업 15일때 ( 독일전용 )
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_PERCENT_DAMAGE1", CInstanceBase::EFFECT_PERCENT_DAMAGE1);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_PERCENT_DAMAGE2", CInstanceBase::EFFECT_PERCENT_DAMAGE2);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_PERCENT_DAMAGE3", CInstanceBase::EFFECT_PERCENT_DAMAGE3);
|
||||
|
||||
// 자동물약 HP, SP
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_AUTO_HPUP", CInstanceBase::EFFECT_AUTO_HPUP);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_AUTO_SPUP", CInstanceBase::EFFECT_AUTO_SPUP);
|
||||
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_RAMADAN_RING_EQUIP", CInstanceBase::EFFECT_RAMADAN_RING_EQUIP);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_HALLOWEEN_CANDY_EQUIP", CInstanceBase::EFFECT_HALLOWEEN_CANDY_EQUIP);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_HAPPINESS_RING_EQUIP", CInstanceBase::EFFECT_HAPPINESS_RING_EQUIP);
|
||||
PyModule_AddIntConstant(poModule, "EFFECT_LOVE_PENDANT_EQUIP", CInstanceBase::EFFECT_LOVE_PENDANT_EQUIP);
|
||||
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -44,5 +44,7 @@ enum
|
||||
// Listed here as 40250 lists them; only the ported ones are defined.
|
||||
void initpack();
|
||||
void initapp();
|
||||
void initchr();
|
||||
void initchrmgr();
|
||||
void initChat();
|
||||
void initnet();
|
||||
|
||||
@@ -154,6 +154,34 @@ D3DXMATRIX* D3DXMatrixInverse(D3DXMATRIX* pOut, FLOAT* pDeterminant, const D3DXM
|
||||
return pOut;
|
||||
}
|
||||
|
||||
FLOAT D3DXMatrixfDeterminant(const D3DXMATRIX* pM)
|
||||
{
|
||||
FLOAT det = 0.0f;
|
||||
D3DXMATRIX unused;
|
||||
D3DXMatrixInverse(&unused, &det, pM);
|
||||
return det;
|
||||
}
|
||||
|
||||
D3DXMATRIX* D3DXMatrixLookAtRH(D3DXMATRIX* pOut, const D3DXVECTOR3* pEye, const D3DXVECTOR3* pAt, const D3DXVECTOR3* pUp)
|
||||
{
|
||||
D3DXVECTOR3 z = *pEye - *pAt;
|
||||
D3DXVec3Normalize(&z, &z);
|
||||
D3DXVECTOR3 x;
|
||||
D3DXVec3Cross(&x, pUp, &z);
|
||||
D3DXVec3Normalize(&x, &x);
|
||||
D3DXVECTOR3 y;
|
||||
D3DXVec3Cross(&y, &z, &x);
|
||||
|
||||
pOut->_11 = x.x; pOut->_12 = y.x; pOut->_13 = z.x; pOut->_14 = 0.0f;
|
||||
pOut->_21 = x.y; pOut->_22 = y.y; pOut->_23 = z.y; pOut->_24 = 0.0f;
|
||||
pOut->_31 = x.z; pOut->_32 = y.z; pOut->_33 = z.z; pOut->_34 = 0.0f;
|
||||
pOut->_41 = -D3DXVec3Dot(&x, pEye);
|
||||
pOut->_42 = -D3DXVec3Dot(&y, pEye);
|
||||
pOut->_43 = -D3DXVec3Dot(&z, pEye);
|
||||
pOut->_44 = 1.0f;
|
||||
return pOut;
|
||||
}
|
||||
|
||||
D3DXMATRIX* D3DXMatrixScaling(D3DXMATRIX* pOut, FLOAT sx, FLOAT sy, FLOAT sz)
|
||||
{
|
||||
D3DXMatrixIdentity(pOut);
|
||||
|
||||
@@ -251,6 +251,8 @@ static_assert(sizeof(D3DXPLANE) == 16 && sizeof(D3DCOLORVALUE) == 16, "D3DX layo
|
||||
inline FLOAT D3DXVec2Length(const D3DXVECTOR2* pV) { return sqrtf(pV->x * pV->x + pV->y * pV->y); }
|
||||
inline FLOAT D3DXVec2LengthSq(const D3DXVECTOR2* pV) { return pV->x * pV->x + pV->y * pV->y; }
|
||||
inline FLOAT D3DXVec2Dot(const D3DXVECTOR2* pV1, const D3DXVECTOR2* pV2) { return pV1->x * pV2->x + pV1->y * pV2->y; }
|
||||
// d3dx8math.inl: the z of the 3D cross product.
|
||||
inline FLOAT D3DXVec2CCW(const D3DXVECTOR2* pV1, const D3DXVECTOR2* pV2) { return pV1->x * pV2->y - pV1->y * pV2->x; }
|
||||
inline D3DXVECTOR2* D3DXVec2Add(D3DXVECTOR2* pOut, const D3DXVECTOR2* pV1, const D3DXVECTOR2* pV2)
|
||||
{
|
||||
pOut->x = pV1->x + pV2->x;
|
||||
@@ -354,6 +356,9 @@ inline BOOL D3DXMatrixIsIdentity(const D3DXMATRIX* pM)
|
||||
D3DXMATRIX* D3DXMatrixMultiply(D3DXMATRIX* pOut, const D3DXMATRIX* pM1, const D3DXMATRIX* pM2);
|
||||
D3DXMATRIX* D3DXMatrixTranspose(D3DXMATRIX* pOut, const D3DXMATRIX* pM);
|
||||
D3DXMATRIX* D3DXMatrixInverse(D3DXMATRIX* pOut, FLOAT* pDeterminant, const D3DXMATRIX* pM);
|
||||
FLOAT D3DXMatrixfDeterminant(const D3DXMATRIX* pM);
|
||||
// Right-handed view matrix: z = normalize(eye - at), x = normalize(up x z), y = z x x.
|
||||
D3DXMATRIX* D3DXMatrixLookAtRH(D3DXMATRIX* pOut, const D3DXVECTOR3* pEye, const D3DXVECTOR3* pAt, const D3DXVECTOR3* pUp);
|
||||
D3DXMATRIX* D3DXMatrixScaling(D3DXMATRIX* pOut, FLOAT sx, FLOAT sy, FLOAT sz);
|
||||
D3DXMATRIX* D3DXMatrixTranslation(D3DXMATRIX* pOut, FLOAT x, FLOAT y, FLOAT z);
|
||||
D3DXMATRIX* D3DXMatrixRotationX(D3DXMATRIX* pOut, FLOAT angle);
|
||||
|
||||
Reference in New Issue
Block a user