2V3-a: walk with the keyboard through the ported player chain

PythonPlayer, PythonPlayerInput{,Keyboard,Mouse}, PythonPlayerEventHandler,
PythonPlayerSkill, PythonPlayerModule and GameType are verbatim copies; the
`player` stub module and the pending PythonPlayer/GameType stand-ins are gone.
Unported callees (CPythonSkill, CItemData, CItemManager, CPythonItem, ...) are
pending stubs. 64-bit fixes: emotion icon handles use Py_BuildPointer, and
PyDict_Next takes Py_ssize_t.

The actor did not move because GrannyUpdateModelMatrix passed the model matrix
through. Walk/run motions use constant root-motion extraction
(AccumulationFlags=AccumulationExtracted, LoopTranslation e.g. (0,-300,0) for
the warrior run, same as the .msa Accumulation). libgr2 now reads both fields
from TrackGroups[0], and the runtime moves by LoopTranslation over each
control's local-clock span, blended by control weight. VDA extraction is not
implemented.

port.login_flow presses DIK_UP; the actor walks more than 100 cm, and the fake
server parses CG packets and sees CG_MOVE FUNC_MOVE, then FUNC_WAIT at the new
position. port.login_live against the real server walked 132 cm.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

extension/src/platform/EterGrnLib/GrannyRuntime.cpp

@@ -1002,12 +1002,46 @@ void GrannyFreeCompletedModelControls(granny_model_instance const* ModelInstance
 			release_control(c);
 }
 
-// PORT: Metin2 motions carry no root-motion accumulation, so the model matrix passes through.
-void GrannyUpdateModelMatrix(granny_model_instance const*, granny_real32, granny_real32 const* ModelMatrix4x4,
-                             granny_real32* DestMatrix4x4, bool)
+// PORT: GrannyUpdateModelMatrix reimplemented for constant-extraction root motion only (walk/run carry
+// AccumulationFlags=AccumulationExtracted + LoopTranslation, e.g. warrior run (0,-300,0) = .msa Accumulation).
+// Each live control contributes LoopTranslation over the local-clock span of the last SecondsElapsed,
+// blended by control weight; Dest = Delta x ModelMatrix (row vectors). VDA extraction is not implemented.
+void GrannyUpdateModelMatrix(granny_model_instance const* ModelInstance, granny_real32 SecondsElapsed,
+                             granny_real32 const* ModelMatrix4x4, granny_real32* DestMatrix4x4, bool Inverse)
 {
-	if (ModelMatrix4x4 && DestMatrix4x4 && ModelMatrix4x4 != DestMatrix4x4)
-		std::memmove(DestMatrix4x4, ModelMatrix4x4, sizeof(float) * 16);
+	if (!ModelMatrix4x4 || !DestMatrix4x4)
+		return;
+	float m[16];
+	std::memcpy(m, ModelMatrix4x4, sizeof(m));
+	float delta[3] = {0.0f, 0.0f, 0.0f}, total = 0.0f;
+	if (ModelInstance)
+		for (const granny_control* c : ModelInstance->controls)
+		{
+			const float w = control_weight(c);
+			const gr2::Animation* a = c->animation->src;
+			if (w <= 0.0f || !a || !(a->accumulation_flags & 1) || (a->accumulation_flags & 4))
+				continue;
+			const float dur = c->animation->pub.Duration;
+			float t1 = c->local_clock, t0 = t1 - SecondsElapsed * c->speed;
+			if (c->loop_count != 0)
+			{
+				const float end = dur * c->loop_count;
+				t0 = std::min(std::max(t0, 0.0f), end);
+				t1 = std::min(std::max(t1, 0.0f), end);
+			}
+			const float k = dur > 0.0f ? (t1 - t0) / dur : 0.0f;
+			for (int i = 0; i < 3; ++i)
+				delta[i] += w * k * a->loop_translation[i];
+			total += w;
+		}
+	if (total > 0.0f)
+	{
+		const float s = (Inverse ? -1.0f : 1.0f) / total;
+		for (int col = 0; col < 3; ++col)
+			m[12 + col] += s * (delta[0] * ModelMatrix4x4[col] + delta[1] * ModelMatrix4x4[4 + col] +
+			                    delta[2] * ModelMatrix4x4[8 + col]);
+	}
+	std::memcpy(DestMatrix4x4, m, sizeof(m));
 }
 
 granny_control* GrannyPlayControlledAnimation(granny_real32 StartTime, granny_animation const* Animation, granny_model_instance* Model)

extension/src/platform/ScriptLib/GameplayModuleConstants.cpp

@@ -7,14 +7,8 @@
 #include "UserInterface/PythonBackground.h"
 #include "EterLib/StateManager.h"
 #include "GameLib/MapOutdoor.h"
-#include "UserInterface/PythonChat.h"
-#include "UserInterface/PythonItem.h"
-#include "GameLib/ItemManager.h"
-#include "UserInterface/PythonCharacterManager.h"
-#include "UserInterface/PythonNonPlayer.h"
-#include "UserInterface/InstanceBase.h"
-#include "GameLib/RaceManager.h"
 #include "EffectLib/EffectManager.h"
+#include "UserInterface/PythonCharacterManager.h"
 #include "UserInterface/PythonEventManager.h"
 #include "UserInterface/PythonNetworkStream.h"
 #include "GameLib/GameEventManager.h"
@@ -25,10 +19,13 @@
 #include "UserInterface/MarkManager.h"
 #include "UserInterface/PythonIME.h"
 #include "UserInterface/PythonApplication.h"
+#include "UserInterface/PythonItem.h"
+#include "GameLib/ItemManager.h"
+#include "UserInterface/InstanceBase.h"
 #include "UserInterface/AbstractApplication.h"
 #include "UserInterface/PythonMessenger.h"
 #include "UserInterface/PythonMiniMap.h"
-#include "UserInterface/PythonPlayer.h"
+#include "UserInterface/PythonNonPlayer.h"
 #include "EterLib/Profiler.h"
 #include "UserInterface/PythonQuest.h"
 #include "UserInterface/PythonSafeBox.h"
@@ -36,6 +33,7 @@
 #include "UserInterface/PythonSkill.h"
 #include "EterBase/Poly/Poly.h"
 #include "EterPack/EterPackManager.h"
+#include "UserInterface/PythonPlayer.h"
 #include "UserInterface/PythonTextTail.h"
 
 // 40250 UserInterface/ServerStateCheckerModule.cpp
@@ -473,279 +471,6 @@ void AddStubConstants_nonplayer(PyObject* poModule)
 	PyModule_AddIntConstant(poModule, "KING", 5);
 }
 
-// 40250 UserInterface/PythonPlayerModule.cpp
-extern const DWORD c_iSkillIndex_Tongsol	= 121;
-extern const DWORD c_iSkillIndex_Combo		= 122;
-extern const DWORD c_iSkillIndex_Fishing	= 123;
-extern const DWORD c_iSkillIndex_Mining		= 124;
-extern const DWORD c_iSkillIndex_Making		= 125;
-extern const DWORD c_iSkillIndex_Language1	= 126;
-extern const DWORD c_iSkillIndex_Language2	= 127;
-extern const DWORD c_iSkillIndex_Language3	= 128;
-extern const DWORD c_iSkillIndex_Polymorph	= 129;
-extern const DWORD c_iSkillIndex_Riding		= 130;
-extern const DWORD c_iSkillIndex_Summon		= 131;
-enum
-{
-	EMOTION_CLAP		= 1,
-	EMOTION_CHEERS_1,
-	EMOTION_CHEERS_2,
-	EMOTION_DANCE_1,
-	EMOTION_DANCE_2,
-	EMOTION_DANCE_3,
-	EMOTION_DANCE_4,
-	EMOTION_DANCE_5,
-	EMOTION_DANCE_6,		// 강남스타일
-	EMOTION_CONGRATULATION,
-	EMOTION_FORGIVE,
-	EMOTION_ANGRY,
-	
-	EMOTION_ATTRACTIVE,
-	EMOTION_SAD,
-	EMOTION_SHY,
-	EMOTION_CHEERUP,
-	EMOTION_BANTER,
-	EMOTION_JOY,
-
-	EMOTION_KISS		= 51,
-	EMOTION_FRENCH_KISS,
-	EMOTION_SLAP,
-
-};
-
-enum
-{
-	REFINE_SCROLL_TYPE_MAKE_SOCKET = 1,
-	REFINE_SCROLL_TYPE_UP_GRADE = 2,
-};
-
-enum
-{
-	REFINE_CANT,
-	REFINE_OK,
-	REFINE_ALREADY_MAX_SOCKET_COUNT,
-	REFINE_NEED_MORE_GOOD_SCROLL,
-	REFINE_CANT_MAKE_SOCKET_ITEM,
-	REFINE_NOT_NEXT_GRADE_ITEM,
-	REFINE_CANT_REFINE_METIN_TO_EQUIPMENT,
-	REFINE_CANT_REFINE_ROD,
-};
-
-enum
-{
-	ATTACH_METIN_CANT,
-	ATTACH_METIN_OK,
-	ATTACH_METIN_NOT_MATCHABLE_ITEM,
-	ATTACH_METIN_NO_MATCHABLE_SOCKET,
-	ATTACH_METIN_NOT_EXIST_GOLD_SOCKET,
-	ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT,
-};
-
-enum
-{
-	DETACH_METIN_CANT,
-	DETACH_METIN_OK,
-};
-
-// 40250 UserInterface/PythonPlayerModule.cpp
-void AddStubConstants_player(PyObject* poModule)
-{
-	(void) poModule;
-	PyModule_AddIntConstant(poModule, "LEVEL",					POINT_LEVEL);
-	PyModule_AddIntConstant(poModule, "VOICE",					POINT_VOICE);
-	PyModule_AddIntConstant(poModule, "EXP",					POINT_EXP);
-	PyModule_AddIntConstant(poModule, "NEXT_EXP",				POINT_NEXT_EXP);
-	PyModule_AddIntConstant(poModule, "HP",						POINT_HP);
-	PyModule_AddIntConstant(poModule, "MAX_HP",					POINT_MAX_HP);
-	PyModule_AddIntConstant(poModule, "SP",						POINT_SP);
-	PyModule_AddIntConstant(poModule, "MAX_SP",					POINT_MAX_SP);
-	PyModule_AddIntConstant(poModule, "STAMINA",				POINT_STAMINA);
-	PyModule_AddIntConstant(poModule, "MAX_STAMINA",			POINT_MAX_STAMINA);
-	PyModule_AddIntConstant(poModule, "ELK",					POINT_GOLD);
-	PyModule_AddIntConstant(poModule, "ST",						POINT_ST);
-	PyModule_AddIntConstant(poModule, "HT",						POINT_HT);
-	PyModule_AddIntConstant(poModule, "DX",						POINT_DX);
-	PyModule_AddIntConstant(poModule, "IQ",						POINT_IQ);
-	PyModule_AddIntConstant(poModule, "ATT_POWER",				POINT_ATT_POWER);
-	PyModule_AddIntConstant(poModule, "ATT_MIN",				POINT_MIN_ATK);
-	PyModule_AddIntConstant(poModule, "ATT_MAX",				POINT_MAX_ATK);
-	PyModule_AddIntConstant(poModule, "MIN_MAGIC_WEP",			POINT_MIN_MAGIC_WEP);
-	PyModule_AddIntConstant(poModule, "MAX_MAGIC_WEP",			POINT_MAX_MAGIC_WEP);
-	PyModule_AddIntConstant(poModule, "ATT_SPEED",				POINT_ATT_SPEED);
-	PyModule_AddIntConstant(poModule, "ATT_BONUS",				POINT_ATT_GRADE_BONUS);
-	PyModule_AddIntConstant(poModule, "EVADE_RATE",				POINT_EVADE_RATE);
-	PyModule_AddIntConstant(poModule, "MOVING_SPEED",			POINT_MOV_SPEED);
-	PyModule_AddIntConstant(poModule, "DEF_GRADE",				POINT_DEF_GRADE);
-	PyModule_AddIntConstant(poModule, "DEF_BONUS",				POINT_DEF_GRADE_BONUS);
-	PyModule_AddIntConstant(poModule, "CASTING_SPEED",			POINT_CASTING_SPEED);
-	PyModule_AddIntConstant(poModule, "MAG_ATT",				POINT_MAGIC_ATT_GRADE);
-	PyModule_AddIntConstant(poModule, "MAG_DEF",				POINT_MAGIC_DEF_GRADE);
-	PyModule_AddIntConstant(poModule, "EMPIRE_POINT",			POINT_EMPIRE_POINT);
-	PyModule_AddIntConstant(poModule, "STAT",					POINT_STAT);
-	PyModule_AddIntConstant(poModule, "SKILL_PASSIVE",			POINT_SUB_SKILL);
-	PyModule_AddIntConstant(poModule, "SKILL_SUPPORT",			POINT_SUB_SKILL);
-	PyModule_AddIntConstant(poModule, "SKILL_ACTIVE",			POINT_SKILL);
-	PyModule_AddIntConstant(poModule, "SKILL_HORSE",			POINT_HORSE_SKILL);
-	PyModule_AddIntConstant(poModule, "PLAYTIME",				POINT_PLAYTIME);
-	PyModule_AddIntConstant(poModule, "BOW_DISTANCE",			POINT_BOW_DISTANCE);
-	PyModule_AddIntConstant(poModule, "HP_RECOVERY",			POINT_HP_RECOVERY);
-	PyModule_AddIntConstant(poModule, "SP_RECOVERY",			POINT_SP_RECOVERY);
-	PyModule_AddIntConstant(poModule, "ATTACKER_BONUS",			POINT_PARTY_ATT_GRADE);
-	PyModule_AddIntConstant(poModule, "MAX_NUM",				POINT_MAX_NUM);
-	PyModule_AddIntConstant(poModule, "POINT_CRITICAL_PCT",		POINT_CRITICAL_PCT);
-	PyModule_AddIntConstant(poModule, "POINT_PENETRATE_PCT",	POINT_PENETRATE_PCT);
-	PyModule_AddIntConstant(poModule, "POINT_MALL_ATTBONUS",	POINT_MALL_ATTBONUS);
-	PyModule_AddIntConstant(poModule, "POINT_MALL_DEFBONUS",	POINT_MALL_DEFBONUS);
-	PyModule_AddIntConstant(poModule, "POINT_MALL_EXPBONUS",	POINT_MALL_EXPBONUS);
-	PyModule_AddIntConstant(poModule, "POINT_MALL_ITEMBONUS",	POINT_MALL_ITEMBONUS);
-	PyModule_AddIntConstant(poModule, "POINT_MALL_GOLDBONUS",	POINT_MALL_GOLDBONUS);
-	PyModule_AddIntConstant(poModule, "POINT_MAX_HP_PCT",		POINT_MAX_HP_PCT);
-	PyModule_AddIntConstant(poModule, "POINT_MAX_SP_PCT",		POINT_MAX_SP_PCT);
-	PyModule_AddIntConstant(poModule, "POINT_SKILL_DAMAGE_BONUS",		POINT_SKILL_DAMAGE_BONUS);
-	PyModule_AddIntConstant(poModule, "POINT_NORMAL_HIT_DAMAGE_BONUS",		POINT_NORMAL_HIT_DAMAGE_BONUS);
-	PyModule_AddIntConstant(poModule, "POINT_SKILL_DEFEND_BONUS",		POINT_SKILL_DEFEND_BONUS);
-	PyModule_AddIntConstant(poModule, "POINT_NORMAL_HIT_DEFEND_BONUS",		POINT_NORMAL_HIT_DEFEND_BONUS);
-	PyModule_AddIntConstant(poModule, "POINT_PC_BANG_EXP_BONUS",		POINT_PC_BANG_EXP_BONUS);
-	PyModule_AddIntConstant(poModule, "POINT_PC_BANG_DROP_BONUS",		POINT_PC_BANG_DROP_BONUS);
-	PyModule_AddIntConstant(poModule, "ENERGY",		POINT_ENERGY);
-	PyModule_AddIntConstant(poModule, "ENERGY_END_TIME",		POINT_ENERGY_END_TIME);
-	PyModule_AddIntConstant(poModule, "SKILL_GRADE_NORMAL",			CPythonPlayer::SKILL_NORMAL);
-	PyModule_AddIntConstant(poModule, "SKILL_GRADE_MASTER",			CPythonPlayer::SKILL_MASTER);
-	PyModule_AddIntConstant(poModule, "SKILL_GRADE_GRAND_MASTER",	CPythonPlayer::SKILL_GRAND_MASTER);
-	PyModule_AddIntConstant(poModule, "SKILL_GRADE_PERFECT_MASTER",	CPythonPlayer::SKILL_PERFECT_MASTER);
-	PyModule_AddIntConstant(poModule, "CATEGORY_ACTIVE",		CPythonPlayer::CATEGORY_ACTIVE);
-	PyModule_AddIntConstant(poModule, "CATEGORY_PASSIVE",		CPythonPlayer::CATEGORY_PASSIVE);
-	PyModule_AddIntConstant(poModule, "INVENTORY_PAGE_SIZE",	c_Inventory_Page_Size);
-	PyModule_AddIntConstant(poModule, "INVENTORY_PAGE_COUNT",	c_Inventory_Page_Count);
-	PyModule_AddIntConstant(poModule, "INVENTORY_SLOT_COUNT",	c_Inventory_Count);
-	PyModule_AddIntConstant(poModule, "EQUIPMENT_SLOT_START",	c_Equipment_Start);
-	PyModule_AddIntConstant(poModule, "EQUIPMENT_PAGE_COUNT",	c_Equipment_Count);
-#ifdef ENABLE_NEW_EQUIPMENT_SYSTEM
-	PyModule_AddIntConstant(poModule, "NEW_EQUIPMENT_SLOT_START",	c_New_Equipment_Start);
-	PyModule_AddIntConstant(poModule, "NEW_EQUIPMENT_SLOT_COUNT",	c_New_Equipment_Count);
-#endif
-	PyModule_AddIntConstant(poModule, "MBF_SKILL",	CPythonPlayer::MBF_SKILL);
-	PyModule_AddIntConstant(poModule, "MBF_ATTACK",	CPythonPlayer::MBF_ATTACK);
-	PyModule_AddIntConstant(poModule, "MBF_CAMERA",	CPythonPlayer::MBF_CAMERA);
-	PyModule_AddIntConstant(poModule, "MBF_SMART",	CPythonPlayer::MBF_SMART);
-	PyModule_AddIntConstant(poModule, "MBF_MOVE",	CPythonPlayer::MBF_MOVE);
-	PyModule_AddIntConstant(poModule, "MBF_AUTO",	CPythonPlayer::MBF_AUTO);
-	PyModule_AddIntConstant(poModule, "MBS_PRESS",	CPythonPlayer::MBS_PRESS);
-	PyModule_AddIntConstant(poModule, "MBS_CLICK",	CPythonPlayer::MBS_CLICK);
-	PyModule_AddIntConstant(poModule, "MBT_RIGHT",	CPythonPlayer::MBT_RIGHT);
-	PyModule_AddIntConstant(poModule, "MBT_LEFT",	CPythonPlayer::MBT_LEFT);
-	PyModule_AddIntConstant(poModule, "SLOT_TYPE_NONE",						SLOT_TYPE_NONE);
-	PyModule_AddIntConstant(poModule, "SLOT_TYPE_INVENTORY",				SLOT_TYPE_INVENTORY);
-	PyModule_AddIntConstant(poModule, "SLOT_TYPE_SKILL",					SLOT_TYPE_SKILL);
-	PyModule_AddIntConstant(poModule, "SLOT_TYPE_SHOP",						SLOT_TYPE_SHOP);
-	PyModule_AddIntConstant(poModule, "SLOT_TYPE_EXCHANGE_OWNER",			SLOT_TYPE_EXCHANGE_OWNER);
-	PyModule_AddIntConstant(poModule, "SLOT_TYPE_EXCHANGE_TARGET",			SLOT_TYPE_EXCHANGE_TARGET);
-	PyModule_AddIntConstant(poModule, "SLOT_TYPE_QUICK_SLOT",				SLOT_TYPE_QUICK_SLOT);
-	PyModule_AddIntConstant(poModule, "SLOT_TYPE_SAFEBOX",					SLOT_TYPE_SAFEBOX);
-	PyModule_AddIntConstant(poModule, "SLOT_TYPE_PRIVATE_SHOP",				SLOT_TYPE_PRIVATE_SHOP);
-	PyModule_AddIntConstant(poModule, "SLOT_TYPE_MALL",						SLOT_TYPE_MALL);
-	PyModule_AddIntConstant(poModule, "SLOT_TYPE_EMOTION",					SLOT_TYPE_EMOTION);
-	PyModule_AddIntConstant(poModule, "SLOT_TYPE_DRAGON_SOUL_INVENTORY",	SLOT_TYPE_DRAGON_SOUL_INVENTORY);
-	PyModule_AddIntConstant(poModule, "RESERVED_WINDOW",					RESERVED_WINDOW);
-	PyModule_AddIntConstant(poModule, "INVENTORY",							INVENTORY);
-	PyModule_AddIntConstant(poModule, "EQUIPMENT",							EQUIPMENT);
-	PyModule_AddIntConstant(poModule, "SAFEBOX",							SAFEBOX);
-	PyModule_AddIntConstant(poModule, "MALL",								MALL);
-	PyModule_AddIntConstant(poModule, "DRAGON_SOUL_INVENTORY",				DRAGON_SOUL_INVENTORY);
-	PyModule_AddIntConstant(poModule, "GROUND",								GROUND);
-	PyModule_AddIntConstant(poModule, "ITEM_MONEY",					-1);
-	PyModule_AddIntConstant(poModule, "SKILL_SLOT_COUNT",			SKILL_MAX_NUM);
-	PyModule_AddIntConstant(poModule, "EFFECT_PICK",				CPythonPlayer::EFFECT_PICK);
-	PyModule_AddIntConstant(poModule, "METIN_SOCKET_TYPE_NONE",					CPythonPlayer::METIN_SOCKET_TYPE_NONE);
-	PyModule_AddIntConstant(poModule, "METIN_SOCKET_TYPE_SILVER",				CPythonPlayer::METIN_SOCKET_TYPE_SILVER);
-	PyModule_AddIntConstant(poModule, "METIN_SOCKET_TYPE_GOLD",					CPythonPlayer::METIN_SOCKET_TYPE_GOLD);
-	PyModule_AddIntConstant(poModule, "METIN_SOCKET_MAX_NUM",					ITEM_SOCKET_SLOT_MAX_NUM);
-	PyModule_AddIntConstant(poModule, "ATTRIBUTE_SLOT_MAX_NUM",					ITEM_ATTRIBUTE_SLOT_MAX_NUM);
-	PyModule_AddIntConstant(poModule, "REFINE_CANT",							REFINE_CANT);
-	PyModule_AddIntConstant(poModule, "REFINE_OK",								REFINE_OK);
-	PyModule_AddIntConstant(poModule, "REFINE_ALREADY_MAX_SOCKET_COUNT",		REFINE_ALREADY_MAX_SOCKET_COUNT);
-	PyModule_AddIntConstant(poModule, "REFINE_NEED_MORE_GOOD_SCROLL",			REFINE_NEED_MORE_GOOD_SCROLL);
-	PyModule_AddIntConstant(poModule, "REFINE_CANT_MAKE_SOCKET_ITEM",			REFINE_CANT_MAKE_SOCKET_ITEM);
-	PyModule_AddIntConstant(poModule, "REFINE_NOT_NEXT_GRADE_ITEM",				REFINE_NOT_NEXT_GRADE_ITEM);
-	PyModule_AddIntConstant(poModule, "REFINE_CANT_REFINE_METIN_TO_EQUIPMENT",	REFINE_CANT_REFINE_METIN_TO_EQUIPMENT);
-	PyModule_AddIntConstant(poModule, "REFINE_CANT_REFINE_ROD",					REFINE_CANT_REFINE_ROD);
-	PyModule_AddIntConstant(poModule, "ATTACH_METIN_CANT",						ATTACH_METIN_CANT);
-	PyModule_AddIntConstant(poModule, "ATTACH_METIN_OK",						ATTACH_METIN_OK);
-	PyModule_AddIntConstant(poModule, "ATTACH_METIN_NOT_MATCHABLE_ITEM",		ATTACH_METIN_NOT_MATCHABLE_ITEM);
-	PyModule_AddIntConstant(poModule, "ATTACH_METIN_NO_MATCHABLE_SOCKET",		ATTACH_METIN_NO_MATCHABLE_SOCKET);
-	PyModule_AddIntConstant(poModule, "ATTACH_METIN_NOT_EXIST_GOLD_SOCKET",		ATTACH_METIN_NOT_EXIST_GOLD_SOCKET);
-	PyModule_AddIntConstant(poModule, "ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT",	ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT);
-	PyModule_AddIntConstant(poModule, "DETACH_METIN_CANT",						DETACH_METIN_CANT);
-	PyModule_AddIntConstant(poModule, "DETACH_METIN_OK",						DETACH_METIN_OK);
-	PyModule_AddIntConstant(poModule, "PARTY_STATE_NORMAL",						CPythonPlayer::PARTY_ROLE_NORMAL);
-	PyModule_AddIntConstant(poModule, "PARTY_STATE_LEADER",						CPythonPlayer::PARTY_ROLE_LEADER);
-	PyModule_AddIntConstant(poModule, "PARTY_STATE_ATTACKER",					CPythonPlayer::PARTY_ROLE_ATTACKER);
-	PyModule_AddIntConstant(poModule, "PARTY_STATE_TANKER",						CPythonPlayer::PARTY_ROLE_TANKER);
-	PyModule_AddIntConstant(poModule, "PARTY_STATE_BUFFER",						CPythonPlayer::PARTY_ROLE_BUFFER);
-	PyModule_AddIntConstant(poModule, "PARTY_STATE_SKILL_MASTER",				CPythonPlayer::PARTY_ROLE_SKILL_MASTER);
-	PyModule_AddIntConstant(poModule, "PARTY_STATE_BERSERKER",					CPythonPlayer::PARTY_ROLE_BERSERKER);
-	PyModule_AddIntConstant(poModule, "PARTY_STATE_DEFENDER",					CPythonPlayer::PARTY_ROLE_DEFENDER);
-	PyModule_AddIntConstant(poModule, "PARTY_STATE_MAX_NUM",					CPythonPlayer::PARTY_ROLE_MAX_NUM);
-	PyModule_AddIntConstant(poModule, "SKILL_INDEX_TONGSOL",		c_iSkillIndex_Tongsol);
-	PyModule_AddIntConstant(poModule, "SKILL_INDEX_FISHING",		c_iSkillIndex_Fishing);
-	PyModule_AddIntConstant(poModule, "SKILL_INDEX_MINING",			c_iSkillIndex_Mining);
-	PyModule_AddIntConstant(poModule, "SKILL_INDEX_MAKING",			c_iSkillIndex_Making);
-	PyModule_AddIntConstant(poModule, "SKILL_INDEX_COMBO",			c_iSkillIndex_Combo);
-	PyModule_AddIntConstant(poModule, "SKILL_INDEX_LANGUAGE1",		c_iSkillIndex_Language1);
-	PyModule_AddIntConstant(poModule, "SKILL_INDEX_LANGUAGE2",		c_iSkillIndex_Language2);
-	PyModule_AddIntConstant(poModule, "SKILL_INDEX_LANGUAGE3",		c_iSkillIndex_Language3);
-	PyModule_AddIntConstant(poModule, "SKILL_INDEX_POLYMORPH",		c_iSkillIndex_Polymorph);
-	PyModule_AddIntConstant(poModule, "SKILL_INDEX_RIDING",			c_iSkillIndex_Riding);
-	PyModule_AddIntConstant(poModule, "SKILL_INDEX_SUMMON",			c_iSkillIndex_Summon);
-	PyModule_AddIntConstant(poModule, "PK_MODE_PEACE",				PK_MODE_PEACE);
-	PyModule_AddIntConstant(poModule, "PK_MODE_REVENGE",			PK_MODE_REVENGE);
-	PyModule_AddIntConstant(poModule, "PK_MODE_FREE",				PK_MODE_FREE);
-	PyModule_AddIntConstant(poModule, "PK_MODE_PROTECT",			PK_MODE_PROTECT);
-	PyModule_AddIntConstant(poModule, "PK_MODE_GUILD",				PK_MODE_GUILD);
-	PyModule_AddIntConstant(poModule, "PK_MODE_MAX_NUM",			PK_MODE_MAX_NUM);
-	PyModule_AddIntConstant(poModule, "BLOCK_EXCHANGE",				BLOCK_EXCHANGE);
-	PyModule_AddIntConstant(poModule, "BLOCK_PARTY",				BLOCK_PARTY_INVITE);
-	PyModule_AddIntConstant(poModule, "BLOCK_GUILD",				BLOCK_GUILD_INVITE);
-	PyModule_AddIntConstant(poModule, "BLOCK_WHISPER",				BLOCK_WHISPER);
-	PyModule_AddIntConstant(poModule, "BLOCK_FRIEND",				BLOCK_MESSENGER_INVITE);
-	PyModule_AddIntConstant(poModule, "BLOCK_PARTY_REQUEST",		BLOCK_PARTY_REQUEST);
-	PyModule_AddIntConstant(poModule, "PARTY_EXP_NON_DISTRIBUTION",		PARTY_EXP_DISTRIBUTION_NON_PARITY);
-	PyModule_AddIntConstant(poModule, "PARTY_EXP_DISTRIBUTION_PARITY",	PARTY_EXP_DISTRIBUTION_PARITY);
-	PyModule_AddIntConstant(poModule, "EMOTION_CLAP",			EMOTION_CLAP);
-	PyModule_AddIntConstant(poModule, "EMOTION_CHEERS_1",		EMOTION_CHEERS_1);
-	PyModule_AddIntConstant(poModule, "EMOTION_CHEERS_2",		EMOTION_CHEERS_2);
-	PyModule_AddIntConstant(poModule, "EMOTION_DANCE_1",		EMOTION_DANCE_1);
-	PyModule_AddIntConstant(poModule, "EMOTION_DANCE_2",		EMOTION_DANCE_2);
-	PyModule_AddIntConstant(poModule, "EMOTION_DANCE_3",		EMOTION_DANCE_3);
-	PyModule_AddIntConstant(poModule, "EMOTION_DANCE_4",		EMOTION_DANCE_4);
-	PyModule_AddIntConstant(poModule, "EMOTION_DANCE_5",		EMOTION_DANCE_5);
-	PyModule_AddIntConstant(poModule, "EMOTION_DANCE_6",		EMOTION_DANCE_6);				// PSY 강남스타일
-	PyModule_AddIntConstant(poModule, "EMOTION_CONGRATULATION",	EMOTION_CONGRATULATION);
-	PyModule_AddIntConstant(poModule, "EMOTION_FORGIVE",		EMOTION_FORGIVE);
-	PyModule_AddIntConstant(poModule, "EMOTION_ANGRY",			EMOTION_ANGRY);
-	PyModule_AddIntConstant(poModule, "EMOTION_ATTRACTIVE",		EMOTION_ATTRACTIVE);
-	PyModule_AddIntConstant(poModule, "EMOTION_SAD",			EMOTION_SAD);
-	PyModule_AddIntConstant(poModule, "EMOTION_SHY",			EMOTION_SHY);
-	PyModule_AddIntConstant(poModule, "EMOTION_CHEERUP",		EMOTION_CHEERUP);
-	PyModule_AddIntConstant(poModule, "EMOTION_BANTER",			EMOTION_BANTER);
-	PyModule_AddIntConstant(poModule, "EMOTION_JOY",			EMOTION_JOY);
-	PyModule_AddIntConstant(poModule, "EMOTION_KISS",			EMOTION_KISS);
-	PyModule_AddIntConstant(poModule, "EMOTION_FRENCH_KISS",	EMOTION_FRENCH_KISS);
-	PyModule_AddIntConstant(poModule, "EMOTION_SLAP",			EMOTION_SLAP);
-	PyModule_AddIntConstant(poModule, "AUTO_POTION_TYPE_HP",	CPythonPlayer::AUTO_POTION_TYPE_HP);
-	PyModule_AddIntConstant(poModule, "AUTO_POTION_TYPE_SP",	CPythonPlayer::AUTO_POTION_TYPE_SP);
-	PyModule_AddIntConstant(poModule, "DRAGON_SOUL_PAGE_SIZE",	c_DragonSoul_Inventory_Box_Size);
-	PyModule_AddIntConstant(poModule, "DRAGON_SOUL_PAGE_COUNT",	DRAGON_SOUL_GRADE_MAX);
-	PyModule_AddIntConstant(poModule, "DRAGON_SOUL_SLOT_COUNT",	c_DragonSoul_Inventory_Count);
-	PyModule_AddIntConstant(poModule, "DRAGON_SOUL_EQUIPMENT_SLOT_START",	c_DragonSoul_Equip_Start);
-	PyModule_AddIntConstant(poModule, "DRAGON_SOUL_EQUIPMENT_PAGE_COUNT",	DS_DECK_MAX_NUM);
-	PyModule_AddIntConstant(poModule, "DRAGON_SOUL_EQUIPMENT_FIRST_SIZE",	c_DragonSoul_Equip_Slot_Max);
-	PyModule_AddIntConstant(poModule, "DRAGON_SOUL_REFINE_CLOSE",	DS_SUB_HEADER_CLOSE);
-	PyModule_AddIntConstant(poModule, "DS_SUB_HEADER_DO_UPGRADE",	DS_SUB_HEADER_DO_UPGRADE);
-	PyModule_AddIntConstant(poModule, "DS_SUB_HEADER_DO_IMPROVEMENT",	DS_SUB_HEADER_DO_IMPROVEMENT);
-	PyModule_AddIntConstant(poModule, "DS_SUB_HEADER_DO_REFINE",	DS_SUB_HEADER_DO_REFINE);
-}
-
 // 40250 UserInterface/PythonProfilerModule.cpp
 void AddStubConstants_profiler(PyObject* poModule)
 {

extension/src/platform/ScriptLib/GameplayModules.cpp

@@ -18,7 +18,6 @@ void AddStubConstants_item(PyObject* poModule);
 void AddStubConstants_messenger(PyObject* poModule);
 void AddStubConstants_miniMap(PyObject* poModule);
 void AddStubConstants_nonplayer(PyObject* poModule);
-void AddStubConstants_player(PyObject* poModule);
 void AddStubConstants_profiler(PyObject* poModule);
 void AddStubConstants_quest(PyObject* poModule);
 void AddStubConstants_safebox(PyObject* poModule);
@@ -579,272 +578,6 @@ PyMethodDef methods_nonplayer[] = {
     { "LoadNonPlayerData", stub_nonplayer_LoadNonPlayerData, METH_VARARGS },
     { NULL, NULL }
 };
-// 40250 UserInterface/PythonPlayerModule.cpp: player export names.
-PyObject* stub_player_GetAutoPotionInfo(PyObject*, PyObject*) { return stub_call_named("player.GetAutoPotionInfo", Py_BuildValue("biii", 0, 0, 0, 0)); }
-PyObject* stub_player_SetAutoPotionInfo(PyObject*, PyObject*) { return stub_call_named("player.SetAutoPotionInfo", Py_BuildNone()); }
-PyObject* stub_player_PickCloseItem(PyObject*, PyObject*) { return stub_call_named("player.PickCloseItem", Py_BuildNone()); }
-PyObject* stub_player_SetGameWindow(PyObject*, PyObject*) { return stub_call_named("player.SetGameWindow", Py_BuildNone()); }
-PyObject* stub_player_RegisterEffect(PyObject*, PyObject*) { return stub_call_named("player.RegisterEffect", Py_BuildNone()); }
-PyObject* stub_player_RegisterCacheEffect(PyObject*, PyObject*) { return stub_call_named("player.RegisterCacheEffect", Py_BuildNone()); }
-PyObject* stub_player_SetMouseState(PyObject*, PyObject*) { return stub_call_named("player.SetMouseState", Py_BuildNone()); }
-PyObject* stub_player_SetMouseFunc(PyObject*, PyObject*) { return stub_call_named("player.SetMouseFunc", Py_BuildNone()); }
-PyObject* stub_player_GetMouseFunc(PyObject*, PyObject*) { return stub_call_named("player.GetMouseFunc", Py_BuildValue("i", 0)); }
-PyObject* stub_player_SetMouseMiddleButtonState(PyObject*, PyObject*) { return stub_call_named("player.SetMouseMiddleButtonState", Py_BuildNone()); }
-PyObject* stub_player_SetMainCharacterIndex(PyObject*, PyObject*) { return stub_call_named("player.SetMainCharacterIndex", Py_BuildNone()); }
-PyObject* stub_player_GetMainCharacterIndex(PyObject*, PyObject*) { return stub_call_named("player.GetMainCharacterIndex", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetMainCharacterName(PyObject*, PyObject*) { return stub_call_named("player.GetMainCharacterName", Py_BuildValue("s", "")); }
-PyObject* stub_player_GetMainCharacterPosition(PyObject*, PyObject*) { return stub_call_named("player.GetMainCharacterPosition", Py_BuildValue("fff", 0.0, 0.0, 0.0)); }
-PyObject* stub_player_IsMainCharacterIndex(PyObject*, PyObject*) { return stub_call_named("player.IsMainCharacterIndex", Py_BuildValue("i", 0)); }
-PyObject* stub_player_CanAttackInstance(PyObject*, PyObject*) { return stub_call_named("player.CanAttackInstance", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsActingEmotion(PyObject*, PyObject*) { return stub_call_named("player.IsActingEmotion", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsPVPInstance(PyObject*, PyObject*) { return stub_call_named("player.IsPVPInstance", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsSameEmpire(PyObject*, PyObject*) { return stub_call_named("player.IsSameEmpire", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsChallengeInstance(PyObject*, PyObject*) { return stub_call_named("player.IsChallengeInstance", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsRevengeInstance(PyObject*, PyObject*) { return stub_call_named("player.IsRevengeInstance", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsCantFightInstance(PyObject*, PyObject*) { return stub_call_named("player.IsCantFightInstance", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetCharacterDistance(PyObject*, PyObject*) { return stub_call_named("player.GetCharacterDistance", Py_BuildValue("f", 0.0)); }
-PyObject* stub_player_IsInSafeArea(PyObject*, PyObject*) { return stub_call_named("player.IsInSafeArea", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsMountingHorse(PyObject*, PyObject*) { return stub_call_named("player.IsMountingHorse", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsObserverMode(PyObject*, PyObject*) { return stub_call_named("player.IsObserverMode", Py_BuildValue("i", 0)); }
-PyObject* stub_player_ActEmotion(PyObject*, PyObject*) { return stub_call_named("player.ActEmotion", Py_BuildNone()); }
-PyObject* stub_player_ShowPlayer(PyObject*, PyObject*) { return stub_call_named("player.ShowPlayer", Py_BuildNone()); }
-PyObject* stub_player_HidePlayer(PyObject*, PyObject*) { return stub_call_named("player.HidePlayer", Py_BuildNone()); }
-PyObject* stub_player_ComboAttack(PyObject*, PyObject*) { return stub_call_named("player.ComboAttack", Py_BuildNone()); }
-PyObject* stub_player_SetAutoCameraRotationSpeed(PyObject*, PyObject*) { return stub_call_named("player.SetAutoCameraRotationSpeed", Py_BuildNone()); }
-PyObject* stub_player_SetAttackKeyState(PyObject*, PyObject*) { return stub_call_named("player.SetAttackKeyState", Py_BuildNone()); }
-PyObject* stub_player_SetSingleDIKKeyState(PyObject*, PyObject*) { return stub_call_named("player.SetSingleDIKKeyState", Py_BuildNone()); }
-PyObject* stub_player_EndKeyWalkingImmediately(PyObject*, PyObject*) { return stub_call_named("player.EndKeyWalkingImmediately", Py_BuildNone()); }
-PyObject* stub_player_StartMouseWalking(PyObject*, PyObject*) { return stub_call_named("player.StartMouseWalking", Py_BuildNone()); }
-PyObject* stub_player_EndMouseWalking(PyObject*, PyObject*) { return stub_call_named("player.EndMouseWalking", Py_BuildNone()); }
-PyObject* stub_player_ResetCameraRotation(PyObject*, PyObject*) { return stub_call_named("player.ResetCameraRotation", Py_BuildNone()); }
-PyObject* stub_player_SetQuickCameraMode(PyObject*, PyObject*) { return stub_call_named("player.SetQuickCameraMode", Py_BuildNone()); }
-PyObject* stub_player_SetSkill(PyObject*, PyObject*) { return stub_call_named("player.SetSkill", Py_BuildNone()); }
-PyObject* stub_player_GetSkillIndex(PyObject*, PyObject*) { return stub_call_named("player.GetSkillIndex", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetSkillSlotIndex(PyObject*, PyObject*) { return stub_call_named("player.GetSkillSlotIndex", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetSkillGrade(PyObject*, PyObject*) { return stub_call_named("player.GetSkillGrade", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetSkillLevel(PyObject*, PyObject*) { return stub_call_named("player.GetSkillLevel", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetSkillCurrentEfficientPercentage(PyObject*, PyObject*) { return stub_call_named("player.GetSkillCurrentEfficientPercentage", Py_BuildValue("f", 0.0)); }
-PyObject* stub_player_GetSkillNextEfficientPercentage(PyObject*, PyObject*) { return stub_call_named("player.GetSkillNextEfficientPercentage", Py_BuildValue("f", 0.0)); }
-PyObject* stub_player_ClickSkillSlot(PyObject*, PyObject*) { return stub_call_named("player.ClickSkillSlot", Py_BuildNone()); }
-PyObject* stub_player_ChangeCurrentSkillNumberOnly(PyObject*, PyObject*) { return stub_call_named("player.ChangeCurrentSkillNumberOnly", Py_BuildNone()); }
-PyObject* stub_player_ClearSkillDict(PyObject*, PyObject*) { return stub_call_named("player.ClearSkillDict", Py_BuildNone()); }
-PyObject* stub_player_GetItemIndex(PyObject*, PyObject*) { return stub_call_named("player.GetItemIndex", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetItemFlags(PyObject*, PyObject*) { return stub_call_named("player.GetItemFlags", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetItemCount(PyObject*, PyObject*) { return stub_call_named("player.GetItemCount", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetItemCountByVnum(PyObject*, PyObject*) { return stub_call_named("player.GetItemCountByVnum", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetItemMetinSocket(PyObject*, PyObject*) { return stub_call_named("player.GetItemMetinSocket", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetItemAttribute(PyObject*, PyObject*) { return stub_call_named("player.GetItemAttribute", Py_BuildValue("ii", 0, 0)); }
-PyObject* stub_player_GetItemUnbindTime(PyObject*, PyObject*) { return stub_call_named("player.GetItemUnbindTime", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetISellItemPrice(PyObject*, PyObject*) { return stub_call_named("player.GetISellItemPrice", Py_BuildValue("i", 0)); }
-PyObject* stub_player_MoveItem(PyObject*, PyObject*) { return stub_call_named("player.MoveItem", Py_BuildNone()); }
-PyObject* stub_player_SendClickItemPacket(PyObject*, PyObject*) { return stub_call_named("player.SendClickItemPacket", Py_BuildNone()); }
-PyObject* stub_player_GetName(PyObject*, PyObject*) { return stub_call_named("player.GetName", Py_BuildValue("s", "")); }
-PyObject* stub_player_GetJob(PyObject*, PyObject*) { return stub_call_named("player.GetJob", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetRace(PyObject*, PyObject*) { return stub_call_named("player.GetRace", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetPlayTime(PyObject*, PyObject*) { return stub_call_named("player.GetPlayTime", Py_BuildValue("i", 0)); }
-PyObject* stub_player_SetPlayTime(PyObject*, PyObject*) { return stub_call_named("player.SetPlayTime", Py_BuildNone()); }
-PyObject* stub_player_IsSkillCoolTime(PyObject*, PyObject*) { return stub_call_named("player.IsSkillCoolTime", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetSkillCoolTime(PyObject*, PyObject*) { return stub_call_named("player.GetSkillCoolTime", Py_BuildValue("ff", 0.0, 0.0)); }
-PyObject* stub_player_IsSkillActive(PyObject*, PyObject*) { return stub_call_named("player.IsSkillActive", Py_BuildValue("i", 0)); }
-PyObject* stub_player_UseGuildSkill(PyObject*, PyObject*) { return stub_call_named("player.UseGuildSkill", Py_BuildNone()); }
-PyObject* stub_player_AffectIndexToSkillIndex(PyObject*, PyObject*) { return stub_call_named("player.AffectIndexToSkillIndex", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetEXP(PyObject*, PyObject*) { return stub_call_named("player.GetEXP", Py_BuildValue("l", 0L)); }
-PyObject* stub_player_GetStatus(PyObject*, PyObject*) { return stub_call_named("player.GetStatus", Py_BuildValue("i", 0)); }
-PyObject* stub_player_SetStatus(PyObject*, PyObject*) { return stub_call_named("player.SetStatus", Py_BuildNone()); }
-PyObject* stub_player_GetElk(PyObject*, PyObject*) { return stub_call_named("player.GetElk", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetMoney(PyObject*, PyObject*) { return stub_call_named("player.GetMoney", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetGuildID(PyObject*, PyObject*) { return stub_call_named("player.GetGuildID", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetGuildName(PyObject*, PyObject*) { return stub_call_named("player.GetGuildName", Py_BuildValue("s", "")); }
-PyObject* stub_player_GetAlignmentData(PyObject*, PyObject*) { return stub_call_named("player.GetAlignmentData", Py_BuildValue("ii", 0, 0)); }
-PyObject* stub_player_RequestAddLocalQuickSlot(PyObject*, PyObject*) { return stub_call_named("player.RequestAddLocalQuickSlot", Py_BuildNone()); }
-PyObject* stub_player_RequestAddToEmptyLocalQuickSlot(PyObject*, PyObject*) { return stub_call_named("player.RequestAddToEmptyLocalQuickSlot", Py_BuildNone()); }
-PyObject* stub_player_RequestDeleteGlobalQuickSlot(PyObject*, PyObject*) { return stub_call_named("player.RequestDeleteGlobalQuickSlot", Py_BuildNone()); }
-PyObject* stub_player_RequestMoveGlobalQuickSlotToLocalQuickSlot(PyObject*, PyObject*) { return stub_call_named("player.RequestMoveGlobalQuickSlotToLocalQuickSlot", Py_BuildNone()); }
-PyObject* stub_player_RequestUseLocalQuickSlot(PyObject*, PyObject*) { return stub_call_named("player.RequestUseLocalQuickSlot", Py_BuildNone()); }
-PyObject* stub_player_LocalQuickSlotIndexToGlobalQuickSlotIndex(PyObject*, PyObject*) { return stub_call_named("player.LocalQuickSlotIndexToGlobalQuickSlotIndex", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetQuickPage(PyObject*, PyObject*) { return stub_call_named("player.GetQuickPage", Py_BuildValue("i", 0)); }
-PyObject* stub_player_SetQuickPage(PyObject*, PyObject*) { return stub_call_named("player.SetQuickPage", Py_BuildNone()); }
-PyObject* stub_player_GetLocalQuickSlot(PyObject*, PyObject*) { return stub_call_named("player.GetLocalQuickSlot", Py_BuildValue("ii", 0, 0)); }
-PyObject* stub_player_GetGlobalQuickSlot(PyObject*, PyObject*) { return stub_call_named("player.GetGlobalQuickSlot", Py_BuildValue("ii", 0, 0)); }
-PyObject* stub_player_RemoveQuickSlotByValue(PyObject*, PyObject*) { return stub_call_named("player.RemoveQuickSlotByValue", Py_BuildNone()); }
-PyObject* stub_player_isItem(PyObject*, PyObject*) { return stub_call_named("player.isItem", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsEquipmentSlot(PyObject*, PyObject*) { return stub_call_named("player.IsEquipmentSlot", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsDSEquipmentSlot(PyObject*, PyObject*) { return stub_call_named("player.IsDSEquipmentSlot", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsCostumeSlot(PyObject*, PyObject*) { return stub_call_named("player.IsCostumeSlot", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsValuableItem(PyObject*, PyObject*) { return stub_call_named("player.IsValuableItem", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsOpenPrivateShop(PyObject*, PyObject*) { return stub_call_named("player.IsOpenPrivateShop", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsBeltInventorySlot(PyObject*, PyObject*) { return stub_call_named("player.IsBeltInventorySlot", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsEquippingBelt(PyObject*, PyObject*) { return stub_call_named("player.IsEquippingBelt", Py_BuildValue("b", 0)); }
-PyObject* stub_player_IsAvailableBeltInventoryCell(PyObject*, PyObject*) { return stub_call_named("player.IsAvailableBeltInventoryCell", Py_BuildValue("b", 0)); }
-PyObject* stub_player_GetItemGrade(PyObject*, PyObject*) { return stub_call_named("player.GetItemGrade", Py_BuildValue("i", 0)); }
-PyObject* stub_player_CanRefine(PyObject*, PyObject*) { return stub_call_named("player.CanRefine", Py_BuildValue("i", 0)); }
-PyObject* stub_player_CanDetach(PyObject*, PyObject*) { return stub_call_named("player.CanDetach", Py_BuildValue("i", 0)); }
-PyObject* stub_player_CanUnlock(PyObject*, PyObject*) { return stub_call_named("player.CanUnlock", Py_BuildValue("i", 0)); }
-PyObject* stub_player_CanAttachMetin(PyObject*, PyObject*) { return stub_call_named("player.CanAttachMetin", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsRefineGradeScroll(PyObject*, PyObject*) { return stub_call_named("player.IsRefineGradeScroll", Py_BuildValue("i", 0)); }
-PyObject* stub_player_ClearTarget(PyObject*, PyObject*) { return stub_call_named("player.ClearTarget", Py_BuildNone()); }
-PyObject* stub_player_SetTarget(PyObject*, PyObject*) { return stub_call_named("player.SetTarget", Py_BuildNone()); }
-PyObject* stub_player_OpenCharacterMenu(PyObject*, PyObject*) { return stub_call_named("player.OpenCharacterMenu", Py_BuildNone()); }
-PyObject* stub_player_Update(PyObject*, PyObject*) { return stub_call_named("player.Update", Py_BuildNone()); }
-PyObject* stub_player_Render(PyObject*, PyObject*) { return stub_call_named("player.Render", Py_BuildNone()); }
-PyObject* stub_player_Clear(PyObject*, PyObject*) { return stub_call_named("player.Clear", Py_BuildNone()); }
-PyObject* stub_player_IsPartyMember(PyObject*, PyObject*) { return stub_call_named("player.IsPartyMember", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsPartyLeader(PyObject*, PyObject*) { return stub_call_named("player.IsPartyLeader", Py_BuildValue("i", 0)); }
-PyObject* stub_player_IsPartyLeaderByPID(PyObject*, PyObject*) { return stub_call_named("player.IsPartyLeaderByPID", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetPartyMemberHPPercentage(PyObject*, PyObject*) { return stub_call_named("player.GetPartyMemberHPPercentage", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetPartyMemberState(PyObject*, PyObject*) { return stub_call_named("player.GetPartyMemberState", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetPartyMemberAffects(PyObject*, PyObject*) { return stub_call_named("player.GetPartyMemberAffects", Py_BuildValue("iiiiiii", 0, 0, 0, 0, 0, 0, 0)); }
-PyObject* stub_player_RemovePartyMember(PyObject*, PyObject*) { return stub_call_named("player.RemovePartyMember", Py_BuildNone()); }
-PyObject* stub_player_ExitParty(PyObject*, PyObject*) { return stub_call_named("player.ExitParty", Py_BuildNone()); }
-PyObject* stub_player_GetPKMode(PyObject*, PyObject*) { return stub_call_named("player.GetPKMode", Py_BuildValue("i", 0)); }
-PyObject* stub_player_HasMobilePhoneNumber(PyObject*, PyObject*) { return stub_call_named("player.HasMobilePhoneNumber", Py_BuildValue("i", 0)); }
-PyObject* stub_player_RegisterEmotionIcon(PyObject*, PyObject*) { return stub_call_named("player.RegisterEmotionIcon", Py_BuildNone()); }
-PyObject* stub_player_GetEmotionIconImage(PyObject*, PyObject*) { return stub_call_named("player.GetEmotionIconImage", Py_BuildValue("i", 0)); }
-PyObject* stub_player_SetWeaponAttackBonusFlag(PyObject*, PyObject*) { return stub_call_named("player.SetWeaponAttackBonusFlag", Py_BuildNone()); }
-PyObject* stub_player_ToggleCoolTime(PyObject*, PyObject*) { return stub_call_named("player.ToggleCoolTime", Py_BuildValue("i", 0)); }
-PyObject* stub_player_ToggleLevelLimit(PyObject*, PyObject*) { return stub_call_named("player.ToggleLevelLimit", Py_BuildValue("i", 0)); }
-PyObject* stub_player_GetTargetVID(PyObject*, PyObject*) { return stub_call_named("player.GetTargetVID", Py_BuildValue("i", 0)); }
-PyObject* stub_player_SetItemData(PyObject*, PyObject*) { return stub_call_named("player.SetItemData", Py_BuildNone()); }
-PyObject* stub_player_SetItemMetinSocket(PyObject*, PyObject*) { return stub_call_named("player.SetItemMetinSocket", Py_BuildNone()); }
-PyObject* stub_player_SetItemAttribute(PyObject*, PyObject*) { return stub_call_named("player.SetItemAttribute", Py_BuildNone()); }
-PyObject* stub_player_SetItemCount(PyObject*, PyObject*) { return stub_call_named("player.SetItemCount", Py_BuildNone()); }
-PyObject* stub_player_GetItemLink(PyObject*, PyObject*) { return stub_call_named("player.GetItemLink", Py_BuildValue("s", "")); }
-PyObject* stub_player_SlotTypeToInvenType(PyObject*, PyObject*) { return stub_call_named("player.SlotTypeToInvenType", Py_BuildValue("i", 0)); }
-PyObject* stub_player_SendDragonSoulRefine(PyObject*, PyObject*) { return stub_call_named("player.SendDragonSoulRefine", Py_BuildNone()); }
-PyMethodDef methods_player[] = {
-    { "GetAutoPotionInfo", stub_player_GetAutoPotionInfo, METH_VARARGS },
-    { "SetAutoPotionInfo", stub_player_SetAutoPotionInfo, METH_VARARGS },
-    { "PickCloseItem", stub_player_PickCloseItem, METH_VARARGS },
-    { "SetGameWindow", stub_player_SetGameWindow, METH_VARARGS },
-    { "RegisterEffect", stub_player_RegisterEffect, METH_VARARGS },
-    { "RegisterCacheEffect", stub_player_RegisterCacheEffect, METH_VARARGS },
-    { "SetMouseState", stub_player_SetMouseState, METH_VARARGS },
-    { "SetMouseFunc", stub_player_SetMouseFunc, METH_VARARGS },
-    { "GetMouseFunc", stub_player_GetMouseFunc, METH_VARARGS },
-    { "SetMouseMiddleButtonState", stub_player_SetMouseMiddleButtonState, METH_VARARGS },
-    { "SetMainCharacterIndex", stub_player_SetMainCharacterIndex, METH_VARARGS },
-    { "GetMainCharacterIndex", stub_player_GetMainCharacterIndex, METH_VARARGS },
-    { "GetMainCharacterName", stub_player_GetMainCharacterName, METH_VARARGS },
-    { "GetMainCharacterPosition", stub_player_GetMainCharacterPosition, METH_VARARGS },
-    { "IsMainCharacterIndex", stub_player_IsMainCharacterIndex, METH_VARARGS },
-    { "CanAttackInstance", stub_player_CanAttackInstance, METH_VARARGS },
-    { "IsActingEmotion", stub_player_IsActingEmotion, METH_VARARGS },
-    { "IsPVPInstance", stub_player_IsPVPInstance, METH_VARARGS },
-    { "IsSameEmpire", stub_player_IsSameEmpire, METH_VARARGS },
-    { "IsChallengeInstance", stub_player_IsChallengeInstance, METH_VARARGS },
-    { "IsRevengeInstance", stub_player_IsRevengeInstance, METH_VARARGS },
-    { "IsCantFightInstance", stub_player_IsCantFightInstance, METH_VARARGS },
-    { "GetCharacterDistance", stub_player_GetCharacterDistance, METH_VARARGS },
-    { "IsInSafeArea", stub_player_IsInSafeArea, METH_VARARGS },
-    { "IsMountingHorse", stub_player_IsMountingHorse, METH_VARARGS },
-    { "IsObserverMode", stub_player_IsObserverMode, METH_VARARGS },
-    { "ActEmotion", stub_player_ActEmotion, METH_VARARGS },
-    { "ShowPlayer", stub_player_ShowPlayer, METH_VARARGS },
-    { "HidePlayer", stub_player_HidePlayer, METH_VARARGS },
-    { "ComboAttack", stub_player_ComboAttack, METH_VARARGS },
-    { "SetAutoCameraRotationSpeed", stub_player_SetAutoCameraRotationSpeed, METH_VARARGS },
-    { "SetAttackKeyState", stub_player_SetAttackKeyState, METH_VARARGS },
-    { "SetSingleDIKKeyState", stub_player_SetSingleDIKKeyState, METH_VARARGS },
-    { "EndKeyWalkingImmediately", stub_player_EndKeyWalkingImmediately, METH_VARARGS },
-    { "StartMouseWalking", stub_player_StartMouseWalking, METH_VARARGS },
-    { "EndMouseWalking", stub_player_EndMouseWalking, METH_VARARGS },
-    { "ResetCameraRotation", stub_player_ResetCameraRotation, METH_VARARGS },
-    { "SetQuickCameraMode", stub_player_SetQuickCameraMode, METH_VARARGS },
-    { "SetSkill", stub_player_SetSkill, METH_VARARGS },
-    { "GetSkillIndex", stub_player_GetSkillIndex, METH_VARARGS },
-    { "GetSkillSlotIndex", stub_player_GetSkillSlotIndex, METH_VARARGS },
-    { "GetSkillGrade", stub_player_GetSkillGrade, METH_VARARGS },
-    { "GetSkillLevel", stub_player_GetSkillLevel, METH_VARARGS },
-    { "GetSkillCurrentEfficientPercentage", stub_player_GetSkillCurrentEfficientPercentage, METH_VARARGS },
-    { "GetSkillNextEfficientPercentage", stub_player_GetSkillNextEfficientPercentage, METH_VARARGS },
-    { "ClickSkillSlot", stub_player_ClickSkillSlot, METH_VARARGS },
-    { "ChangeCurrentSkillNumberOnly", stub_player_ChangeCurrentSkillNumberOnly, METH_VARARGS },
-    { "ClearSkillDict", stub_player_ClearSkillDict, METH_VARARGS },
-    { "GetItemIndex", stub_player_GetItemIndex, METH_VARARGS },
-    { "GetItemFlags", stub_player_GetItemFlags, METH_VARARGS },
-    { "GetItemCount", stub_player_GetItemCount, METH_VARARGS },
-    { "GetItemCountByVnum", stub_player_GetItemCountByVnum, METH_VARARGS },
-    { "GetItemMetinSocket", stub_player_GetItemMetinSocket, METH_VARARGS },
-    { "GetItemAttribute", stub_player_GetItemAttribute, METH_VARARGS },
-    { "GetItemUnbindTime", stub_player_GetItemUnbindTime, METH_VARARGS },
-    { "GetISellItemPrice", stub_player_GetISellItemPrice, METH_VARARGS },
-    { "MoveItem", stub_player_MoveItem, METH_VARARGS },
-    { "SendClickItemPacket", stub_player_SendClickItemPacket, METH_VARARGS },
-    { "GetName", stub_player_GetName, METH_VARARGS },
-    { "GetJob", stub_player_GetJob, METH_VARARGS },
-    { "GetRace", stub_player_GetRace, METH_VARARGS },
-    { "GetPlayTime", stub_player_GetPlayTime, METH_VARARGS },
-    { "SetPlayTime", stub_player_SetPlayTime, METH_VARARGS },
-    { "IsSkillCoolTime", stub_player_IsSkillCoolTime, METH_VARARGS },
-    { "GetSkillCoolTime", stub_player_GetSkillCoolTime, METH_VARARGS },
-    { "IsSkillActive", stub_player_IsSkillActive, METH_VARARGS },
-    { "UseGuildSkill", stub_player_UseGuildSkill, METH_VARARGS },
-    { "AffectIndexToSkillIndex", stub_player_AffectIndexToSkillIndex, METH_VARARGS },
-    { "GetEXP", stub_player_GetEXP, METH_VARARGS },
-    { "GetStatus", stub_player_GetStatus, METH_VARARGS },
-    { "SetStatus", stub_player_SetStatus, METH_VARARGS },
-    { "GetElk", stub_player_GetElk, METH_VARARGS },
-    { "GetMoney", stub_player_GetMoney, METH_VARARGS },
-    { "GetGuildID", stub_player_GetGuildID, METH_VARARGS },
-    { "GetGuildName", stub_player_GetGuildName, METH_VARARGS },
-    { "GetAlignmentData", stub_player_GetAlignmentData, METH_VARARGS },
-    { "RequestAddLocalQuickSlot", stub_player_RequestAddLocalQuickSlot, METH_VARARGS },
-    { "RequestAddToEmptyLocalQuickSlot", stub_player_RequestAddToEmptyLocalQuickSlot, METH_VARARGS },
-    { "RequestDeleteGlobalQuickSlot", stub_player_RequestDeleteGlobalQuickSlot, METH_VARARGS },
-    { "RequestMoveGlobalQuickSlotToLocalQuickSlot", stub_player_RequestMoveGlobalQuickSlotToLocalQuickSlot, METH_VARARGS },
-    { "RequestUseLocalQuickSlot", stub_player_RequestUseLocalQuickSlot, METH_VARARGS },
-    { "LocalQuickSlotIndexToGlobalQuickSlotIndex", stub_player_LocalQuickSlotIndexToGlobalQuickSlotIndex, METH_VARARGS },
-    { "GetQuickPage", stub_player_GetQuickPage, METH_VARARGS },
-    { "SetQuickPage", stub_player_SetQuickPage, METH_VARARGS },
-    { "GetLocalQuickSlot", stub_player_GetLocalQuickSlot, METH_VARARGS },
-    { "GetGlobalQuickSlot", stub_player_GetGlobalQuickSlot, METH_VARARGS },
-    { "RemoveQuickSlotByValue", stub_player_RemoveQuickSlotByValue, METH_VARARGS },
-    { "isItem", stub_player_isItem, METH_VARARGS },
-    { "IsEquipmentSlot", stub_player_IsEquipmentSlot, METH_VARARGS },
-    { "IsDSEquipmentSlot", stub_player_IsDSEquipmentSlot, METH_VARARGS },
-    { "IsCostumeSlot", stub_player_IsCostumeSlot, METH_VARARGS },
-    { "IsValuableItem", stub_player_IsValuableItem, METH_VARARGS },
-    { "IsOpenPrivateShop", stub_player_IsOpenPrivateShop, METH_VARARGS },
-    { "IsBeltInventorySlot", stub_player_IsBeltInventorySlot, METH_VARARGS },
-    { "IsEquippingBelt", stub_player_IsEquippingBelt, METH_VARARGS },
-    { "IsAvailableBeltInventoryCell", stub_player_IsAvailableBeltInventoryCell, METH_VARARGS },
-    { "GetItemGrade", stub_player_GetItemGrade, METH_VARARGS },
-    { "CanRefine", stub_player_CanRefine, METH_VARARGS },
-    { "CanDetach", stub_player_CanDetach, METH_VARARGS },
-    { "CanUnlock", stub_player_CanUnlock, METH_VARARGS },
-    { "CanAttachMetin", stub_player_CanAttachMetin, METH_VARARGS },
-    { "IsRefineGradeScroll", stub_player_IsRefineGradeScroll, METH_VARARGS },
-    { "ClearTarget", stub_player_ClearTarget, METH_VARARGS },
-    { "SetTarget", stub_player_SetTarget, METH_VARARGS },
-    { "OpenCharacterMenu", stub_player_OpenCharacterMenu, METH_VARARGS },
-    { "Update", stub_player_Update, METH_VARARGS },
-    { "Render", stub_player_Render, METH_VARARGS },
-    { "Clear", stub_player_Clear, METH_VARARGS },
-    { "IsPartyMember", stub_player_IsPartyMember, METH_VARARGS },
-    { "IsPartyLeader", stub_player_IsPartyLeader, METH_VARARGS },
-    { "IsPartyLeaderByPID", stub_player_IsPartyLeaderByPID, METH_VARARGS },
-    { "GetPartyMemberHPPercentage", stub_player_GetPartyMemberHPPercentage, METH_VARARGS },
-    { "GetPartyMemberState", stub_player_GetPartyMemberState, METH_VARARGS },
-    { "GetPartyMemberAffects", stub_player_GetPartyMemberAffects, METH_VARARGS },
-    { "RemovePartyMember", stub_player_RemovePartyMember, METH_VARARGS },
-    { "ExitParty", stub_player_ExitParty, METH_VARARGS },
-    { "GetPKMode", stub_player_GetPKMode, METH_VARARGS },
-    { "HasMobilePhoneNumber", stub_player_HasMobilePhoneNumber, METH_VARARGS },
-    { "RegisterEmotionIcon", stub_player_RegisterEmotionIcon, METH_VARARGS },
-    { "GetEmotionIconImage", stub_player_GetEmotionIconImage, METH_VARARGS },
-    { "SetWeaponAttackBonusFlag", stub_player_SetWeaponAttackBonusFlag, METH_VARARGS },
-    { "ToggleCoolTime", stub_player_ToggleCoolTime, METH_VARARGS },
-    { "ToggleLevelLimit", stub_player_ToggleLevelLimit, METH_VARARGS },
-    { "GetTargetVID", stub_player_GetTargetVID, METH_VARARGS },
-    { "SetItemData", stub_player_SetItemData, METH_VARARGS },
-    { "SetItemMetinSocket", stub_player_SetItemMetinSocket, METH_VARARGS },
-    { "SetItemAttribute", stub_player_SetItemAttribute, METH_VARARGS },
-    { "SetItemCount", stub_player_SetItemCount, METH_VARARGS },
-    { "GetItemLink", stub_player_GetItemLink, METH_VARARGS },
-    { "SlotTypeToInvenType", stub_player_SlotTypeToInvenType, METH_VARARGS },
-    { "SendDragonSoulRefine", stub_player_SendDragonSoulRefine, METH_VARARGS },
-    { NULL, NULL }
-};
 // 40250 UserInterface/PythonProfilerModule.cpp: profiler export names.
 PyObject* stub_profiler_Push(PyObject*, PyObject*) { return stub_call_named("profiler.Push", Py_BuildNone()); }
 PyObject* stub_profiler_Pop(PyObject*, PyObject*) { return stub_call_named("profiler.Pop", Py_BuildNone()); }
@@ -1252,11 +985,6 @@ void init_2v0_gameplay_stubs() {
         PyModule_AddIntConstant(module, "__port_stub__", 1);
         AddStubConstants_nonplayer(module);
     }
-    {
-        PyObject* module = Py_InitModule("player", methods_player);
-        PyModule_AddIntConstant(module, "__port_stub__", 1);
-        AddStubConstants_player(module);
-    }
     {
         PyObject* module = Py_InitModule("profiler", methods_profiler);
         PyModule_AddIntConstant(module, "__port_stub__", 1);

extension/src/platform/ScriptLib/PythonBoot.cpp

@@ -341,6 +341,7 @@ bool run_main_script_body(const char* lpCmdLine, std::string* error)
 	initapp();
 	initchr();
 	initchrmgr();
+	initPlayer();
 	initChat();
 	initnet();
 	init_2v0_gameplay_stubs();

extension/src/platform/UserInterface/PythonApplication.cpp

@@ -55,6 +55,9 @@ void CPythonApplication::SetMinFog(float) { MT_PLATFORM_STUB(); }
 // this returns it. PORT: no member to hold it; the timer only advances in Process(), so reading it
 // here gives the same value.
 float CPythonApplication::GetGlobalTime() { return CTimer::Instance().GetCurrentSecond(); }
+// In 40250 Process() also copies CTimer::GetElapsedSecond() into m_fGlobalElapsedTime (PythonApplication.cpp:448).
+// PORT: read straight from the timer, as GetGlobalTime above.
+float CPythonApplication::GetGlobalElapsedTime() { return CTimer::Instance().GetElapsedSecond(); }
 void CPythonApplication::SetFrameSkip(bool) { MT_PLATFORM_STUB(); }
 // PORT: 40250 creates the Win32 window, the D3D8 device, cursors, sound, keyboard, the net device,
 // fonts and the IME here. The Godot window and its canvas already exist when the host starts the
@@ -288,6 +291,9 @@ void CPythonApplication::SetCursorVisible(BOOL, bool) { MT_PLATFORM_STUB(); }
 BOOL CPythonApplication::GetCursorVisible() { MT_PLATFORM_STUB(); return FALSE; }
 bool CPythonApplication::GetLiarCursorOn() { MT_PLATFORM_STUB(); return false; }
 void CPythonApplication::SetCursorMode(int) { MT_PLATFORM_STUB(); }
+// 40250 returns m_iCursorMode, CURSOR_MODE_HARDWARE from the constructor until SetCursorMode (PythonApplicationCursor.cpp:92).
+// PORT: SetCursorMode is still a stub, so the mode stays the constructor's.
+int CPythonApplication::GetCursorMode() { return CURSOR_MODE_HARDWARE; }
 void CPythonApplication::SetMouseHandler(PyObject*) { MT_PLATFORM_STUB(); }
 void CPythonApplication::SetGlobalCenterPosition(LONG, LONG) { MT_PLATFORM_STUB(); }
 void CPythonApplication::SetFPS(int) { MT_PLATFORM_STUB(); }
@@ -306,7 +312,6 @@ BOOL SKILL_EFFECT_UPGRADE_ENABLE = FALSE;
 double g_specularSpd = 0;
 
 bool LoadLocaleData(const char*) { MT_PLATFORM_STUB(); return false; }
-void SetGuildSymbolPath(const char*) { MT_PLATFORM_STUB(); }
 void TextTail_SetLivingTime(long) { MT_PLATFORM_STUB(); }
 namespace {
 // The supplied 40250 Client/locale.cfg selects "en" (code page 1252).
@@ -364,72 +369,3 @@ int LocaleService_StringCompareCI( LPCSTR szStringLeft, LPCSTR szStringRight, si
 {
 	return strnicmp( szStringLeft, szStringRight, sizeLength );
 }
-
-// 40250 UserInterface/GameType.cpp:9-73 (DEFAULT_FONT), verbatim.
-// PORT: the default names are CP949 literals in 40250; ui.py sets the locale font (app.SetDefaultFontName)
-// before anything asks for it.
-static std::string gs_strDefaultFontName = "굴림체:12.fnt";
-static std::string gs_strDefaultItalicFontName = "굴림체:12i.fnt";
-static CResource* gs_pkDefaultFont = NULL;
-static CResource* gs_pkDefaultItalicFont = NULL;
-
-static bool gs_isReloadDefaultFont = false;
-
-void DefaultFont_Startup()
-{
-	gs_pkDefaultFont = NULL;
-}
-
-void DefaultFont_Cleanup()
-{
-	if (gs_pkDefaultFont)
-		gs_pkDefaultFont->Release();
-}
-
-void DefaultFont_SetName(const char * c_szFontName)
-{
-	gs_strDefaultFontName = c_szFontName;
-	gs_strDefaultFontName += ".fnt";
-
-	gs_strDefaultItalicFontName = c_szFontName;
-	if(strchr(c_szFontName, ':'))
-		gs_strDefaultItalicFontName += "i";
-	gs_strDefaultItalicFontName += ".fnt";
-
-	gs_isReloadDefaultFont = true;
-}
-
-bool ReloadDefaultFonts()
-{
-	CResourceManager& rkResMgr = CResourceManager::Instance();
-
-	gs_isReloadDefaultFont = false;
-
-	CResource* pkNewFont = rkResMgr.GetResourcePointer(gs_strDefaultFontName.c_str());
-	pkNewFont->AddReference();
-	if (gs_pkDefaultFont)
-		gs_pkDefaultFont->Release();
-	gs_pkDefaultFont = pkNewFont;
-
-	CResource* pkNewItalicFont = rkResMgr.GetResourcePointer(gs_strDefaultItalicFontName.c_str());
-	pkNewItalicFont->AddReference();
-	if (gs_pkDefaultItalicFont)
-		gs_pkDefaultItalicFont->Release();
-	gs_pkDefaultItalicFont = pkNewItalicFont;
-
-	return true;
-}
-
-CResource* DefaultFont_GetResource()
-{
-	if (!gs_pkDefaultFont || gs_isReloadDefaultFont)
-		ReloadDefaultFonts();
-	return gs_pkDefaultFont;
-}
-
-CResource* DefaultItalicFont_GetResource()
-{
-	if (!gs_pkDefaultItalicFont || gs_isReloadDefaultFont)
-		ReloadDefaultFonts();
-	return gs_pkDefaultItalicFont;
-}

extension/src/platform/pending/GameLib/ItemData.cpp

@@ -95,3 +95,39 @@ auto CItemData::GetAttachingDataPointer(DWORD, const NRaceData::TAttachingData *
 	MT_PLATFORM_STUB();
 	return mt_platform_stub_return<BOOL>();
 }
+
+auto CItemData::IsAntiFlag(DWORD) const -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CItemData::IsEquipment() const -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CItemData::IsFlag(DWORD) const -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CItemData::HasNextGrade() const -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CItemData::GetWearFlags() const -> DWORD
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<DWORD>();
+}
+
+auto CItemData::GetISellItemPrice() const -> DWORD
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<DWORD>();
+}

extension/src/platform/pending/GameLib/ItemManager.cpp

@@ -21,3 +21,15 @@ auto CItemManager::GetItemDataPointer(DWORD, CItemData **) -> BOOL
 	MT_PLATFORM_STUB();
 	return mt_platform_stub_return<BOOL>();
 }
+
+auto CItemManager::SelectItemData(DWORD) -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CItemManager::GetSelectedItemDataPointer() -> CItemData *
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<CItemData *>();
+}

extension/src/platform/pending/UserInterface/GameType.cpp

@@ -1,10 +0,0 @@
-// Pending GameType.cpp dependency of InstanceBase; the full unit is not ported yet.
-#include "UserInterface/StdAfx.h"
-#include "UserInterface/GameType.h"
-
-std::string g_strGuildSymbolPathName = "mark/10/";
-
-const char* GetGuildSymbolFileName(DWORD dwGuildID)
-{
-	return _getf("%s%03d.jpg", g_strGuildSymbolPathName.c_str(), dwGuildID);
-}

extension/src/platform/pending/UserInterface/Locale.cpp

@@ -0,0 +1,13 @@
+// Stand-in for the 40250 logic unit UserInterface/Locale.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 "UserInterface/StdAfx.h"
+#include "UserInterface/Locale.h"
+
+#include "../../PlatformStub.h"
+
+auto LocaleService_GetSkillPower(unsigned int) -> int
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<int>();
+}

extension/src/platform/pending/UserInterface/PythonBackground.cpp

@@ -206,3 +206,9 @@ void CPythonBackground::Initialize()
 	SetAtlasInfoFileName(atlas.c_str());
 	CMapManager::Initialize();
 }
+
+auto CPythonBackground::GetPickingPoint(D3DXVECTOR3 *) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}

extension/src/platform/pending/UserInterface/PythonGuild.cpp

@@ -131,3 +131,9 @@ CPythonGuild::~CPythonGuild()
 {
 	MT_PLATFORM_STUB();
 }
+
+auto CPythonGuild::IsDoingGuildWar() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}

extension/src/platform/pending/UserInterface/PythonItem.cpp

@@ -65,3 +65,39 @@ auto CPythonItem::Update(const POINT &) -> void
 {
 	MT_PLATFORM_STUB();
 }
+
+auto CPythonItem::GetOwnership(DWORD, const char **) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CPythonItem::GetGroundItemPosition(DWORD, TPixelPosition *) -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonItem::GetPickedItemID(DWORD *) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CPythonItem::GetCloseItem(const TPixelPosition &, DWORD *, DWORD) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CPythonItem::GetCloseMoney(const TPixelPosition &, DWORD *, DWORD) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CPythonItem::GetVirtualNumberOfGroundItem(DWORD) -> DWORD
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<DWORD>();
+}

extension/src/platform/pending/UserInterface/PythonMiniMap.cpp

@@ -70,3 +70,9 @@ auto CPythonMiniMap::DeleteTarget(int) -> void
 {
 	MT_PLATFORM_STUB();
 }
+
+auto CPythonMiniMap::GetGuildAreaID(DWORD, DWORD) -> DWORD
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<DWORD>();
+}

extension/src/platform/pending/UserInterface/PythonSkill.cpp

@@ -0,0 +1,193 @@
+// Stand-in for the 40250 logic unit UserInterface/PythonSkill.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 "UserInterface/StdAfx.h"
+#include "UserInterface/PythonSkill.h"
+
+#include "../../PlatformStub.h"
+
+auto CPythonSkill::SSkillData::IsNeedCorpse() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsToggleSkill() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsChargeSkill() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::GetSkillData(DWORD, TSkillData **) -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::GetTargetRange() const -> DWORD
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<DWORD>();
+}
+
+auto CPythonSkill::SSkillData::CanChangeDirection() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsFanRange() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsCircleRange() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsAutoSearchTarget() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsNeedTarget() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsUseHPSkill() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsStandingSkill() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::CanUseWeaponType(DWORD) -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsOnlyForAlliance() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::CanUseForMe() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::CanUseIfNotEnough() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsNeedEmptyBottle() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsNeedPoisonBottle() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsNeedBow() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsAttackSkill() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsHorseSkill() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsMovingSkill() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::IsOnlyForGuildWar() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::GetSkillCoolTime(float) -> DWORD
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<DWORD>();
+}
+
+auto CPythonSkill::SSkillData::GetNeedSP(float) -> int
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<int>();
+}
+
+auto CPythonSkill::SSkillData::GetMotionLoopCount(float) -> DWORD
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<DWORD>();
+}
+
+auto CPythonSkill::SSkillData::GetTargetCount(float) -> DWORD
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<DWORD>();
+}
+
+auto CPythonSkill::SSkillData::GetSkillMotionIndex(int) -> DWORD
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<DWORD>();
+}
+
+auto CPythonSkill::SSkillData::IsCanUseSkill() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CPythonSkill::SSkillData::IsNoMotion() -> BOOL
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BOOL>();
+}
+
+auto CPythonSkill::SSkillData::GetType() const -> BYTE
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BYTE>();
+}

extension/src/port/UserInterface/GameType.cpp

@@ -0,0 +1,112 @@
+#include "StdAfx.h"
+#include "GameType.h"
+
+std::string g_strResourcePath = "d:/ymir work/";
+std::string g_strImagePath = "d:/ymir work/ui/";
+
+std::string g_strGuildSymbolPathName = "mark/10/";
+
+// DEFAULT_FONT
+static std::string gs_strDefaultFontName = "\261\274\270\262\303\274:12.fnt";
+static std::string gs_strDefaultItalicFontName = "\261\274\270\262\303\274:12i.fnt";
+static CResource* gs_pkDefaultFont = NULL;
+static CResource* gs_pkDefaultItalicFont = NULL;
+
+static bool gs_isReloadDefaultFont = false;
+
+void DefaultFont_Startup()
+{
+	gs_pkDefaultFont = NULL;
+}
+
+void DefaultFont_Cleanup()
+{
+	if (gs_pkDefaultFont)
+		gs_pkDefaultFont->Release();
+}
+
+void DefaultFont_SetName(const char * c_szFontName)
+{
+	gs_strDefaultFontName = c_szFontName;
+	gs_strDefaultFontName += ".fnt";
+
+	gs_strDefaultItalicFontName = c_szFontName;
+	if(strchr(c_szFontName, ':'))
+		gs_strDefaultItalicFontName += "i";
+	gs_strDefaultItalicFontName += ".fnt";
+
+	gs_isReloadDefaultFont = true;
+}
+
+bool ReloadDefaultFonts()
+{
+	CResourceManager& rkResMgr = CResourceManager::Instance();
+
+	gs_isReloadDefaultFont = false;
+
+	CResource* pkNewFont = rkResMgr.GetResourcePointer(gs_strDefaultFontName.c_str());
+	pkNewFont->AddReference();
+	if (gs_pkDefaultFont)
+		gs_pkDefaultFont->Release();
+	gs_pkDefaultFont = pkNewFont;
+
+	CResource* pkNewItalicFont = rkResMgr.GetResourcePointer(gs_strDefaultItalicFontName.c_str());
+	pkNewItalicFont->AddReference();
+	if (gs_pkDefaultItalicFont)
+		gs_pkDefaultItalicFont->Release();
+	gs_pkDefaultItalicFont = pkNewItalicFont;
+
+	return true;
+}
+
+CResource* DefaultFont_GetResource()
+{	
+	if (!gs_pkDefaultFont || gs_isReloadDefaultFont)
+		ReloadDefaultFonts();
+	return gs_pkDefaultFont;
+}
+
+CResource* DefaultItalicFont_GetResource()
+{	
+	if (!gs_pkDefaultItalicFont || gs_isReloadDefaultFont)
+		ReloadDefaultFonts();
+	return gs_pkDefaultItalicFont;
+}
+
+// END_OF_DEFAULT_FONT
+
+void SetGuildSymbolPath(const char * c_szPathName)
+{
+	g_strGuildSymbolPathName = "mark/";
+	g_strGuildSymbolPathName += c_szPathName;
+	g_strGuildSymbolPathName += "/";
+}
+
+const char * GetGuildSymbolFileName(DWORD dwGuildID)
+{
+	return _getf("%s%03d.jpg", g_strGuildSymbolPathName.c_str(), dwGuildID);
+}
+
+BYTE c_aSlotTypeToInvenType[SLOT_TYPE_MAX] =
+{
+	RESERVED_WINDOW,		// SLOT_TYPE_NONE
+	INVENTORY,				// SLOT_TYPE_INVENTORY
+	RESERVED_WINDOW,		// SLOT_TYPE_SKILL
+	RESERVED_WINDOW,		// SLOT_TYPE_EMOTION
+	RESERVED_WINDOW,		// SLOT_TYPE_SHOP
+	RESERVED_WINDOW,		// SLOT_TYPE_EXCHANGE_OWNER
+	RESERVED_WINDOW,		// SLOT_TYPE_EXCHANGE_TARGET
+	RESERVED_WINDOW,		// SLOT_TYPE_QUICK_SLOT
+	RESERVED_WINDOW,		// SLOT_TYPE_SAFEBOX	<- SAFEBOX, MALL의 경우 하드 코딩되어있는 LEGACY 코드를 유지함.
+	RESERVED_WINDOW,		// SLOT_TYPE_PRIVATE_SHOP
+	RESERVED_WINDOW,		// SLOT_TYPE_MALL		<- SAFEBOX, MALL의 경우 하드 코딩되어있는 LEGACY 코드를 유지함.
+	DRAGON_SOUL_INVENTORY,	// SLOT_TYPE_DRAGON_SOUL_INVENTORY
+};
+
+BYTE SlotTypeToInvenType(BYTE bSlotType)
+{
+	if (bSlotType >= SLOT_TYPE_MAX)
+		return RESERVED_WINDOW;
+	else
+		return c_aSlotTypeToInvenType[bSlotType];
+}

extension/src/port/UserInterface/PythonPlayerEventHandler.cpp

@@ -0,0 +1,280 @@
+#include "StdAfx.h"
+#include "PythonPlayerEventHandler.h"
+#include "PythonPlayer.h"
+#include "PythonCharacterManager.h"
+#include "PythonNetworkStream.h"
+
+CPythonPlayerEventHandler& CPythonPlayerEventHandler::GetSingleton()
+{
+	static CPythonPlayerEventHandler s_kPlayerEventHandler;
+	return s_kPlayerEventHandler;
+}
+
+CPythonPlayerEventHandler::~CPythonPlayerEventHandler()
+{
+}
+
+void CPythonPlayerEventHandler::OnClearAffects()
+{
+	CPythonPlayer::Instance().ClearAffects();
+}
+
+void CPythonPlayerEventHandler::OnSetAffect(UINT uAffect)
+{
+	CPythonPlayer::Instance().SetAffect(uAffect);
+}
+
+void CPythonPlayerEventHandler::OnResetAffect(UINT uAffect)
+{
+	CPythonPlayer::Instance().ResetAffect(uAffect);
+}
+
+void CPythonPlayerEventHandler::OnSyncing(const SState& c_rkState)
+{
+	const TPixelPosition& c_rkPPosCurSyncing=c_rkState.kPPosSelf;
+	m_kPPosPrevWaiting=c_rkPPosCurSyncing;
+}
+
+void CPythonPlayerEventHandler::OnWaiting(const SState& c_rkState)
+{
+	DWORD dwCurTime=ELTimer_GetMSec();
+	if (m_dwNextWaitingNotifyTime>dwCurTime)
+		return;
+
+	m_dwNextWaitingNotifyTime=dwCurTime+100;
+
+	const TPixelPosition& c_rkPPosCurWaiting=c_rkState.kPPosSelf;
+	float dx=m_kPPosPrevWaiting.x-c_rkPPosCurWaiting.x;
+	float dy=m_kPPosPrevWaiting.y-c_rkPPosCurWaiting.y;
+	float len=sqrt(dx*dx+dy*dy);
+
+	if (len<1.0f)
+		return;
+
+	m_kPPosPrevWaiting=c_rkPPosCurWaiting;
+
+	CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
+	rkNetStream.SendCharacterStatePacket(c_rkState.kPPosSelf, c_rkState.fAdvRotSelf, CInstanceBase::FUNC_WAIT, 0);
+
+	//Trace("waiting\n");
+}
+
+void CPythonPlayerEventHandler::OnMoving(const SState& c_rkState)
+{
+	DWORD dwCurTime=ELTimer_GetMSec();		
+	if (m_dwNextMovingNotifyTime>dwCurTime)
+		return;
+	
+	m_dwNextMovingNotifyTime=dwCurTime+300;
+	
+	CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
+	rkNetStream.SendCharacterStatePacket(c_rkState.kPPosSelf, c_rkState.fAdvRotSelf, CInstanceBase::FUNC_MOVE, 0);
+
+//	Trace("moving\n");
+}
+
+void CPythonPlayerEventHandler::OnMove(const SState& c_rkState)
+{
+	DWORD dwCurTime=ELTimer_GetMSec();
+	m_dwNextWaitingNotifyTime=dwCurTime+100;
+	m_dwNextMovingNotifyTime=dwCurTime+300;
+
+	CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
+	rkNetStream.SendCharacterStatePacket(c_rkState.kPPosSelf, c_rkState.fAdvRotSelf, CInstanceBase::FUNC_MOVE, 0);
+
+//	Trace("move\n");
+}
+
+void CPythonPlayerEventHandler::OnStop(const SState& c_rkState)
+{
+	CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
+	rkNetStream.SendCharacterStatePacket(c_rkState.kPPosSelf, c_rkState.fAdvRotSelf, CInstanceBase::FUNC_WAIT, 0);
+
+//	Trace("stop\n");
+}
+
+void CPythonPlayerEventHandler::OnWarp(const SState& c_rkState)
+{
+	CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
+	rkNetStream.SendCharacterStatePacket(c_rkState.kPPosSelf, c_rkState.fAdvRotSelf, CInstanceBase::FUNC_WAIT, 0);
+}
+
+void CPythonPlayerEventHandler::OnAttack(const SState& c_rkState, WORD wMotionIndex)
+{
+//	Tracef("CPythonPlayerEventHandler::OnAttack [%d]\n", wMotionIndex);
+	assert(wMotionIndex < 255);
+
+	CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
+	rkNetStream.SendCharacterStatePacket(c_rkState.kPPosSelf, c_rkState.fAdvRotSelf, CInstanceBase::FUNC_COMBO, wMotionIndex);
+
+#ifdef __ATTACK_SPEED_CHECK__
+	static DWORD s_dwLastTime=timeGetTime();
+
+	DWORD dwCurTime=timeGetTime();
+	Tracef("%d\n", dwCurTime-s_dwLastTime);
+	s_dwLastTime=dwCurTime;
+#endif
+
+}
+
+void CPythonPlayerEventHandler::OnUseSkill(const SState& c_rkState, UINT uMotSkill, UINT uArg)
+{
+	CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
+	rkNetStream.SendCharacterStatePacket(c_rkState.kPPosSelf, c_rkState.fAdvRotSelf, CInstanceBase::FUNC_SKILL|uMotSkill, uArg);
+}
+
+void CPythonPlayerEventHandler::OnUpdate()
+{
+}
+
+void CPythonPlayerEventHandler::OnChangeShape()
+{
+	CPythonPlayer::Instance().NEW_Stop();
+}
+
+void CPythonPlayerEventHandler::OnHit(UINT uSkill, CActorInstance& rkActorVictim, BOOL isSendPacket)
+{
+	DWORD dwVIDVictim=rkActorVictim.GetVirtualID();
+
+	// Update Target
+	CPythonPlayer::Instance().SetTarget(dwVIDVictim, FALSE);
+	// Update Target
+
+	if (isSendPacket)
+	{
+//#define ATTACK_TIME_LOG
+#ifdef ATTACK_TIME_LOG
+		static std::map<DWORD, float> s_prevTimed;
+		float curTime = timeGetTime() / 1000.0f;
+		bool isFirst = false;
+		if (s_prevTimed.end() == s_prevTimed.find(dwVIDVictim))
+		{
+			s_prevTimed[dwVIDVictim] = curTime;
+			isFirst = true;
+		}
+		float diffTime = curTime-s_prevTimed[dwVIDVictim];
+		if (diffTime < 0.1f && !isFirst)
+		{
+			TraceError("ATTACK(SPEED_HACK): %.4f(%.4f) %d", curTime, diffTime, dwVIDVictim);
+		}
+		else
+		{
+			TraceError("ATTACK: %.4f(%.4f) %d", curTime, diffTime, dwVIDVictim);
+		}
+		
+		s_prevTimed[dwVIDVictim] = curTime;
+#endif
+		CPythonNetworkStream& rkStream=CPythonNetworkStream::Instance();
+		rkStream.SendAttackPacket(uSkill, dwVIDVictim);
+	}
+
+	if (!rkActorVictim.IsPushing())
+		return;
+
+	// 거대 몬스터 밀림 제외
+	extern bool IS_HUGE_RACE(unsigned int vnum);
+	if (IS_HUGE_RACE(rkActorVictim.GetRace()))
+		return;
+
+
+	CPythonCharacterManager::Instance().AdjustCollisionWithOtherObjects(&rkActorVictim);
+
+	const TPixelPosition& kPPosLast=rkActorVictim.NEW_GetLastPixelPositionRef();
+
+	SVictim kVictim;
+	kVictim.m_dwVID=dwVIDVictim;
+	kVictim.m_lPixelX=long(kPPosLast.x);
+	kVictim.m_lPixelY=long(kPPosLast.y);
+
+	rkActorVictim.TEMP_Push(kVictim.m_lPixelX, kVictim.m_lPixelY);
+
+	m_kVctkVictim.push_back(kVictim);
+}
+
+void CPythonPlayerEventHandler::FlushVictimList()
+{
+	if (m_kVctkVictim.empty())
+		return;
+
+	// #0000682: [M2EU] 대진각 스킬 사용시 튕김 
+	unsigned int SYNC_POSITION_COUNT_LIMIT = 16;
+	unsigned int uiVictimCount = m_kVctkVictim.size();
+
+	CPythonNetworkStream& rkStream=CPythonNetworkStream::Instance();
+
+	TPacketCGSyncPosition kPacketSyncPos;
+	kPacketSyncPos.bHeader=HEADER_CG_SYNC_POSITION;
+	kPacketSyncPos.wSize=sizeof(kPacketSyncPos)+sizeof(TPacketCGSyncPositionElement) * uiVictimCount;
+
+	rkStream.Send(sizeof(kPacketSyncPos), &kPacketSyncPos);
+
+	for (unsigned int i = 0; i < uiVictimCount; ++i)
+	{
+		const SVictim& rkVictim =  m_kVctkVictim[i];
+		rkStream.SendSyncPositionElementPacket(rkVictim.m_dwVID, rkVictim.m_lPixelX, rkVictim.m_lPixelY);		
+	}
+
+	rkStream.SendSequence();
+	m_kVctkVictim.clear();
+}
+
+CPythonPlayerEventHandler::CPythonPlayerEventHandler()
+{
+	m_dwPrevComboIndex=0;
+	m_dwNextMovingNotifyTime=0;
+	m_dwNextWaitingNotifyTime=0;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+void CPythonPlayerEventHandler::CNormalBowAttack_FlyEventHandler_AutoClear::OnSetFlyTarget()
+{
+	SState s;
+	m_pInstMain->NEW_GetPixelPosition(&s.kPPosSelf);
+	s.fAdvRotSelf=m_pInstMain->GetGraphicThingInstancePtr()->GetTargetRotation();
+
+	CPythonNetworkStream& rpns=CPythonNetworkStream::Instance();
+	rpns.SendFlyTargetingPacket(m_pInstTarget->GetVirtualID(), m_pInstTarget->GetGraphicThingInstancePtr()->OnGetFlyTargetPosition());
+}
+void CPythonPlayerEventHandler::CNormalBowAttack_FlyEventHandler_AutoClear::OnShoot(DWORD dwSkillIndex)
+{
+	CPythonNetworkStream& rpns=CPythonNetworkStream::Instance();
+	rpns.SendShootPacket(dwSkillIndex);
+}
+
+void CPythonPlayerEventHandler::CNormalBowAttack_FlyEventHandler_AutoClear::Set(CPythonPlayerEventHandler * pParent, CInstanceBase * pInstMain, CInstanceBase * pInstTarget)
+{
+	m_pParent=(pParent);
+	m_pInstMain=(pInstMain);
+	m_pInstTarget=(pInstTarget);
+}
+
+void CPythonPlayerEventHandler::CNormalBowAttack_FlyEventHandler_AutoClear::SetTarget(CInstanceBase* pInstTarget)
+{
+	m_pInstTarget = pInstTarget;
+}
+
+void CPythonPlayerEventHandler::CNormalBowAttack_FlyEventHandler_AutoClear::OnExplodingAtAnotherTarget(DWORD dwSkillIndex, DWORD dwVID)
+{
+	return;
+
+	Tracef("Shoot : \264\331\270\245 target\277\241 \270\302\276\322\275\300\264\317\264\331 : %d, %d\n", dwSkillIndex, dwVID);
+
+	CPythonNetworkStream& rkStream=CPythonNetworkStream::Instance();
+	rkStream.SendAttackPacket(dwSkillIndex, dwVID);
+
+	CPythonCharacterManager& rkChrMgr = CPythonCharacterManager::Instance();
+	CInstanceBase * pInstance = rkChrMgr.GetInstancePtr(dwVID);
+	if (pInstance)
+	{
+		pInstance->GetGraphicThingInstanceRef().OnShootDamage();
+	}
+}
+void CPythonPlayerEventHandler::CNormalBowAttack_FlyEventHandler_AutoClear::OnExplodingAtTarget(DWORD dwSkillIndex)
+{
+//	Tracef("Shoot : 원하는 target에 맞았습니다 : %d, %d\n", dwSkillIndex, m_pInstTarget->GetVirtualID());
+//	CPythonNetworkStream& rkStream=CPythonNetworkStream::Instance();
+//	rkStream.SendAttackPacket(dwSkillIndex, m_pInstTarget->GetVirtualID());
+}

extension/src/port/UserInterface/PythonPlayerEventHandler.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include "../GameLib/ActorInstance.h"
+#include "../GameLib/FlyHandler.h"
+
+#include "PythonNetworkStream.h"
+#include "InstanceBase.h"
+
+class CPythonPlayerEventHandler : public CActorInstance::IEventHandler
+{
+	public:
+		static CPythonPlayerEventHandler& GetSingleton();
+
+	public:
+		virtual ~CPythonPlayerEventHandler();
+
+		virtual void OnSyncing(const SState& c_rkState);
+		virtual void OnWaiting(const SState& c_rkState);
+		virtual void OnMoving(const SState& c_rkState);
+		virtual void OnMove(const SState& c_rkState);
+		virtual void OnStop(const SState& c_rkState);
+		virtual void OnWarp(const SState& c_rkState);
+		virtual void OnClearAffects();
+		virtual void OnSetAffect(UINT uAffect);
+		virtual void OnResetAffect(UINT uAffect);
+		virtual void OnAttack(const SState& c_rkState, WORD wMotionIndex);
+		virtual void OnUseSkill(const SState& c_rkState, UINT uMotSkill, UINT uArg);
+		virtual void OnUpdate();
+		virtual void OnChangeShape();
+		virtual void OnHit(UINT uSkill, CActorInstance& rkActorVictim, BOOL isSendPacket);
+
+		void FlushVictimList();
+
+	protected:
+		CPythonPlayerEventHandler();
+
+	protected:
+		struct SVictim
+		{
+			DWORD	m_dwVID;
+			long	m_lPixelX;
+			long	m_lPixelY;
+		};
+
+	protected:
+		std::vector<SVictim> m_kVctkVictim;
+
+		DWORD m_dwPrevComboIndex;
+		DWORD m_dwNextWaitingNotifyTime;
+		DWORD m_dwNextMovingNotifyTime;
+		TPixelPosition m_kPPosPrevWaiting;
+
+	private:
+		class CNormalBowAttack_FlyEventHandler_AutoClear : public IFlyEventHandler
+		{
+			public:
+				CNormalBowAttack_FlyEventHandler_AutoClear() {}
+				virtual ~CNormalBowAttack_FlyEventHandler_AutoClear() {}
+
+				void Set(CPythonPlayerEventHandler * pParent, CInstanceBase * pInstMain, CInstanceBase * pInstTarget);
+				void SetTarget(CInstanceBase* pInstTarget);
+
+				virtual void OnSetFlyTarget();
+				virtual void OnShoot(DWORD dwSkillIndex);
+
+				virtual void OnNoTarget() { /*Tracenf("Shoot : target이 없습니다.");*/ }
+				virtual void OnExplodingOutOfRange() { /*Tracenf("Shoot : 사정거리가 끝났습니다.");*/ }
+				virtual void OnExplodingAtBackground() { /*Tracenf("Shoot : 배경에 맞았습니다.");*/ }
+				virtual void OnExplodingAtAnotherTarget(DWORD dwSkillIndex, DWORD dwVID);
+				virtual void OnExplodingAtTarget(DWORD dwSkillIndex);
+
+			protected:
+				CPythonPlayerEventHandler * m_pParent;
+				CInstanceBase * m_pInstMain;
+				CInstanceBase * m_pInstTarget;
+		} m_NormalBowAttack_FlyEventHandler_AutoClear;
+
+		public:
+			IFlyEventHandler * GetNormalBowAttackFlyEventHandler(CInstanceBase* pInstMain, CInstanceBase* pInstTarget)
+			{
+				m_NormalBowAttack_FlyEventHandler_AutoClear.Set(this,pInstMain,pInstTarget);
+				return &m_NormalBowAttack_FlyEventHandler_AutoClear;
+			}
+
+			void ChangeFlyTarget(CInstanceBase* pInstTarget)
+			{
+				m_NormalBowAttack_FlyEventHandler_AutoClear.SetTarget(pInstTarget);
+			}
+};

extension/src/port/UserInterface/PythonPlayerInputKeyboard.cpp

@@ -0,0 +1,134 @@
+#include "StdAfx.h"
+#include "PythonPlayer.h"
+
+#include "InstanceBase.h"
+
+void CPythonPlayer::SetAttackKeyState(bool isPress)
+{
+	if (isPress)
+	{
+		CInstanceBase* pkInstMain = NEW_GetMainActorPtr();
+		if (pkInstMain)
+		if (pkInstMain->IsFishingMode())
+		{
+			NEW_Fishing();
+			return;
+		}
+	}
+
+	m_isAtkKey=isPress;
+}
+
+void CPythonPlayer::NEW_SetSingleDIKKeyState(int eDIKKey, bool isPress)
+{
+	if (NEW_CancelFishing())
+		return;
+
+	switch (eDIKKey)
+	{
+		case DIK_UP:
+			NEW_SetSingleDirKeyState(DIR_UP, isPress);
+			break;
+		case DIK_DOWN:
+			NEW_SetSingleDirKeyState(DIR_DOWN, isPress);
+			break;
+		case DIK_LEFT:
+			NEW_SetSingleDirKeyState(DIR_LEFT, isPress);
+			break;
+		case DIK_RIGHT:
+			NEW_SetSingleDirKeyState(DIR_RIGHT, isPress);
+			break;
+	}
+}
+
+void CPythonPlayer::NEW_SetSingleDirKeyState(int eDirKey, bool isPress)
+{
+	switch (eDirKey)
+	{
+		case DIR_UP:
+			m_isUp=isPress;
+			break;
+		case DIR_DOWN:
+			m_isDown=isPress;
+			break;
+		case DIR_LEFT:
+			m_isLeft=isPress;
+			break;
+		case DIR_RIGHT:
+			m_isRight=isPress;
+			break;
+	}
+
+	m_isDirKey=(m_isUp || m_isDown || m_isLeft || m_isRight);
+
+	NEW_SetMultiDirKeyState(m_isLeft, m_isRight, m_isUp, m_isDown);
+}
+
+void CPythonPlayer::NEW_SetMultiDirKeyState(bool isLeft, bool isRight, bool isUp, bool isDown)
+{
+	if (!__CanMove())
+		return;	
+
+	bool isAny=(isLeft || isRight || isUp || isDown);
+
+	if (isAny)
+	{
+		float fDirRot=0.0f;
+		NEW_GetMultiKeyDirRotation(isLeft, isRight, isUp, isDown, &fDirRot);
+
+		if (!NEW_MoveToDirection(fDirRot))
+		{
+			Tracen("CPythonPlayer::NEW_SetMultiKeyState - NEW_Move -> ERROR");
+			return;
+		}
+	}
+	else
+	{
+		NEW_Stop();
+	}
+}
+
+float CPythonPlayer::GetDegreeFromDirection(int iUD, int iLR)
+{
+	switch(iUD)
+	{
+		case KEYBOARD_UD_UP:
+			if (KEYBOARD_LR_LEFT == iLR)
+			{
+				return +45.0f;
+			}
+			else if (KEYBOARD_LR_RIGHT == iLR)
+			{
+				return -45.0f;
+			}
+
+			return 0.0f;
+			break;
+
+		case KEYBOARD_UD_DOWN:
+			if (KEYBOARD_LR_LEFT == iLR)
+			{
+				return +135.0f;
+			}
+			else if (KEYBOARD_LR_RIGHT == iLR)
+			{
+				return -135.0f;
+			}
+
+			return +180.0f;
+			break;
+
+		case KEYBOARD_UD_NONE:
+			if (KEYBOARD_LR_LEFT == iLR)
+			{
+				return +90.0f;
+			}
+			else if (KEYBOARD_LR_RIGHT == iLR)
+			{
+				return -90.0f;
+			}
+			break;
+	}
+
+	return 0.0f;
+}

extension/src/port/UserInterface/PythonPlayerInputMouse.cpp

@@ -0,0 +1,394 @@
+#include "StdAfx.h"
+#include "PythonPlayer.h"
+#include "PythonApplication.h"
+
+#include "../EterLib/Camera.h"
+
+void CPythonPlayer::NEW_SetMouseMoveState(int eMBS)
+{
+	if (MBS_PRESS==eMBS)
+	{
+		NEW_MoveToMouseScreenDirection();
+
+		m_isDirMov=true;
+	}
+	else if (MBS_CLICK==eMBS)
+	{
+		NEW_Stop();
+
+		m_isDirMov=false;
+	}
+}
+
+bool CPythonPlayer::NEW_MoveToMouseScreenDirection()
+{
+	UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+
+	long lMouseX;
+	long lMouseY;
+	rkWndMgr.GetMousePosition(lMouseX, lMouseY);
+
+	long lScrWidth = rkWndMgr.GetScreenWidth();
+	long lScrHeight = rkWndMgr.GetScreenHeight();
+	float fMouseX=lMouseX/float(lScrWidth);
+	float fMouseY=lMouseY/float(lScrHeight);
+
+	float fDirRot;
+	NEW_GetMouseDirRotation(fMouseX, fMouseY, &fDirRot);
+
+	return NEW_MoveToDirection(fDirRot);
+}
+
+void CPythonPlayer::NEW_SetMouseCameraState(int eMBS)
+{
+	CPythonApplication & rkApp = CPythonApplication::Instance();
+	CPythonBackground & rkBG = CPythonBackground::Instance();
+	CCamera* pkCmrCur=CCameraManager::Instance().GetCurrentCamera();
+
+	if (pkCmrCur)
+	{
+		if (MBS_PRESS==eMBS)
+		{
+			UI::CWindowManager& rkWndMgr=UI::CWindowManager::Instance();
+
+			long lMouseX;
+			long lMouseY;
+			rkWndMgr.GetMousePosition(lMouseX, lMouseY);
+
+			pkCmrCur->BeginDrag(lMouseX, lMouseY);
+
+			if ( !rkBG.IsMapReady() )
+				return;
+
+			rkApp.SetCursorNum(CPythonApplication::CAMERA_ROTATE);
+			if ( CPythonApplication::CURSOR_MODE_HARDWARE == rkApp.GetCursorMode())
+				rkApp.SetCursorVisible(FALSE, true);
+
+		}
+		else if (MBS_CLICK==eMBS)
+		{
+			bool isCameraDrag=pkCmrCur->EndDrag();
+			
+			if ( !rkBG.IsMapReady() )
+				return;
+
+			rkApp.SetCursorNum(CPythonApplication::NORMAL);
+			if ( CPythonApplication::CURSOR_MODE_HARDWARE == rkApp.GetCursorMode())
+				rkApp.SetCursorVisible(TRUE);
+
+			if (!isCameraDrag)
+			{
+				__ChangeTargetToPickedInstance();
+
+				CInstanceBase * pkInstPicked;
+				if (__GetPickedActorPtr(&pkInstPicked))
+				{
+					OpenCharacterMenu(pkInstPicked->GetVirtualID());
+				}
+			}
+		}
+	}
+}
+
+
+
+void CPythonPlayer::NEW_SetMouseSmartState(int eMBS, bool isAuto)
+{
+	CInstanceBase* pkInstMain=NEW_GetMainActorPtr();
+	if (!pkInstMain) return;
+
+	// PrivateShop
+	if (IsOpenPrivateShop())
+	{
+		// ShopPacket 이 오기전 잠깐 동안  
+		m_isSmtMov=false;
+		return;
+	}
+
+	// Emotion
+	if (__IsProcessingEmotion())
+	{
+		return;
+	}
+
+	// AFFECT_STUN 처리
+	if (pkInstMain->IsSleep())
+	{
+		return;
+	}
+
+	if (MBS_PRESS==eMBS)
+	{
+		m_isSmtMov=true;
+
+		__OnPressSmart(*pkInstMain, isAuto);
+	}
+	else if (MBS_CLICK==eMBS)
+	{
+		m_isSmtMov=false;
+
+		__OnClickSmart(*pkInstMain, isAuto);
+	}
+}
+
+void CPythonPlayer::__OnPressSmart(CInstanceBase& rkInstMain, bool isAuto)
+{
+	DWORD dwPickedItemID;
+	DWORD dwPickedActorID;
+	TPixelPosition kPPosPickedGround;
+
+	bool isPickedItemID=__GetPickedItemID(&dwPickedItemID);
+	bool isPickedActorID=__GetPickedActorID(&dwPickedActorID);
+	bool isPickedGroundPos=__GetPickedGroundPos(&kPPosPickedGround);
+
+	if (isPickedItemID)
+	{
+		__OnPressItem(rkInstMain, dwPickedItemID);
+	}
+	else if (isPickedActorID && dwPickedActorID != GetMainCharacterIndex())
+	{
+		__OnPressActor(rkInstMain, dwPickedActorID, isAuto);
+	}
+	else if (isPickedGroundPos)
+	{
+		__OnPressGround(rkInstMain, kPPosPickedGround);
+	}
+	else
+	{
+		__OnPressScreen(rkInstMain);
+	}
+}
+
+void CPythonPlayer::__OnClickSmart(CInstanceBase& rkInstMain, bool isAuto)
+{
+	DWORD dwPickedItemID;
+	DWORD dwPickedActorID;
+	TPixelPosition kPPosPickedGround;
+	if (__GetPickedItemID(&dwPickedItemID))
+	{
+		__OnClickItem(rkInstMain, dwPickedItemID);
+	}
+	else if (__GetPickedActorID(&dwPickedActorID))
+	{
+		__OnClickActor(rkInstMain, dwPickedActorID, isAuto);
+	}
+	else if (__GetPickedGroundPos(&kPPosPickedGround))
+	{
+		__OnClickGround(rkInstMain, kPPosPickedGround);
+	}
+	else
+	{
+		rkInstMain.NEW_Stop();
+	}
+}
+
+void CPythonPlayer::__ShowPickedEffect(const TPixelPosition& c_rkPPosPickedGround)
+{
+#ifdef __MOVIE_MODE__
+	CInstanceBase* pkInstMain=NEW_GetMainActorPtr();
+	if (!pkInstMain) return;
+
+	if (pkInstMain->IsMovieMode())
+		return;
+#endif
+	NEW_ShowEffect(EFFECT_PICK, c_rkPPosPickedGround);
+}
+
+bool CPythonPlayer::NEW_SetMouseFunc(int eMBT, int eMBF)
+{
+	if (eMBT>=MBT_NUM)
+		return false;
+
+	m_aeMBFButton[eMBT]=eMBF;
+
+	return true;
+}
+
+int CPythonPlayer::NEW_GetMouseFunc(int eMBT)
+{
+	if (eMBT>=MBT_NUM)
+		return false;
+
+	return m_aeMBFButton[eMBT];
+}
+
+void CPythonPlayer::SetQuickCameraMode(bool isEnable)
+{
+	if (isEnable)
+	{
+	}
+	else
+	{
+		NEW_SetMouseCameraState(MBS_CLICK);
+	}
+}
+
+bool CPythonPlayer::NEW_SetMouseState(int eMBT, int eMBS)
+{
+	if (eMBT>=MBT_NUM)
+		return false;
+
+	int eMBF=m_aeMBFButton[eMBT];
+	switch (eMBF)
+	{
+		case MBF_MOVE:
+			if (__CanMove())
+				NEW_SetMouseMoveState(eMBS);
+			break;
+		case MBF_SMART:
+			if (CPythonApplication::Instance().IsPressed(DIK_LCONTROL) || CPythonApplication::Instance().IsPressed(DIK_RCONTROL))
+			{
+				NEW_Attack();
+			}
+			else
+			{
+				NEW_SetMouseSmartState(eMBS, false);
+			}
+			break;
+		case MBF_CAMERA:
+			NEW_SetMouseCameraState(eMBS);
+			break;
+		case MBF_AUTO:
+			NEW_SetMouseSmartState(eMBS, true);
+			break;
+		case MBF_ATTACK:
+			NEW_Attack();
+			break;
+		case MBF_SKILL:
+			if (CPythonApplication::Instance().IsPressed(DIK_LCONTROL))
+			{
+				NEW_SetMouseCameraState(eMBS);
+			}
+			else
+			{
+				if (MBS_PRESS == eMBS)
+				{
+ 					__ChangeTargetToPickedInstance();
+					__UseCurrentSkill();
+				}
+			}
+			break;
+	}
+
+	return true;
+}
+
+void CPythonPlayer::NEW_SetMouseMiddleButtonState(int eMBState)
+{
+	NEW_SetMouseCameraState(eMBState);
+}
+
+
+
+void CPythonPlayer::NEW_RefreshMouseWalkingDirection()
+{
+	CInstanceBase* pkInstMain = NEW_GetMainActorPtr();
+	if (!pkInstMain) return;
+
+	switch (m_eReservedMode)
+	{
+		case MODE_CLICK_ITEM:
+		{
+			CPythonItem& rkIT=CPythonItem::Instance();
+
+			TPixelPosition kPPosPickedItem;
+			if (rkIT.GetGroundItemPosition(m_dwIIDReserved, &kPPosPickedItem))
+			{
+				if (pkInstMain->NEW_GetDistanceFromDestPixelPosition(kPPosPickedItem)<20.0f)
+				{
+					CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
+
+					TPixelPosition kPPosCur;
+					pkInstMain->NEW_GetPixelPosition(&kPPosCur);
+
+					float fCurRot=pkInstMain->GetRotation();
+					rkNetStream.SendCharacterStatePacket(kPPosCur,  fCurRot, CInstanceBase::FUNC_WAIT, 0);
+					SendClickItemPacket(m_dwIIDReserved);
+
+					pkInstMain->NEW_Stop();
+
+					__ClearReservedAction();
+				}
+				else
+				{
+					pkInstMain->NEW_MoveToDestPixelPositionDirection(kPPosPickedItem);
+				}
+			}
+			else
+			{
+				__ClearReservedAction();
+			}
+
+			break;
+		}
+
+		case MODE_CLICK_ACTOR:
+		{
+			__ReserveProcess_ClickActor();
+			break;
+		}
+
+		case MODE_CLICK_POSITION:
+		{
+			if (!pkInstMain->isLock())
+			if (NEW_IsEmptyReservedDelayTime(CPythonApplication::Instance().GetGlobalElapsedTime()))
+			{
+				pkInstMain->NEW_MoveToDestPixelPositionDirection(m_kPPosReserved);
+				__ClearReservedAction();
+			}
+			break;
+		}
+
+		case MODE_USE_SKILL:
+		{
+			CInstanceBase* pkInstReserved=NEW_FindActorPtr(m_dwVIDReserved);
+			if (pkInstReserved)
+			{
+				float fDistance=pkInstMain->GetDistance(pkInstReserved);
+
+				// #0000806: [M2EU] 수룡에게 무사(나한군) 탄환격 스킬 사용 안됨
+				extern bool IS_HUGE_RACE(unsigned int vnum);
+				if (IS_HUGE_RACE(pkInstReserved->GetRace())) // 거대 종족은 근접을 못함
+				{
+					fDistance -= 200.0f; // TEMP: 일단 하드 코딩 처리. 정석적으로는 바운드 스피어를 고려해야함
+				}
+
+				if (fDistance < float(m_dwSkillRangeReserved))
+				{
+					// 접근 도중 Target 이 바뀌어 있을 수도 있다 - [levites]
+					SetTarget(m_dwVIDReserved);
+					if (__UseSkill(m_dwSkillSlotIndexReserved))
+						__ClearReservedAction();
+				}
+				else
+				{
+					pkInstMain->NEW_MoveToDestInstanceDirection(*pkInstReserved);
+				}
+			}
+			else
+			{
+				__ClearReservedAction();
+			}
+			break;
+		}
+	}
+
+	if (m_isSmtMov)
+		__OnPressSmart(*pkInstMain, false);
+
+	if (m_isDirMov)
+		NEW_MoveToMouseScreenDirection();
+
+	if (m_isDirKey)
+		NEW_SetMultiDirKeyState(m_isLeft, m_isRight, m_isUp, m_isDown);
+
+	if (m_isAtkKey)
+		NEW_Attack();
+
+	m_iComboOld=pkInstMain->GetComboIndex();
+}
+
+BOOL CPythonPlayer::__IsRightButtonSkillMode()
+{
+	return MBF_SKILL == m_aeMBFButton[MBT_RIGHT];
+}

extension/src/port/UserInterface/PythonPlayerSkill.cpp

@@ -0,0 +1,991 @@
+#include "StdAfx.h"
+#include "PythonPlayer.h"
+#include "PythonTextTail.h"
+#include "PythonNetworkStream.h"
+#include "InstanceBase.h"
+#include "PythonChat.h"
+#include "PythonGuild.h"
+#include "../GameLib/ItemManager.h"
+
+void CPythonPlayer::ClearAffects()
+{
+	PyCallClassMemberFunc(m_ppyGameWindow, "ClearAffects", Py_BuildValue("()"));
+}
+
+void CPythonPlayer::SetAffect(UINT uAffect)
+{
+	PyCallClassMemberFunc(m_ppyGameWindow, "SetAffect", Py_BuildValue("(i)", uAffect));
+
+	/////
+
+	DWORD dwSkillIndex;
+	if (!AffectIndexToSkillIndex(uAffect, &dwSkillIndex))
+		return;
+
+	CPythonSkill::TSkillData * pSkillData;
+	if (!CPythonSkill::Instance().GetSkillData(dwSkillIndex, &pSkillData))
+		return;
+
+	if (!pSkillData->IsToggleSkill())
+		return;
+
+	DWORD dwSkillSlotIndex;
+	if (!GetSkillSlotIndex(dwSkillIndex, &dwSkillSlotIndex))
+		return;
+
+	__ActivateSkillSlot(dwSkillSlotIndex);
+}
+
+void CPythonPlayer::ResetAffect(UINT uAffect)
+{
+	// 2004.07.17.myevan.스킬 아닌 이펙트가 안 사라지는 문제 
+	PyCallClassMemberFunc(m_ppyGameWindow, "ResetAffect", Py_BuildValue("(i)", uAffect));
+
+	DWORD dwSkillIndex;
+	if (!AffectIndexToSkillIndex(uAffect, &dwSkillIndex))
+		return;
+
+	CPythonSkill::TSkillData * pSkillData;
+	if (!CPythonSkill::Instance().GetSkillData(dwSkillIndex, &pSkillData))
+		return;
+
+	if (!pSkillData->IsToggleSkill())
+		return;
+
+	DWORD dwSkillSlotIndex;
+	if (!GetSkillSlotIndex(dwSkillIndex, &dwSkillSlotIndex))
+		return;
+
+	__DeactivateSkillSlot(dwSkillSlotIndex);
+}
+
+bool CPythonPlayer::FindSkillSlotIndexBySkillIndex(DWORD dwSkillIndex, DWORD * pdwSkillSlotIndex)
+{
+	for (int i = 0; i < SKILL_MAX_NUM; ++i)
+	{
+		TSkillInstance & rkSkillInst = m_playerStatus.aSkill[i];
+		if (dwSkillIndex == rkSkillInst.dwIndex)
+		{
+			*pdwSkillSlotIndex = i;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+void CPythonPlayer::ChangeCurrentSkillNumberOnly(DWORD dwSlotIndex)
+{
+	if (dwSlotIndex >= SKILL_MAX_NUM)
+		return;
+
+	TSkillInstance & rkSkillInst = m_playerStatus.aSkill[dwSlotIndex];
+
+	CPythonSkill::TSkillData * pSkillData;
+	if (!CPythonSkill::Instance().GetSkillData(rkSkillInst.dwIndex, &pSkillData))
+		return;
+
+	if (!pSkillData->IsCanUseSkill())
+		return;
+
+	if (!__IsRightButtonSkillMode())
+	{
+		if (!__IsTarget())
+		{
+			PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "NEED_TARGET"));
+			return;
+		}
+
+		ClickSkillSlot(dwSlotIndex);
+	}
+	else
+	{
+		m_dwcurSkillSlotIndex = dwSlotIndex;
+		PyCallClassMemberFunc(m_ppyGameWindow, "ChangeCurrentSkill", Py_BuildValue("(i)", dwSlotIndex));
+	}
+}
+
+void CPythonPlayer::ClickSkillSlot(DWORD dwSlotIndex)
+{
+	if (dwSlotIndex >= SKILL_MAX_NUM)
+		return;
+
+	TSkillInstance & rkSkillInst = m_playerStatus.aSkill[dwSlotIndex];
+
+	CPythonSkill::TSkillData * pSkillData;
+	if (!CPythonSkill::Instance().GetSkillData(rkSkillInst.dwIndex, &pSkillData))
+		return;
+
+	if (CPythonSkill::SKILL_TYPE_GUILD == pSkillData->byType)
+	{
+		UseGuildSkill(dwSlotIndex);
+		return;
+	}
+
+	if (!pSkillData->IsCanUseSkill())
+		return;
+
+	if (pSkillData->IsStandingSkill())
+	{
+		if (pSkillData->IsToggleSkill())
+		{
+			if (IsSkillActive(dwSlotIndex))
+			{
+				CInstanceBase * pkInstMain = NEW_GetMainActorPtr();
+				if (!pkInstMain)
+					return;
+				if (pkInstMain->IsUsingSkill())
+					return;
+
+				CPythonNetworkStream::Instance().SendUseSkillPacket(rkSkillInst.dwIndex);
+				return;
+			}
+		}
+
+		__UseSkill(dwSlotIndex);
+		return;
+	}
+
+	if (m_dwcurSkillSlotIndex == dwSlotIndex)
+	{
+		__UseSkill(m_dwcurSkillSlotIndex);
+		return;
+	}
+
+	if (!__IsRightButtonSkillMode())
+	{
+		__UseSkill(dwSlotIndex);
+	}
+	else
+	{
+		m_dwcurSkillSlotIndex = dwSlotIndex;
+		PyCallClassMemberFunc(m_ppyGameWindow, "ChangeCurrentSkill", Py_BuildValue("(i)", dwSlotIndex));
+	}
+}
+
+bool CPythonPlayer::__CheckSkillUsable(DWORD dwSlotIndex)
+{
+	CInstanceBase * pkInstMain = NEW_GetMainActorPtr();
+	if (!pkInstMain)
+		return false;
+
+	if (dwSlotIndex >= SKILL_MAX_NUM)
+		return false;
+
+	TSkillInstance & rkSkillInst = m_playerStatus.aSkill[dwSlotIndex];
+
+	CPythonSkill::TSkillData * pSkillData;
+	if (!CPythonSkill::Instance().GetSkillData(rkSkillInst.dwIndex, &pSkillData))
+		return false;
+
+	if (pkInstMain->IsMountingHorse())
+	{
+		if (!pSkillData->IsHorseSkill())
+		{
+			PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "NOT_HORSE_SKILL"));
+			return false;
+		}
+	}
+
+	if (pSkillData->IsHorseSkill())
+	{
+		if (!pkInstMain->IsMountingHorse())
+		{
+			PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "HAVE_TO_RIDE"));
+			return false;
+		}
+	}
+
+	// 2004.07.26.levites - 안전지대에서 공격 못하도록 수정
+	// NOTE : 공격 스킬은 안전지대에서 사용하지 못합니다 - [levites]
+	if (pSkillData->IsAttackSkill())
+	{
+		if (pkInstMain->IsInSafe())
+		{
+			PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "IN_SAFE"));
+
+			return false;
+		}
+	}	
+
+	// NOTE : 패시브 스킬은 사용하지 못합니다 - [levites]
+	if (!pSkillData->IsCanUseSkill())
+		return false;
+//	if (CPythonSkill::SKILL_TYPE_PASSIVE == pSkillData->byType)
+//		return false;
+
+	// NOTE : [Only Assassin] 빈병이 있는지 체크 합니다.
+	if (pSkillData->IsNeedEmptyBottle())
+	{
+		if (!__HasItem(27995))
+		{
+			PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "NEED_EMPTY_BOTTLE"));
+			return false;
+		}
+	}
+
+	// NOTE : [Only Assassin] 독병이 있는지 체크 합니다.
+	if (pSkillData->IsNeedPoisonBottle())
+	{
+		if (!__HasItem(27996))
+		{
+			PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "NEED_POISON_BOTTLE"));
+			return false;
+		}
+	}
+
+	// NOTE : 낚시 중일때는 스킬을 사용하지 못합니다.
+	if (pkInstMain->IsFishingMode())
+	{
+		PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "REMOVE_FISHING_ROD"));
+		return false;
+	}
+
+	// NOTE : 레벨 체크
+	if (m_sysIsLevelLimit)
+	{
+		if (rkSkillInst.iLevel <= 0)
+		{
+			PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "NOT_YET_LEARN"));
+			return false;
+		}
+	}
+
+	// NOTE : 들고 있는 무기 체크
+	if (!pSkillData->CanUseWeaponType(pkInstMain->GetWeaponType()))
+	{
+		PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "NOT_MATCHABLE_WEAPON"));
+		return false;
+	}
+
+	if (!pSkillData->IsHorseSkill()) // HORSE 스킬 중에 화살을 쓰지 않는 스킬이 있기 때문에
+	{
+		if (__CheckShortArrow(rkSkillInst, *pSkillData))
+			return false;
+
+		// NOTE : 활이 필요할 경우 화살 개수 체크
+		if (pSkillData->IsNeedBow())
+		{
+			if (!__HasEnoughArrow())
+				return false;
+		}
+	}
+
+	if (__CheckDashAffect(*pkInstMain))
+	{
+		if (!pSkillData->IsChargeSkill())
+		{
+			if (__CheckRestSkillCoolTime(dwSlotIndex))
+			{
+				PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "WAIT_COOLTIME"));
+				return false;
+			}
+		}
+	}
+	else
+	{
+		if (__CheckRestSkillCoolTime(dwSlotIndex))
+		{
+			PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "WAIT_COOLTIME"));
+			return false;
+		}
+
+		if (__CheckShortLife(rkSkillInst, *pSkillData))
+		{
+			PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "NOT_ENOUGH_HP"));
+			return false;
+		}
+
+		if (__CheckShortMana(rkSkillInst, *pSkillData))
+		{
+			PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "NOT_ENOUGH_SP"));
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool CPythonPlayer::__CheckShortArrow(TSkillInstance & rkSkillInst, CPythonSkill::TSkillData& rkSkillData)
+{
+	if (!rkSkillData.IsNeedBow())
+		return false;
+
+	if (__HasEnoughArrow())
+		return false;
+	
+	return true;
+}
+
+bool CPythonPlayer::__CheckShortMana(TSkillInstance& rkSkillInst, CPythonSkill::TSkillData& rkSkillData)
+{
+	extern const DWORD c_iSkillIndex_Summon;
+	if (c_iSkillIndex_Summon == rkSkillInst.dwIndex)
+		return false;
+
+	int iNeedSP = rkSkillData.GetNeedSP(rkSkillInst.fcurEfficientPercentage);
+	int icurSP = GetStatus(POINT_SP);
+
+	// NOTE : ToggleSkill 이 아닌데 소모 SP 가 0 이다.
+	if (!rkSkillData.IsToggleSkill())
+	{
+		if (iNeedSP == 0)
+		{
+			CPythonChat::Instance().AppendChat(CHAT_TYPE_INFO, "!!! Find strange game data. Please reinstall metin2.");
+			return true;
+		}
+	}
+
+	if (rkSkillData.CanUseIfNotEnough())
+	{
+		if (icurSP <= 0)
+			return true;
+	}
+	else
+	{
+		if (-1 != iNeedSP)
+			if (iNeedSP > icurSP)
+				return true;
+	}
+
+	return false;
+}
+
+bool CPythonPlayer::__CheckShortLife(TSkillInstance& rkSkillInst, CPythonSkill::TSkillData& rkSkillData)
+{
+	if (!rkSkillData.IsUseHPSkill())
+		return false;
+	
+	DWORD dwNeedHP = rkSkillData.GetNeedSP(rkSkillInst.fcurEfficientPercentage);
+	if (dwNeedHP <= GetStatus(POINT_HP))
+		return false;
+
+	return true;
+}
+
+bool CPythonPlayer::__CheckRestSkillCoolTime(DWORD dwSlotIndex)
+{
+	if (!m_sysIsCoolTime)
+		return false;
+
+	if (dwSlotIndex >= SKILL_MAX_NUM)
+		return false;
+
+	float fElapsedTime = CTimer::Instance().GetCurrentSecond() - m_playerStatus.aSkill[dwSlotIndex].fLastUsedTime;
+	if (fElapsedTime >= m_playerStatus.aSkill[dwSlotIndex].fCoolTime)
+		return false;	
+
+	return true;
+}
+
+bool CPythonPlayer::__CheckDashAffect(CInstanceBase& rkInstMain)
+{
+	return rkInstMain.IsAffect(CInstanceBase::AFFECT_DASH);
+}
+
+void CPythonPlayer::__UseCurrentSkill()
+{
+	__UseSkill(m_dwcurSkillSlotIndex);
+}
+
+DWORD CPythonPlayer::__GetSkillTargetRange(CPythonSkill::TSkillData& rkSkillData)
+{
+	return rkSkillData.GetTargetRange() + GetStatus(POINT_BOW_DISTANCE)*100;
+}
+
+bool CPythonPlayer::__ProcessEnemySkillTargetRange(CInstanceBase& rkInstMain, CInstanceBase& rkInstTarget, CPythonSkill::TSkillData& rkSkillData, DWORD dwSkillSlotIndex)
+{
+	DWORD dwSkillTargetRange=__GetSkillTargetRange(rkSkillData);
+	float fSkillTargetRange = float(dwSkillTargetRange);
+	if (fSkillTargetRange <= 0.0f)
+		return true;
+
+	// #0000806: [M2EU] 수룡에게 무사(나한군) 탄환격 스킬 사용 안됨	
+	float fTargetDistance = rkInstMain.GetDistance(&rkInstTarget);
+
+	extern bool IS_HUGE_RACE(unsigned int vnum);
+	if (IS_HUGE_RACE(rkInstTarget.GetRace()))
+	{
+		fTargetDistance -= 200.0f; // TEMP: 일단 하드 코딩 처리. 정석적으로는 바운드 스피어를 고려해야함
+	}
+
+	if (fTargetDistance >= fSkillTargetRange)
+	{
+		if (rkSkillData.IsChargeSkill())
+		{
+			if (!__IsReservedUseSkill(dwSkillSlotIndex))
+				__SendUseSkill(dwSkillSlotIndex, 0);
+		}
+
+		__ReserveUseSkill(rkInstTarget.GetVirtualID(), dwSkillSlotIndex, dwSkillTargetRange);
+
+		return false;
+	}
+
+	// 2004.07.05.myevan. 궁신탄영 사용시 맵에 끼임. 사용하기전 갈수 있는곳 체크
+	TPixelPosition kPPosTarget;
+	rkInstTarget.NEW_GetPixelPosition(&kPPosTarget);
+
+	IBackground& rkBG=IBackground::Instance();
+	if (rkBG.IsBlock(kPPosTarget.x, kPPosTarget.y))
+	{
+		PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "CANNOT_APPROACH"));
+		return false;
+	}
+
+	return true;
+}
+
+bool CPythonPlayer::__CanUseSkill()
+{
+	CInstanceBase* pkInstMain=NEW_GetMainActorPtr();
+	if (!pkInstMain)
+		return false;
+
+	if (IsObserverMode())
+		return false;
+
+	// Fix me
+	// 뉴마운트. 승마스킬레벨 20 미만인 경우, 고급 마운트를 타고 승마 관련 스킬 못 쓰도록 못하도록 하드 코딩... 
+	// 나중에 시간 나면 can use skill 체크를 서버에서 해주자...
+	if (pkInstMain->IsMountingHorse() && (GetSkillGrade(109) < 1 && GetSkillLevel(109) < 20))
+	{
+		return false;
+	}
+
+	return pkInstMain->CanUseSkill();
+}
+
+
+bool CPythonPlayer::__UseSkill(DWORD dwSlotIndex)
+{
+	// PrivateShop
+	if (IsOpenPrivateShop())
+	{
+		return true;
+	}
+
+	if (!__CanUseSkill())
+	{
+		return false;
+	}
+
+	if (dwSlotIndex >= SKILL_MAX_NUM)
+	{
+		Tracenf("CPythonPlayer::__UseSkill(dwSlotIndex=%d) It's not available skill slot number", dwSlotIndex);
+		return false;
+	}
+
+	TSkillInstance & rkSkillInst = m_playerStatus.aSkill[dwSlotIndex];
+
+	if (__CheckSpecialSkill(rkSkillInst.dwIndex))
+	{
+		return true;
+	}
+
+	CPythonSkill::TSkillData * pSkillData;
+	if (!CPythonSkill::Instance().GetSkillData(rkSkillInst.dwIndex, &pSkillData))
+	{
+		Tracenf("CPythonPlayer::__UseSkill(dwSlotIndex=%d) There is no skill data", dwSlotIndex);
+		return false;
+	}
+
+	if (pSkillData->IsToggleSkill())
+	{
+		if (IsSkillActive(dwSlotIndex))
+		{
+			CPythonNetworkStream::Instance().SendUseSkillPacket(rkSkillInst.dwIndex, dwSlotIndex);
+			return false;
+		}
+	}
+
+	if (!__CheckSkillUsable(dwSlotIndex))
+	{
+		return false;
+	}
+
+	CInstanceBase * pkInstMain = NEW_GetMainActorPtr();
+	if (!pkInstMain)
+	{
+		Tracenf("CPythonPlayer::__UseSkill(dwSlotIndex=%d) There is no main player", dwSlotIndex);
+		return false;
+	}
+
+	if (pkInstMain->IsUsingSkill())
+	{
+		return false;
+	}
+
+	CInstanceBase * pkInstTarget = NULL;
+
+	// NOTE : 타겟이 필요한 경우
+	if (pSkillData->IsNeedTarget() ||
+		pSkillData->CanChangeDirection() ||
+		pSkillData->IsAutoSearchTarget())
+	{
+		if (pSkillData->IsNeedCorpse())
+			pkInstTarget=__GetDeadTargetInstancePtr();
+		else
+			pkInstTarget=__GetAliveTargetInstancePtr();
+
+		// 현재 타겟이 없으면..
+		if (!pkInstTarget)
+		{
+			// 업데이트하고..
+			__ChangeTargetToPickedInstance();
+
+			// 다시 얻어낸다.
+			if (pSkillData->IsNeedCorpse())
+				pkInstTarget=__GetDeadTargetInstancePtr();
+			else
+				pkInstTarget=__GetAliveTargetInstancePtr();
+		}
+
+		if (pkInstTarget)
+		{
+			if (pSkillData->IsOnlyForAlliance())
+			{
+				if (pkInstMain == pkInstTarget)
+				{
+					if (!pSkillData->CanUseForMe())
+					{
+						PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "CANNOT_USE_SELF"));
+						return false;
+					}
+				}
+				else if (!pkInstMain->IsAttackableInstance(*pkInstTarget) && pkInstTarget->IsPC())
+				{
+					DWORD dwSkillRange = __GetSkillTargetRange(*pSkillData);
+
+					if (dwSkillRange > 0)
+					{
+						float fDistance=pkInstMain->GetDistance(pkInstTarget);
+						if (fDistance>=float(dwSkillRange))
+						{
+							__ReserveUseSkill(pkInstTarget->GetVirtualID(), dwSlotIndex, dwSkillRange);
+							return false;
+						}
+					}
+				}
+				else
+				{
+					if (pSkillData->CanUseForMe())
+					{
+						pkInstTarget = pkInstMain;
+						Tracef(" [ALERT] \265\277\267\341\277\241\260\324 \273\347\277\353\307\317\264\302 \261\342\274\372\300\323\277\241\265\265 \300\373\277\241\260\324 \305\270\260\331\306\303 \265\307\276\356\300\326\276\356\274\255 \300\332\275\305\277\241\260\324\267\316 \300\347\274\263\301\244\n");
+					}
+					else
+					{
+						PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "ONLY_FOR_ALLIANCE"));
+						return false;
+					}
+				}
+			}
+			else
+			{
+				if (pkInstTarget->IsInSafe())
+				{
+					PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "CANNOT_ATTACK_ENEMY_IN_SAFE_AREA"));
+					return false;
+				}
+
+				if (pkInstMain->IsAttackableInstance(*pkInstTarget))
+				{
+					if (!__ProcessEnemySkillTargetRange(*pkInstMain, *pkInstTarget, *pSkillData, dwSlotIndex))
+						return false;
+				}
+				else
+				{
+					PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "CANNOT_ATTACK"));
+					return false;
+				}
+			}
+
+			pkInstMain->SetFlyTargetInstance(*pkInstTarget);
+
+			if (pkInstMain != pkInstTarget)
+			{
+				if (pkInstMain->IsFlyTargetObject())
+				{
+					pkInstMain->NEW_LookAtFlyTarget();
+				}
+				else
+				{
+					pkInstMain->NEW_LookAtDestInstance(*pkInstTarget);
+				}
+			}
+		}
+		else
+		{
+			if (pSkillData->IsAutoSearchTarget())
+			{
+				if (pkInstMain->NEW_GetFrontInstance(&pkInstTarget, 2000.0f))
+				{
+					SetTarget(pkInstTarget->GetVirtualID());
+					if (!__ProcessEnemySkillTargetRange(*pkInstMain, *pkInstTarget, *pSkillData, dwSlotIndex))
+						return false;
+				}
+				else
+				{
+					PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "NEED_TARGET"));
+					return false;
+				}
+			}
+
+			if (pSkillData->CanUseForMe())
+			{
+				pkInstTarget = pkInstMain;
+				pkInstMain->SetFlyTargetInstance(*pkInstMain);
+				Tracef(" [ALERT] \305\270\260\331\300\314 \276\370\276\356\274\255 \307\303\267\271\300\314\276\356\277\241\260\324 \273\347\277\353\307\325\264\317\264\331\n");
+			}
+			else if (pSkillData->IsNeedCorpse())
+			{
+				PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "ONLY_FOR_CORPSE"));
+				return false;
+			}
+			else
+			{
+				PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "NEED_TARGET"));
+				return false;
+			}
+		}
+	}
+
+	if (pSkillData->CanChangeDirection())
+	{
+		DWORD dwPickedActorID;
+		TPixelPosition kPPosPickedGround;
+
+		if (pkInstTarget && pkInstTarget!=pkInstMain)
+		{
+			pkInstMain->NEW_LookAtDestInstance(*pkInstTarget);
+		}
+		else if (__GetPickedActorID(&dwPickedActorID))
+		{
+			CInstanceBase* pkInstVictim=NEW_FindActorPtr(dwPickedActorID);
+			if (pkInstVictim)
+				pkInstMain->NEW_LookAtDestInstance(*pkInstVictim);
+		}
+		else if (__GetPickedGroundPos(&kPPosPickedGround))
+		{
+			pkInstMain->NEW_LookAtDestPixelPosition(kPPosPickedGround);
+		}
+		else
+		{
+			Tracenf("CPythonPlayer::__UseSkill(%d) - \310\255\270\351 \261\342\301\330 \271\346\307\342 \274\263\301\244\300\273 \307\330\276\337\307\324", dwSlotIndex);
+		}
+	}
+
+	// 관격술 처리
+	DWORD dwTargetMaxCount = pSkillData->GetTargetCount(rkSkillInst.fcurEfficientPercentage);
+	DWORD dwRange = __GetSkillTargetRange(*pSkillData);
+	if (dwTargetMaxCount>0 && pkInstTarget)
+	{
+		DWORD dwTargetCount=1;
+		std::vector<CInstanceBase*> kVct_pkInstTarget;
+
+		if (pSkillData->IsFanRange())
+		{
+			if (pkInstMain->NEW_GetInstanceVectorInFanRange(float(dwRange), *pkInstTarget, &kVct_pkInstTarget))
+			{
+				std::vector<CInstanceBase*>::iterator i;
+				for (i=kVct_pkInstTarget.begin(); i!=kVct_pkInstTarget.end(); ++i)
+				{
+					if (dwTargetCount>=dwTargetMaxCount)
+						break;
+
+					CInstanceBase* pkInstEach=*i;
+
+					if (pkInstTarget!=pkInstEach && !pkInstEach->IsDead())
+					{
+						pkInstMain->AddFlyTargetInstance(*pkInstEach);
+						CPythonNetworkStream::Instance().SendAddFlyTargetingPacket(pkInstEach->GetVirtualID(), pkInstEach->GetGraphicThingInstanceRef().OnGetFlyTargetPosition());
+
+						dwTargetCount++;
+					}
+				}
+			}
+		}
+		else if (pSkillData->IsCircleRange())
+		{
+			if (pkInstMain->NEW_GetInstanceVectorInCircleRange(float(dwRange), &kVct_pkInstTarget))
+			{
+				std::vector<CInstanceBase*>::iterator i;
+				for (i=kVct_pkInstTarget.begin(); i!=kVct_pkInstTarget.end(); ++i)
+				{
+					if (dwTargetCount>=dwTargetMaxCount)
+						break;
+
+					CInstanceBase* pkInstEach=*i;
+
+					if (pkInstTarget!=pkInstEach && !pkInstEach->IsDead())
+					{
+						pkInstMain->AddFlyTargetInstance(*pkInstEach);
+						CPythonNetworkStream::Instance().SendAddFlyTargetingPacket(pkInstEach->GetVirtualID(), pkInstEach->GetGraphicThingInstanceRef().OnGetFlyTargetPosition());
+
+						dwTargetCount++;
+					}
+				}
+			}
+		}
+
+		if (dwTargetCount<dwTargetMaxCount)
+		{
+			while (dwTargetCount<dwTargetMaxCount)
+			{
+				TPixelPosition kPPosDst;
+				pkInstMain->NEW_GetRandomPositionInFanRange(*pkInstTarget, &kPPosDst);
+
+				kPPosDst.x=kPPosDst.x;
+				kPPosDst.y=-kPPosDst.y;
+
+				pkInstMain->AddFlyTargetPosition(kPPosDst);
+				CPythonNetworkStream::Instance().SendAddFlyTargetingPacket(0, kPPosDst);
+
+				dwTargetCount++;
+			}
+		}
+	}
+
+	/////
+	// NOTE : 멀리서 적을 클릭해놓고 스킬을 쓰면 스킬을 쓴뒤 바로 적을 공격하는 문제를 수정하기 위한 코드 - [levites]
+	__ClearReservedAction();
+	/////
+
+	if (!pSkillData->IsNoMotion())
+	{
+		DWORD dwMotionIndex = pSkillData->GetSkillMotionIndex(rkSkillInst.iGrade);
+		DWORD dwLoopCount = pSkillData->GetMotionLoopCount(rkSkillInst.fcurEfficientPercentage);
+		if (!pkInstMain->NEW_UseSkill(rkSkillInst.dwIndex, dwMotionIndex, dwLoopCount, pSkillData->IsMovingSkill() ? true : false))
+		{
+			Tracenf("CPythonPlayer::__UseSkill(%d) - pkInstMain->NEW_UseSkill - ERROR", dwSlotIndex);
+			return false;
+		}
+	}
+
+	DWORD dwTargetVID=pkInstTarget ? pkInstTarget->GetVirtualID() : 0;
+
+	__SendUseSkill(dwSlotIndex, dwTargetVID);
+	return true;
+}
+
+void CPythonPlayer::__SendUseSkill(DWORD dwSkillSlotIndex, DWORD dwTargetVID)
+{
+	TSkillInstance & rkSkillInst = m_playerStatus.aSkill[dwSkillSlotIndex];
+
+	CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
+	rkNetStream.SendUseSkillPacket(rkSkillInst.dwIndex, dwTargetVID);
+
+	__RunCoolTime(dwSkillSlotIndex);
+}
+
+BYTE CPythonPlayer::__GetSkillType(DWORD dwSkillSlotIndex)
+{
+	TSkillInstance & rkSkillInst = m_playerStatus.aSkill[dwSkillSlotIndex];
+
+	CPythonSkill::TSkillData * pkSkillData;
+	CPythonSkill& rkPythonSkill = CPythonSkill::Instance();
+	if (!rkPythonSkill.GetSkillData(rkSkillInst.dwIndex, &pkSkillData))
+	{
+		//TraceError("CPythonPlayer::__GetSkillType(dwSkillSlotIndex=%d) - NOT CHECK", dwSkillSlotIndex);
+		return 0;
+	}
+	return pkSkillData->GetType();
+}
+
+void CPythonPlayer::__RunCoolTime(DWORD dwSkillSlotIndex)
+{
+	TSkillInstance & rkSkillInst = m_playerStatus.aSkill[dwSkillSlotIndex];
+
+	CPythonSkill::TSkillData * pkSkillData;
+	if (!CPythonSkill::Instance().GetSkillData(rkSkillInst.dwIndex, &pkSkillData))
+	{
+		TraceError("CPythonPlayer::__SendUseSkill(dwSkillSlotIndex=%d) - NOT CHECK", dwSkillSlotIndex);
+		return;
+	}
+
+	CPythonSkill::TSkillData& rkSkillData=*pkSkillData;
+
+	rkSkillInst.fCoolTime = rkSkillData.GetSkillCoolTime(rkSkillInst.fcurEfficientPercentage);
+	rkSkillInst.fLastUsedTime = CTimer::Instance().GetCurrentSecond();
+
+	int iSpd = 100 - GetStatus(POINT_CASTING_SPEED);
+	if (iSpd > 0)
+		iSpd = 100 + iSpd;
+	else if (iSpd < 0)
+		iSpd = 10000 / (100 - iSpd);
+	else
+		iSpd = 100;
+
+	rkSkillInst.fCoolTime = rkSkillInst.fCoolTime * iSpd / 100;
+
+	PyCallClassMemberFunc(m_ppyGameWindow, "RunUseSkillEvent", Py_BuildValue("(if)", dwSkillSlotIndex, rkSkillInst.fCoolTime));
+}
+
+bool CPythonPlayer::__HasEnoughArrow()
+{
+	CItemData * pItemData;
+	if (CItemManager::Instance().GetItemDataPointer(GetItemIndex(TItemPos(INVENTORY, c_Equipment_Arrow)), &pItemData))
+	if (CItemData::ITEM_TYPE_WEAPON == pItemData->GetType())
+	if (CItemData::WEAPON_ARROW == pItemData->GetSubType())
+	{
+		return true;
+	}
+
+	PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotShotError", Py_BuildValue("(is)", GetMainCharacterIndex(), "EMPTY_ARROW"));
+	return false;
+}
+
+bool CPythonPlayer::__HasItem(DWORD dwItemID)
+{
+	for (int i = 0; i < c_Inventory_Count; ++i)
+	{
+		if (dwItemID == GetItemIndex(TItemPos (INVENTORY, i)))
+			return true;
+	}
+	for (int i = 0; i < c_DragonSoul_Inventory_Count; ++i)
+	{
+		if (dwItemID == GetItemIndex(TItemPos (DRAGON_SOUL_INVENTORY, i)))
+			return true;
+	}
+
+	return false;
+}
+
+extern const DWORD c_iSkillIndex_Tongsol;
+extern const DWORD c_iSkillIndex_Fishing;
+extern const DWORD c_iSkillIndex_Mining;
+extern const DWORD c_iSkillIndex_Making;
+extern const DWORD c_iSkillIndex_Combo;
+extern const DWORD c_iSkillIndex_Language1;
+extern const DWORD c_iSkillIndex_Language2;
+extern const DWORD c_iSkillIndex_Language3;
+extern const DWORD c_iSkillIndex_Polymorph;
+
+void CPythonPlayer::UseGuildSkill(DWORD dwSkillSlotIndex)
+{
+	CInstanceBase* pkInstMain = NEW_GetMainActorPtr();
+	if (!pkInstMain)
+		return;
+	if (!pkInstMain->CanUseSkill())
+		return;
+
+	///////////////////////////////////////////////////////////////////////////////////////////////
+
+	if (dwSkillSlotIndex >= SKILL_MAX_NUM)
+	{
+		Tracenf("CPythonPlayer::UseGuildSkill(dwSkillSlotIndex=%d) It's not available skill slot number", dwSkillSlotIndex);
+		return;
+	}
+
+	TSkillInstance & rkSkillInst = m_playerStatus.aSkill[dwSkillSlotIndex];
+
+	DWORD dwSkillIndex = rkSkillInst.dwIndex;
+
+	CPythonSkill::TSkillData * pSkillData;
+	if (!CPythonSkill::Instance().GetSkillData(dwSkillIndex, &pSkillData))
+		return;
+
+	if (__CheckRestSkillCoolTime(dwSkillSlotIndex))
+	{
+		PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "WAIT_COOLTIME"));
+		return;
+	}
+
+	if (pSkillData->IsOnlyForGuildWar())
+	{
+		if (!CPythonGuild::Instance().IsDoingGuildWar())
+		{
+			PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "ONLY_FOR_GUILD_WAR"));
+			return;
+		}
+	}
+
+	DWORD dwMotionIndex = pSkillData->GetSkillMotionIndex();
+	if (!pkInstMain->NEW_UseSkill(dwSkillIndex, dwMotionIndex, 1, false))
+	{
+		Tracenf("CPythonPlayer::UseGuildSkill(%d) - pkInstMain->NEW_UseSkill - ERROR", dwSkillIndex);
+	}
+
+	///////////////////////////////////////////////////////////////////////////////////////////////
+
+	CPythonNetworkStream::Instance().SendGuildUseSkillPacket(dwSkillIndex, 0);
+	__RunCoolTime(dwSkillSlotIndex);
+}
+
+void CPythonPlayer::SetComboSkillFlag(BOOL bFlag)
+{
+	DWORD dwSlotIndex;
+	if (!GetSkillSlotIndex(c_iSkillIndex_Combo, &dwSlotIndex))
+	{
+		Tracef("CPythonPlayer::SetComboSkillFlag(killIndex=%d) - Can't Find Slot Index\n", c_iSkillIndex_Combo);
+		return;
+	}
+
+	int iLevel = GetSkillLevel(dwSlotIndex);
+	if (iLevel <= 0)
+	{
+		Tracef("CPythonPlayer::SetComboSkillFlag(skillIndex=%d, skillLevel=%d) - Invalid Combo Skill Level\n", c_iSkillIndex_Combo, iLevel);
+		return;
+	}
+
+	iLevel = MIN(iLevel, 2);
+
+	CInstanceBase* pkInstMain = NEW_GetMainActorPtr();
+	if (!pkInstMain)
+		return;
+
+	if (bFlag)
+	{
+		pkInstMain->SetComboType(iLevel);
+		__ActivateSkillSlot(dwSlotIndex);
+	}
+	else
+	{
+		pkInstMain->SetComboType(0);
+		__DeactivateSkillSlot(dwSlotIndex);
+	}
+}
+
+bool CPythonPlayer::__CheckSpecialSkill(DWORD dwSkillIndex)
+{
+	CInstanceBase* pkInstMain = NEW_GetMainActorPtr();
+	if (!pkInstMain)
+		return false;
+
+	// Fishing
+	if (c_iSkillIndex_Fishing == dwSkillIndex)
+	{
+		if (pkInstMain->IsFishingMode())
+		{
+			NEW_Fishing();
+		}
+		else
+		{
+			PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "EQUIP_FISHING_ROD"));
+		}
+		return true;
+	}
+
+	// Combo
+	else if (c_iSkillIndex_Combo == dwSkillIndex)
+	{
+		DWORD dwSlotIndex;
+		if (!GetSkillSlotIndex(dwSkillIndex, &dwSlotIndex))
+			return false;
+
+		int iLevel = GetSkillLevel(dwSlotIndex);
+		if (iLevel > 0)
+		{
+			CPythonNetworkStream::Instance().SendUseSkillPacket(dwSkillIndex);
+		}
+		else
+		{
+			PyCallClassMemberFunc(m_ppyGameWindow, "OnCannotUseSkill", Py_BuildValue("(is)", GetMainCharacterIndex(), "NOT_YET_LEARN"));
+		}
+
+		return true;
+	}
+
+	return false;
+}

extension/src/port/UserInterface/StdAfx.h

@@ -46,5 +46,6 @@ void initpack();
 void initapp();
 void initchr();
 void initchrmgr();
+void initPlayer();
 void initChat();
 void initnet();

extension/tests/port_login_flow_server.cpp

@@ -509,9 +509,46 @@ bool FakeLoginServer::ServeGame(Connection& c, int index)
 		return Fail(name + ": CG_PONG after the entergame burst: " + error);
 	Event(name + ":burst_pong");
 
-	// Hold the connection until the test stops us.
-	std::uint8_t byte = 0;
-	while (!m_stop && c.Read(&byte, 1) == 1)
-		;
-	return true;
+	// Then hold the connection until the test stops us, reading what the game phase sends the way
+	// CInputProcessor::Process frames it (static size or TDynamicSizePacketHeader, then the sequence
+	// byte). A CG_MOVE (input_main.cpp CInputMain::Move) becomes "<name>:move <func> <arg> <rot> <x> <y>".
+	for (;;)
+	{
+		std::uint8_t packet[1024] = {};
+		if (c.Read(packet, 1) != 1)
+			return true;
+		const std::uint8_t header = packet[0];
+		size_t size = static_cast<size_t>(packet_size_cg(header));
+		if (is_dynamic_cg(header) || header == HDR_CG_SYNC_POSITION)
+		{
+			if (c.Read(packet + 1, sizeof(DynHead) - 1) != 1)
+				return true;
+			DynHead head;
+			std::memcpy(&head, packet, sizeof(head));
+			size = head.size;
+			if (size < sizeof(DynHead) || size > sizeof(packet) ||
+				(size > sizeof(DynHead) && c.Read(packet + sizeof(DynHead), size - sizeof(DynHead)) != 1))
+				return Fail(name + ": dynamic CG packet " + std::to_string(header) + " in the game phase");
+		}
+		else if (size == 0 || size > sizeof(packet))
+			return Fail(name + ": unknown CG header " + std::to_string(header) + " in the game phase");
+		else if (size > 1 && c.Read(packet + 1, size - 1) != 1)
+			return true;
+		if (is_sequence_cg(header))
+		{
+			std::uint8_t sequence = 0;
+			if (c.Read(&sequence, 1) != 1)
+				return true;
+			if (sequence != SEQUENCE_TABLE[c.sequence])
+				return Fail(name + ": SEQUENCE mismatch on CG header " + std::to_string(header));
+			c.sequence = (c.sequence + 1) % SEQUENCE_TABLE_SIZE;
+		}
+		if (header == HDR_CG_MOVE)
+		{
+			CGMove move;
+			std::memcpy(&move, packet, sizeof(move));
+			Event(name + ":move " + std::to_string(move.func) + " " + std::to_string(move.arg) + " " +
+				  std::to_string(move.rot) + " " + std::to_string(move.x) + " " + std::to_string(move.y));
+		}
+	}
 }

extension/tests/port_login_flow_test.cpp

@@ -377,6 +377,42 @@ int main(int argc, char** argv)
 			return false;
 		};
 		CHECK(pump_until(3, character_draw));
+
+		// 7. (批次 2V3) Keyboard movement through the original path: the key reaches game.GameWindow's
+		//    onPressKeyDict, MoveUp calls player.SetSingleDIKKeyState(DIK_UP, True), CPythonPlayer turns
+		//    it into NEW_MoveToDirection on the main instance, and CPythonPlayerEventHandler::OnMove sends
+		//    CG_MOVE FUNC_MOVE. Releasing the key stops the actor (OnStop: FUNC_WAIT at the new position).
+		TPixelPosition start = {};
+		if (main_instance)
+			main_instance->NEW_GetPixelPosition(&start);
+		auto walked = [&] {
+			TPixelPosition now = {};
+			main_instance->NEW_GetPixelPosition(&now);
+			return std::hypot(now.x - start.x, now.y - start.y);
+		};
+		PythonBoot::UIKey(DIK_UP, true);
+		CHECK(main_instance && pump_until(3, [&] { return walked() > 100.0f; }));
+		PythonBoot::UIKey(DIK_UP, false);
+		CHECK(main_instance && pump_until(2, [&] { return !main_instance->IsWalking(); }));
+		const float distance = main_instance ? walked() : 0.0f;
+		std::printf("port_login_flow_test: DIK_UP walked %.0f cm\n", distance);
+		if (server)
+		{
+			// The fake server records "game2:move <func> <arg> <rot> <x> <y>"; x, y are the TPixelPosition
+			// (y negated back, as SendCharacterStatePacket does) plus the map base the server gave.
+			auto moves = [&] {
+				std::vector<std::string> out;
+				for (const auto& e : server->Events())
+					if (e.rfind("game2:move ", 0) == 0)
+						out.push_back(e);
+				return out;
+			};
+			CHECK(pump_until(2, [&] { auto m = moves(); return m.size() >= 2 && m.back().rfind("game2:move 0 ", 0) == 0; }));
+			const auto m = moves();
+			CHECK(!m.empty() && m.front().rfind("game2:move 1 0 ", 0) == 0);
+			for (const auto& e : m)
+				std::printf("port_login_flow_test: %s\n", e.c_str());
+		}
 	}
 	if (server)
 	{
@@ -394,7 +430,7 @@ int main(int argc, char** argv)
 				if (e.rfind(prefix, 0) == 0)
 					want.push_back(e);
 			for (const auto& e : events)
-				if (e.rfind(prefix, 0) == 0)
+				if (e.rfind(prefix, 0) == 0 && e.find(":move ") == std::string::npos)
 					got.push_back(e);
 			CHECK(want == got);
 		}