2V1-b/c: PythonNetworkStream phases, AccountConnector and the net module

Port PythonNetworkStream with its HandShake/Login/Select/Loading/Offline
phases, AccountConnector and PythonNetworkStreamModule verbatim; the net
stub goes. PythonBoot creates the network stream, account connector,
player, flying manager and effect manager like CPythonApplication, and
app.Create/Process drive CNetworkDevice and both connectors.

Packet.h long fields become 32-bit LONG; port.packet checks 38
login/select/loading packet sizes against wire_classic.h. Unported units
in the link closure live under platform/pending/ as stand-ins. The macOS
gate now builds all and finds iconv.

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

extension/src/platform/ScriptLib/GameplayModules.cpp

@@ -869,262 +869,6 @@ PyMethodDef methods_miniMap[] = {
 };
 const char* ints_miniMap[] = {"TYPE_OPC", "TYPE_OPCPVP", "TYPE_OPCPVPSELF", "TYPE_NPC", "TYPE_MONSTER", "TYPE_WARP", "TYPE_WAYPOINT", "TYPE_PARTY", "TYPE_EMPIRE", NULL};
 const char* strings_miniMap[] = {NULL};
-// 40250 UserInterface/PythonNetworkStreamModule.cpp: net export names.
-PyObject* stub_net_GetBettingGuildWarValue(PyObject*, PyObject*) { return stub_call_named("net.GetBettingGuildWarValue"); }
-PyObject* stub_net_EnableChatInsultFilter(PyObject*, PyObject*) { return stub_call_named("net.EnableChatInsultFilter"); }
-PyObject* stub_net_SetServerInfo(PyObject*, PyObject*) { return stub_call_named("net.SetServerInfo"); }
-PyObject* stub_net_GetServerInfo(PyObject*, PyObject*) { return stub_call_named("net.GetServerInfo"); }
-PyObject* stub_net_PreserveServerCommand(PyObject*, PyObject*) { return stub_call_named("net.PreserveServerCommand"); }
-PyObject* stub_net_GetPreservedServerCommand(PyObject*, PyObject*) { return stub_call_named("net.GetPreservedServerCommand"); }
-PyObject* stub_net_StartGame(PyObject*, PyObject*) { return stub_call_named("net.StartGame"); }
-PyObject* stub_net_Warp(PyObject*, PyObject*) { return stub_call_named("net.Warp"); }
-PyObject* stub_net_IsTest(PyObject*, PyObject*) { return stub_call_named("net.IsTest"); }
-PyObject* stub_net_SetMarkServer(PyObject*, PyObject*) { return stub_call_named("net.SetMarkServer"); }
-PyObject* stub_net_IsChatInsultIn(PyObject*, PyObject*) { return stub_call_named("net.IsChatInsultIn"); }
-PyObject* stub_net_IsInsultIn(PyObject*, PyObject*) { return stub_call_named("net.IsInsultIn"); }
-PyObject* stub_net_LoadInsultList(PyObject*, PyObject*) { return stub_call_named("net.LoadInsultList"); }
-PyObject* stub_net_UploadMark(PyObject*, PyObject*) { return stub_call_named("net.UploadMark"); }
-PyObject* stub_net_UploadSymbol(PyObject*, PyObject*) { return stub_call_named("net.UploadSymbol"); }
-PyObject* stub_net_GetGuildID(PyObject*, PyObject*) { return stub_call_named("net.GetGuildID"); }
-PyObject* stub_net_GetEmpireID(PyObject*, PyObject*) { return stub_call_named("net.GetEmpireID"); }
-PyObject* stub_net_GetMainActorVID(PyObject*, PyObject*) { return stub_call_named("net.GetMainActorVID"); }
-PyObject* stub_net_GetMainActorRace(PyObject*, PyObject*) { return stub_call_named("net.GetMainActorRace"); }
-PyObject* stub_net_GetMainActorEmpire(PyObject*, PyObject*) { return stub_call_named("net.GetMainActorEmpire"); }
-PyObject* stub_net_GetMainActorSkillGroup(PyObject*, PyObject*) { return stub_call_named("net.GetMainActorSkillGroup"); }
-PyObject* stub_net_GetAccountCharacterSlotDataInteger(PyObject*, PyObject*) { return stub_call_named("net.GetAccountCharacterSlotDataInteger"); }
-PyObject* stub_net_GetAccountCharacterSlotDataString(PyObject*, PyObject*) { return stub_call_named("net.GetAccountCharacterSlotDataString"); }
-PyObject* stub_net_GetFieldMusicFileName(PyObject*, PyObject*) { return stub_call_named("net.GetFieldMusicFileName"); }
-PyObject* stub_net_GetFieldMusicVolume(PyObject*, PyObject*) { return stub_call_named("net.GetFieldMusicVolume"); }
-PyObject* stub_net_ToggleGameDebugInfo(PyObject*, PyObject*) { return stub_call_named("net.ToggleGameDebugInfo"); }
-PyObject* stub_net_SetLoginInfo(PyObject*, PyObject*) { return stub_call_named("net.SetLoginInfo"); }
-PyObject* stub_net_SetPhaseWindow(PyObject*, PyObject*) { return stub_call_named("net.SetPhaseWindow"); }
-PyObject* stub_net_ClearPhaseWindow(PyObject*, PyObject*) { return stub_call_named("net.ClearPhaseWindow"); }
-PyObject* stub_net_SetServerCommandParserWindow(PyObject*, PyObject*) { return stub_call_named("net.SetServerCommandParserWindow"); }
-PyObject* stub_net_SetAccountConnectorHandler(PyObject*, PyObject*) { return stub_call_named("net.SetAccountConnectorHandler"); }
-PyObject* stub_net_SetHandler(PyObject*, PyObject*) { return stub_call_named("net.SetHandler"); }
-PyObject* stub_net_SetTCPRecvBufferSize(PyObject*, PyObject*) { return stub_call_named("net.SetTCPRecvBufferSize"); }
-PyObject* stub_net_SetTCPSendBufferSize(PyObject*, PyObject*) { return stub_call_named("net.SetTCPSendBufferSize"); }
-PyObject* stub_net_SetUDPRecvBufferSize(PyObject*, PyObject*) { return stub_call_named("net.SetUDPRecvBufferSize"); }
-PyObject* stub_net_DirectEnter(PyObject*, PyObject*) { return stub_call_named("net.DirectEnter"); }
-PyObject* stub_net_LogOutGame(PyObject*, PyObject*) { return stub_call_named("net.LogOutGame"); }
-PyObject* stub_net_ExitGame(PyObject*, PyObject*) { return stub_call_named("net.ExitGame"); }
-PyObject* stub_net_ExitApplication(PyObject*, PyObject*) { return stub_call_named("net.ExitApplication"); }
-PyObject* stub_net_ConnectTCP(PyObject*, PyObject*) { return stub_call_named("net.ConnectTCP"); }
-PyObject* stub_net_ConnectUDP(PyObject*, PyObject*) { return stub_call_named("net.ConnectUDP"); }
-PyObject* stub_net_ConnectToAccountServer(PyObject*, PyObject*) { return stub_call_named("net.ConnectToAccountServer"); }
-PyObject* stub_net_SendLoginPacket(PyObject*, PyObject*) { return stub_call_named("net.SendLoginPacket"); }
-PyObject* stub_net_SendChinaMatrixCardPacket(PyObject*, PyObject*) { return stub_call_named("net.SendChinaMatrixCardPacket"); }
-PyObject* stub_net_SendRunupMatrixCardPacket(PyObject*, PyObject*) { return stub_call_named("net.SendRunupMatrixCardPacket"); }
-PyObject* stub_net_SendNEWCIBNPasspodAnswerPacket(PyObject*, PyObject*) { return stub_call_named("net.SendNEWCIBNPasspodAnswerPacket"); }
-PyObject* stub_net_SendSelectEmpirePacket(PyObject*, PyObject*) { return stub_call_named("net.SendSelectEmpirePacket"); }
-PyObject* stub_net_SendSelectCharacterPacket(PyObject*, PyObject*) { return stub_call_named("net.SendSelectCharacterPacket"); }
-PyObject* stub_net_SendChangeNamePacket(PyObject*, PyObject*) { return stub_call_named("net.SendChangeNamePacket"); }
-PyObject* stub_net_SendCreateCharacterPacket(PyObject*, PyObject*) { return stub_call_named("net.SendCreateCharacterPacket"); }
-PyObject* stub_net_SendDestroyCharacterPacket(PyObject*, PyObject*) { return stub_call_named("net.SendDestroyCharacterPacket"); }
-PyObject* stub_net_SendEnterGamePacket(PyObject*, PyObject*) { return stub_call_named("net.SendEnterGamePacket"); }
-PyObject* stub_net_SendItemUsePacket(PyObject*, PyObject*) { return stub_call_named("net.SendItemUsePacket"); }
-PyObject* stub_net_SendItemUseToItemPacket(PyObject*, PyObject*) { return stub_call_named("net.SendItemUseToItemPacket"); }
-PyObject* stub_net_SendItemDropPacket(PyObject*, PyObject*) { return stub_call_named("net.SendItemDropPacket"); }
-PyObject* stub_net_SendItemDropPacketNew(PyObject*, PyObject*) { return stub_call_named("net.SendItemDropPacketNew"); }
-PyObject* stub_net_SendElkDropPacket(PyObject*, PyObject*) { return stub_call_named("net.SendElkDropPacket"); }
-PyObject* stub_net_SendGoldDropPacketNew(PyObject*, PyObject*) { return stub_call_named("net.SendGoldDropPacketNew"); }
-PyObject* stub_net_SendItemMovePacket(PyObject*, PyObject*) { return stub_call_named("net.SendItemMovePacket"); }
-PyObject* stub_net_SendItemPickUpPacket(PyObject*, PyObject*) { return stub_call_named("net.SendItemPickUpPacket"); }
-PyObject* stub_net_SendGiveItemPacket(PyObject*, PyObject*) { return stub_call_named("net.SendGiveItemPacket"); }
-PyObject* stub_net_SetOfflinePhase(PyObject*, PyObject*) { return stub_call_named("net.SetOfflinePhase"); }
-PyObject* stub_net_Disconnect(PyObject*, PyObject*) { return stub_call_named("net.Disconnect"); }
-PyObject* stub_net_IsConnect(PyObject*, PyObject*) { return stub_call_named("net.IsConnect"); }
-PyObject* stub_net_SendChatPacket(PyObject*, PyObject*) { return stub_call_named("net.SendChatPacket"); }
-PyObject* stub_net_SendEmoticon(PyObject*, PyObject*) { return stub_call_named("net.SendEmoticon"); }
-PyObject* stub_net_SendWhisperPacket(PyObject*, PyObject*) { return stub_call_named("net.SendWhisperPacket"); }
-PyObject* stub_net_SendMobileMessagePacket(PyObject*, PyObject*) { return stub_call_named("net.SendMobileMessagePacket"); }
-PyObject* stub_net_SendCharacterPositionPacket(PyObject*, PyObject*) { return stub_call_named("net.SendCharacterPositionPacket"); }
-PyObject* stub_net_SendShopEndPacket(PyObject*, PyObject*) { return stub_call_named("net.SendShopEndPacket"); }
-PyObject* stub_net_SendShopBuyPacket(PyObject*, PyObject*) { return stub_call_named("net.SendShopBuyPacket"); }
-PyObject* stub_net_SendShopSellPacket(PyObject*, PyObject*) { return stub_call_named("net.SendShopSellPacket"); }
-PyObject* stub_net_SendShopSellPacketNew(PyObject*, PyObject*) { return stub_call_named("net.SendShopSellPacketNew"); }
-PyObject* stub_net_SendExchangeStartPacket(PyObject*, PyObject*) { return stub_call_named("net.SendExchangeStartPacket"); }
-PyObject* stub_net_SendExchangeItemAddPacket(PyObject*, PyObject*) { return stub_call_named("net.SendExchangeItemAddPacket"); }
-PyObject* stub_net_SendExchangeItemDelPacket(PyObject*, PyObject*) { return stub_call_named("net.SendExchangeItemDelPacket"); }
-PyObject* stub_net_SendExchangeElkAddPacket(PyObject*, PyObject*) { return stub_call_named("net.SendExchangeElkAddPacket"); }
-PyObject* stub_net_SendExchangeAcceptPacket(PyObject*, PyObject*) { return stub_call_named("net.SendExchangeAcceptPacket"); }
-PyObject* stub_net_SendExchangeExitPacket(PyObject*, PyObject*) { return stub_call_named("net.SendExchangeExitPacket"); }
-PyObject* stub_net_SendOnClickPacket(PyObject*, PyObject*) { return stub_call_named("net.SendOnClickPacket"); }
-PyObject* stub_net_RegisterEmoticonString(PyObject*, PyObject*) { return stub_call_named("net.RegisterEmoticonString"); }
-PyObject* stub_net_SendMessengerAddByVIDPacket(PyObject*, PyObject*) { return stub_call_named("net.SendMessengerAddByVIDPacket"); }
-PyObject* stub_net_SendMessengerAddByNamePacket(PyObject*, PyObject*) { return stub_call_named("net.SendMessengerAddByNamePacket"); }
-PyObject* stub_net_SendMessengerRemovePacket(PyObject*, PyObject*) { return stub_call_named("net.SendMessengerRemovePacket"); }
-PyObject* stub_net_SendPartyInvitePacket(PyObject*, PyObject*) { return stub_call_named("net.SendPartyInvitePacket"); }
-PyObject* stub_net_SendPartyInviteAnswerPacket(PyObject*, PyObject*) { return stub_call_named("net.SendPartyInviteAnswerPacket"); }
-PyObject* stub_net_SendPartyExitPacket(PyObject*, PyObject*) { return stub_call_named("net.SendPartyExitPacket"); }
-PyObject* stub_net_SendPartyRemovePacket(PyObject*, PyObject*) { return stub_call_named("net.SendPartyRemovePacket"); }
-PyObject* stub_net_SendPartySetStatePacket(PyObject*, PyObject*) { return stub_call_named("net.SendPartySetStatePacket"); }
-PyObject* stub_net_SendPartyUseSkillPacket(PyObject*, PyObject*) { return stub_call_named("net.SendPartyUseSkillPacket"); }
-PyObject* stub_net_SendPartyParameterPacket(PyObject*, PyObject*) { return stub_call_named("net.SendPartyParameterPacket"); }
-PyObject* stub_net_SendSafeboxSaveMoneyPacket(PyObject*, PyObject*) { return stub_call_named("net.SendSafeboxSaveMoneyPacket"); }
-PyObject* stub_net_SendSafeboxWithdrawMoneyPacket(PyObject*, PyObject*) { return stub_call_named("net.SendSafeboxWithdrawMoneyPacket"); }
-PyObject* stub_net_SendSafeboxCheckinPacket(PyObject*, PyObject*) { return stub_call_named("net.SendSafeboxCheckinPacket"); }
-PyObject* stub_net_SendSafeboxCheckoutPacket(PyObject*, PyObject*) { return stub_call_named("net.SendSafeboxCheckoutPacket"); }
-PyObject* stub_net_SendSafeboxItemMovePacket(PyObject*, PyObject*) { return stub_call_named("net.SendSafeboxItemMovePacket"); }
-PyObject* stub_net_SendMallCheckoutPacket(PyObject*, PyObject*) { return stub_call_named("net.SendMallCheckoutPacket"); }
-PyObject* stub_net_SendAnswerMakeGuildPacket(PyObject*, PyObject*) { return stub_call_named("net.SendAnswerMakeGuildPacket"); }
-PyObject* stub_net_SendQuestInputStringPacket(PyObject*, PyObject*) { return stub_call_named("net.SendQuestInputStringPacket"); }
-PyObject* stub_net_SendQuestConfirmPacket(PyObject*, PyObject*) { return stub_call_named("net.SendQuestConfirmPacket"); }
-PyObject* stub_net_SendGuildAddMemberPacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildAddMemberPacket"); }
-PyObject* stub_net_SendGuildRemoveMemberPacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildRemoveMemberPacket"); }
-PyObject* stub_net_SendGuildChangeGradeNamePacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildChangeGradeNamePacket"); }
-PyObject* stub_net_SendGuildChangeGradeAuthorityPacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildChangeGradeAuthorityPacket"); }
-PyObject* stub_net_SendGuildOfferPacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildOfferPacket"); }
-PyObject* stub_net_SendGuildPostCommentPacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildPostCommentPacket"); }
-PyObject* stub_net_SendGuildDeleteCommentPacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildDeleteCommentPacket"); }
-PyObject* stub_net_SendGuildRefreshCommentsPacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildRefreshCommentsPacket"); }
-PyObject* stub_net_SendGuildChangeMemberGradePacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildChangeMemberGradePacket"); }
-PyObject* stub_net_SendGuildUseSkillPacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildUseSkillPacket"); }
-PyObject* stub_net_SendGuildChangeMemberGeneralPacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildChangeMemberGeneralPacket"); }
-PyObject* stub_net_SendGuildInviteAnswerPacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildInviteAnswerPacket"); }
-PyObject* stub_net_SendGuildChargeGSPPacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildChargeGSPPacket"); }
-PyObject* stub_net_SendGuildDepositMoneyPacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildDepositMoneyPacket"); }
-PyObject* stub_net_SendGuildWithdrawMoneyPacket(PyObject*, PyObject*) { return stub_call_named("net.SendGuildWithdrawMoneyPacket"); }
-PyObject* stub_net_SendRequestRefineInfoPacket(PyObject*, PyObject*) { return stub_call_named("net.SendRequestRefineInfoPacket"); }
-PyObject* stub_net_SendRefinePacket(PyObject*, PyObject*) { return stub_call_named("net.SendRefinePacket"); }
-PyObject* stub_net_SendSelectItemPacket(PyObject*, PyObject*) { return stub_call_named("net.SendSelectItemPacket"); }
-PyObject* stub_net_SetPacketSequenceMode(PyObject*, PyObject*) { return stub_call_named("net.SetPacketSequenceMode"); }
-PyObject* stub_net_SetEmpireLanguageMode(PyObject*, PyObject*) { return stub_call_named("net.SetEmpireLanguageMode"); }
-PyObject* stub_net_SetSkillGroupFake(PyObject*, PyObject*) { return stub_call_named("net.SetSkillGroupFake"); }
-PyObject* stub_net_SendGuildSymbol(PyObject*, PyObject*) { return stub_call_named("net.SendGuildSymbol"); }
-PyObject* stub_net_DisconnectUploader(PyObject*, PyObject*) { return stub_call_named("net.DisconnectUploader"); }
-PyObject* stub_net_RecvGuildSymbol(PyObject*, PyObject*) { return stub_call_named("net.RecvGuildSymbol"); }
-PyObject* stub_net_RegisterErrorLog(PyObject*, PyObject*) { return stub_call_named("net.RegisterErrorLog"); }
-PyMethodDef methods_net[] = {
-    { "GetBettingGuildWarValue", stub_net_GetBettingGuildWarValue, METH_VARARGS },
-    { "EnableChatInsultFilter", stub_net_EnableChatInsultFilter, METH_VARARGS },
-    { "SetServerInfo", stub_net_SetServerInfo, METH_VARARGS },
-    { "GetServerInfo", stub_net_GetServerInfo, METH_VARARGS },
-    { "PreserveServerCommand", stub_net_PreserveServerCommand, METH_VARARGS },
-    { "GetPreservedServerCommand", stub_net_GetPreservedServerCommand, METH_VARARGS },
-    { "StartGame", stub_net_StartGame, METH_VARARGS },
-    { "Warp", stub_net_Warp, METH_VARARGS },
-    { "IsTest", stub_net_IsTest, METH_VARARGS },
-    { "SetMarkServer", stub_net_SetMarkServer, METH_VARARGS },
-    { "IsChatInsultIn", stub_net_IsChatInsultIn, METH_VARARGS },
-    { "IsInsultIn", stub_net_IsInsultIn, METH_VARARGS },
-    { "LoadInsultList", stub_net_LoadInsultList, METH_VARARGS },
-    { "UploadMark", stub_net_UploadMark, METH_VARARGS },
-    { "UploadSymbol", stub_net_UploadSymbol, METH_VARARGS },
-    { "GetGuildID", stub_net_GetGuildID, METH_VARARGS },
-    { "GetEmpireID", stub_net_GetEmpireID, METH_VARARGS },
-    { "GetMainActorVID", stub_net_GetMainActorVID, METH_VARARGS },
-    { "GetMainActorRace", stub_net_GetMainActorRace, METH_VARARGS },
-    { "GetMainActorEmpire", stub_net_GetMainActorEmpire, METH_VARARGS },
-    { "GetMainActorSkillGroup", stub_net_GetMainActorSkillGroup, METH_VARARGS },
-    { "GetAccountCharacterSlotDataInteger", stub_net_GetAccountCharacterSlotDataInteger, METH_VARARGS },
-    { "GetAccountCharacterSlotDataString", stub_net_GetAccountCharacterSlotDataString, METH_VARARGS },
-    { "GetFieldMusicFileName", stub_net_GetFieldMusicFileName, METH_VARARGS },
-    { "GetFieldMusicVolume", stub_net_GetFieldMusicVolume, METH_VARARGS },
-    { "ToggleGameDebugInfo", stub_net_ToggleGameDebugInfo, METH_VARARGS },
-    { "SetLoginInfo", stub_net_SetLoginInfo, METH_VARARGS },
-    { "SetPhaseWindow", stub_net_SetPhaseWindow, METH_VARARGS },
-    { "ClearPhaseWindow", stub_net_ClearPhaseWindow, METH_VARARGS },
-    { "SetServerCommandParserWindow", stub_net_SetServerCommandParserWindow, METH_VARARGS },
-    { "SetAccountConnectorHandler", stub_net_SetAccountConnectorHandler, METH_VARARGS },
-    { "SetHandler", stub_net_SetHandler, METH_VARARGS },
-    { "SetTCPRecvBufferSize", stub_net_SetTCPRecvBufferSize, METH_VARARGS },
-    { "SetTCPSendBufferSize", stub_net_SetTCPSendBufferSize, METH_VARARGS },
-    { "SetUDPRecvBufferSize", stub_net_SetUDPRecvBufferSize, METH_VARARGS },
-    { "DirectEnter", stub_net_DirectEnter, METH_VARARGS },
-    { "LogOutGame", stub_net_LogOutGame, METH_VARARGS },
-    { "ExitGame", stub_net_ExitGame, METH_VARARGS },
-    { "ExitApplication", stub_net_ExitApplication, METH_VARARGS },
-    { "ConnectTCP", stub_net_ConnectTCP, METH_VARARGS },
-    { "ConnectUDP", stub_net_ConnectUDP, METH_VARARGS },
-    { "ConnectToAccountServer", stub_net_ConnectToAccountServer, METH_VARARGS },
-    { "SendLoginPacket", stub_net_SendLoginPacket, METH_VARARGS },
-    { "SendChinaMatrixCardPacket", stub_net_SendChinaMatrixCardPacket, METH_VARARGS },
-    { "SendRunupMatrixCardPacket", stub_net_SendRunupMatrixCardPacket, METH_VARARGS },
-    { "SendNEWCIBNPasspodAnswerPacket", stub_net_SendNEWCIBNPasspodAnswerPacket, METH_VARARGS },
-    { "SendSelectEmpirePacket", stub_net_SendSelectEmpirePacket, METH_VARARGS },
-    { "SendSelectCharacterPacket", stub_net_SendSelectCharacterPacket, METH_VARARGS },
-    { "SendChangeNamePacket", stub_net_SendChangeNamePacket, METH_VARARGS },
-    { "SendCreateCharacterPacket", stub_net_SendCreateCharacterPacket, METH_VARARGS },
-    { "SendDestroyCharacterPacket", stub_net_SendDestroyCharacterPacket, METH_VARARGS },
-    { "SendEnterGamePacket", stub_net_SendEnterGamePacket, METH_VARARGS },
-    { "SendItemUsePacket", stub_net_SendItemUsePacket, METH_VARARGS },
-    { "SendItemUseToItemPacket", stub_net_SendItemUseToItemPacket, METH_VARARGS },
-    { "SendItemDropPacket", stub_net_SendItemDropPacket, METH_VARARGS },
-    { "SendItemDropPacketNew", stub_net_SendItemDropPacketNew, METH_VARARGS },
-    { "SendElkDropPacket", stub_net_SendElkDropPacket, METH_VARARGS },
-    { "SendGoldDropPacketNew", stub_net_SendGoldDropPacketNew, METH_VARARGS },
-    { "SendItemMovePacket", stub_net_SendItemMovePacket, METH_VARARGS },
-    { "SendItemPickUpPacket", stub_net_SendItemPickUpPacket, METH_VARARGS },
-    { "SendGiveItemPacket", stub_net_SendGiveItemPacket, METH_VARARGS },
-    { "SetOfflinePhase", stub_net_SetOfflinePhase, METH_VARARGS },
-    { "Disconnect", stub_net_Disconnect, METH_VARARGS },
-    { "IsConnect", stub_net_IsConnect, METH_VARARGS },
-    { "SendChatPacket", stub_net_SendChatPacket, METH_VARARGS },
-    { "SendEmoticon", stub_net_SendEmoticon, METH_VARARGS },
-    { "SendWhisperPacket", stub_net_SendWhisperPacket, METH_VARARGS },
-    { "SendMobileMessagePacket", stub_net_SendMobileMessagePacket, METH_VARARGS },
-    { "SendCharacterPositionPacket", stub_net_SendCharacterPositionPacket, METH_VARARGS },
-    { "SendShopEndPacket", stub_net_SendShopEndPacket, METH_VARARGS },
-    { "SendShopBuyPacket", stub_net_SendShopBuyPacket, METH_VARARGS },
-    { "SendShopSellPacket", stub_net_SendShopSellPacket, METH_VARARGS },
-    { "SendShopSellPacketNew", stub_net_SendShopSellPacketNew, METH_VARARGS },
-    { "SendExchangeStartPacket", stub_net_SendExchangeStartPacket, METH_VARARGS },
-    { "SendExchangeItemAddPacket", stub_net_SendExchangeItemAddPacket, METH_VARARGS },
-    { "SendExchangeItemDelPacket", stub_net_SendExchangeItemDelPacket, METH_VARARGS },
-    { "SendExchangeElkAddPacket", stub_net_SendExchangeElkAddPacket, METH_VARARGS },
-    { "SendExchangeAcceptPacket", stub_net_SendExchangeAcceptPacket, METH_VARARGS },
-    { "SendExchangeExitPacket", stub_net_SendExchangeExitPacket, METH_VARARGS },
-    { "SendOnClickPacket", stub_net_SendOnClickPacket, METH_VARARGS },
-    { "RegisterEmoticonString", stub_net_RegisterEmoticonString, METH_VARARGS },
-    { "SendMessengerAddByVIDPacket", stub_net_SendMessengerAddByVIDPacket, METH_VARARGS },
-    { "SendMessengerAddByNamePacket", stub_net_SendMessengerAddByNamePacket, METH_VARARGS },
-    { "SendMessengerRemovePacket", stub_net_SendMessengerRemovePacket, METH_VARARGS },
-    { "SendPartyInvitePacket", stub_net_SendPartyInvitePacket, METH_VARARGS },
-    { "SendPartyInviteAnswerPacket", stub_net_SendPartyInviteAnswerPacket, METH_VARARGS },
-    { "SendPartyExitPacket", stub_net_SendPartyExitPacket, METH_VARARGS },
-    { "SendPartyRemovePacket", stub_net_SendPartyRemovePacket, METH_VARARGS },
-    { "SendPartySetStatePacket", stub_net_SendPartySetStatePacket, METH_VARARGS },
-    { "SendPartyUseSkillPacket", stub_net_SendPartyUseSkillPacket, METH_VARARGS },
-    { "SendPartyParameterPacket", stub_net_SendPartyParameterPacket, METH_VARARGS },
-    { "SendSafeboxSaveMoneyPacket", stub_net_SendSafeboxSaveMoneyPacket, METH_VARARGS },
-    { "SendSafeboxWithdrawMoneyPacket", stub_net_SendSafeboxWithdrawMoneyPacket, METH_VARARGS },
-    { "SendSafeboxCheckinPacket", stub_net_SendSafeboxCheckinPacket, METH_VARARGS },
-    { "SendSafeboxCheckoutPacket", stub_net_SendSafeboxCheckoutPacket, METH_VARARGS },
-    { "SendSafeboxItemMovePacket", stub_net_SendSafeboxItemMovePacket, METH_VARARGS },
-    { "SendMallCheckoutPacket", stub_net_SendMallCheckoutPacket, METH_VARARGS },
-    { "SendAnswerMakeGuildPacket", stub_net_SendAnswerMakeGuildPacket, METH_VARARGS },
-    { "SendQuestInputStringPacket", stub_net_SendQuestInputStringPacket, METH_VARARGS },
-    { "SendQuestConfirmPacket", stub_net_SendQuestConfirmPacket, METH_VARARGS },
-    { "SendGuildAddMemberPacket", stub_net_SendGuildAddMemberPacket, METH_VARARGS },
-    { "SendGuildRemoveMemberPacket", stub_net_SendGuildRemoveMemberPacket, METH_VARARGS },
-    { "SendGuildChangeGradeNamePacket", stub_net_SendGuildChangeGradeNamePacket, METH_VARARGS },
-    { "SendGuildChangeGradeAuthorityPacket", stub_net_SendGuildChangeGradeAuthorityPacket, METH_VARARGS },
-    { "SendGuildOfferPacket", stub_net_SendGuildOfferPacket, METH_VARARGS },
-    { "SendGuildPostCommentPacket", stub_net_SendGuildPostCommentPacket, METH_VARARGS },
-    { "SendGuildDeleteCommentPacket", stub_net_SendGuildDeleteCommentPacket, METH_VARARGS },
-    { "SendGuildRefreshCommentsPacket", stub_net_SendGuildRefreshCommentsPacket, METH_VARARGS },
-    { "SendGuildChangeMemberGradePacket", stub_net_SendGuildChangeMemberGradePacket, METH_VARARGS },
-    { "SendGuildUseSkillPacket", stub_net_SendGuildUseSkillPacket, METH_VARARGS },
-    { "SendGuildChangeMemberGeneralPacket", stub_net_SendGuildChangeMemberGeneralPacket, METH_VARARGS },
-    { "SendGuildInviteAnswerPacket", stub_net_SendGuildInviteAnswerPacket, METH_VARARGS },
-    { "SendGuildChargeGSPPacket", stub_net_SendGuildChargeGSPPacket, METH_VARARGS },
-    { "SendGuildDepositMoneyPacket", stub_net_SendGuildDepositMoneyPacket, METH_VARARGS },
-    { "SendGuildWithdrawMoneyPacket", stub_net_SendGuildWithdrawMoneyPacket, METH_VARARGS },
-    { "SendRequestRefineInfoPacket", stub_net_SendRequestRefineInfoPacket, METH_VARARGS },
-    { "SendRefinePacket", stub_net_SendRefinePacket, METH_VARARGS },
-    { "SendSelectItemPacket", stub_net_SendSelectItemPacket, METH_VARARGS },
-    { "SetPacketSequenceMode", stub_net_SetPacketSequenceMode, METH_VARARGS },
-    { "SetEmpireLanguageMode", stub_net_SetEmpireLanguageMode, METH_VARARGS },
-    { "SetSkillGroupFake", stub_net_SetSkillGroupFake, METH_VARARGS },
-    { "SendGuildSymbol", stub_net_SendGuildSymbol, METH_VARARGS },
-    { "DisconnectUploader", stub_net_DisconnectUploader, METH_VARARGS },
-    { "RecvGuildSymbol", stub_net_RecvGuildSymbol, METH_VARARGS },
-    { "RegisterErrorLog", stub_net_RegisterErrorLog, METH_VARARGS },
-    { NULL, NULL }
-};
-const char* ints_net[] = {"ERROR_NONE", "ERROR_CONNECT_MARK_SERVER", "ERROR_LOAD_MARK", "ERROR_MARK_WIDTH", "ERROR_MARK_HEIGHT", "ERROR_MARK_UPLOAD_NEED_RECONNECT", "ERROR_MARK_CHECK_NEED_RECONNECT", "PHASE_WINDOW_LOGIN", "PHASE_WINDOW_SELECT", "PHASE_WINDOW_CREATE", "PHASE_WINDOW_LOAD", "PHASE_WINDOW_GAME", "PHASE_WINDOW_EMPIRE", "PHASE_WINDOW_LOGO", "ACCOUNT_CHARACTER_SLOT_ID", "ACCOUNT_CHARACTER_SLOT_NAME", "ACCOUNT_CHARACTER_SLOT_RACE", "ACCOUNT_CHARACTER_SLOT_LEVEL", "ACCOUNT_CHARACTER_SLOT_STR", "ACCOUNT_CHARACTER_SLOT_DEX", "ACCOUNT_CHARACTER_SLOT_INT", "ACCOUNT_CHARACTER_SLOT_HTH", "ACCOUNT_CHARACTER_SLOT_PLAYTIME", "ACCOUNT_CHARACTER_SLOT_FORM", "ACCOUNT_CHARACTER_SLOT_ADDR", "ACCOUNT_CHARACTER_SLOT_PORT", "ACCOUNT_CHARACTER_SLOT_GUILD_ID", "ACCOUNT_CHARACTER_SLOT_GUILD_NAME", "ACCOUNT_CHARACTER_SLOT_CHANGE_NAME_FLAG", "ACCOUNT_CHARACTER_SLOT_HAIR", "SERVER_COMMAND_LOG_OUT", "SERVER_COMMAND_RETURN_TO_SELECT_CHARACTER", "SERVER_COMMAND_QUIT", "EMPIRE_A", "EMPIRE_B", "EMPIRE_C", "DS_SUB_HEADER_REFINE_FAIL", "DS_SUB_HEADER_REFINE_FAIL_MAX_REFINE", "DS_SUB_HEADER_REFINE_FAIL_INVALID_MATERIAL", "DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MONEY", "DS_SUB_HEADER_REFINE_FAIL_NOT_ENOUGH_MATERIAL", "DS_SUB_HEADER_REFINE_FAIL_TOO_MUCH_MATERIAL", "DS_SUB_HEADER_REFINE_SUCCEED", NULL};
-const char* strings_net[] = {NULL};
 // 40250 UserInterface/PythonNonPlayerModule.cpp: nonplayer export names.
 PyObject* stub_nonplayer_GetEventType(PyObject*, PyObject*) { return stub_call_named("nonplayer.GetEventType"); }
 PyObject* stub_nonplayer_GetEventTypeByVID(PyObject*, PyObject*) { return stub_call_named("nonplayer.GetEventTypeByVID"); }
@@ -1891,14 +1635,6 @@ void init_2v0_gameplay_stubs() {
         for (const char** name = strings_miniMap; *name; ++name)
             PyModule_AddStringConstant(module, *name, "");
     }
-    {
-        PyObject* module = Py_InitModule("net", methods_net);
-        PyModule_AddIntConstant(module, "__port_stub__", 1);
-        for (const char** name = ints_net; *name; ++name)
-            PyModule_AddIntConstant(module, *name, 0);
-        for (const char** name = strings_net; *name; ++name)
-            PyModule_AddStringConstant(module, *name, "");
-    }
     {
         PyObject* module = Py_InitModule("nonplayer", methods_nonplayer);
         PyModule_AddIntConstant(module, "__port_stub__", 1);

extension/src/platform/ScriptLib/PythonBoot.cpp

@@ -7,6 +7,11 @@
 #include "EterPythonLib/StdAfx.h"
 #include "EterBase/Timer.h"
 #include "EterLib/Util.h"
+#include "UserInterface/PythonNetworkStream.h"
+#include "UserInterface/AccountConnector.h"
+#include "UserInterface/PythonPlayer.h"
+#include "GameLib/FlyingObjectManager.h"
+#include "EffectLib/EffectManager.h"
 #include "PythonBoot.h"
 #include "PythonHost.h"
 #include "../EterLib/UIRenderCommands.h"
@@ -25,6 +30,15 @@ std::unique_ptr<UI::CWindowManager> g_window_manager;
 std::unique_ptr<CPythonResource> g_resource;
 // 40250 CPythonApplication::m_timer; CSlotWindow's cool time and Process() read it via Instance().
 std::unique_ptr<CTimer> g_timer;
+// 40250 CPythonApplication::m_pyNetworkStream and m_kAccountConnector (CSingletons); the app loop
+// processes them every frame and the net module reaches them through Instance().
+std::unique_ptr<CPythonNetworkStream> g_network_stream;
+std::unique_ptr<CAccountConnector> g_account_connector;
+// 40250 CPythonApplication::m_pyPlayer, m_FlyingManager and m_kEftMgr: the loading phase clears them
+// (CPythonNetworkStream::SetLoadingPhase). PythonPlayer and FlyingObjectManager are platform/pending stand-ins.
+std::unique_ptr<CPythonPlayer> g_player;
+std::unique_ptr<CFlyingManager> g_flying_manager;
+std::unique_ptr<CEffectManager> g_effect_manager;
 
 bool fail(std::string* error, const std::string& text)
 {
@@ -206,6 +220,11 @@ bool Start(const char* stdlib_path, std::string* error)
 	g_timer = std::make_unique<CTimer>();
 	g_resource = std::make_unique<CPythonResource>();
 	g_window_manager = std::make_unique<UI::CWindowManager>();
+	g_network_stream = std::make_unique<CPythonNetworkStream>();
+	g_account_connector = std::make_unique<CAccountConnector>();
+	g_player = std::make_unique<CPythonPlayer>();
+	g_flying_manager = std::make_unique<CFlyingManager>();
+	g_effect_manager = std::make_unique<CEffectManager>();
 	return true;
 }
 
@@ -226,6 +245,7 @@ bool run_main_script_body(const char* lpCmdLine, std::string* error)
 	initgrpText();
 	initwndMgr();
 	initapp();
+	initnet();
 	init_2v0_gameplay_stubs();
 
 	ClearLogBoxMessage();
@@ -391,6 +411,11 @@ void Stop()
 	// 40250 Main(): pyLauncher.Clear() runs before app->Destroy()/delete app, so the window manager
 	// (a CPythonApplication member) is still alive while Py_Finalize runs the windows' __del__.
 	g_launcher->Clear();
+	g_effect_manager.reset();
+	g_flying_manager.reset();
+	g_player.reset();
+	g_account_connector.reset();
+	g_network_stream.reset();
 	g_window_manager.reset();
 	g_resource.reset();
 	g_timer.reset();
@@ -398,3 +423,10 @@ void Stop()
 }
 
 }
+
+// winuser.h (declared in the port's windows.h shim). WM_QUIT ends 40250's CPythonApplication::Loop;
+// here the script fiber's loop ends the same way.
+void PostQuitMessage(int)
+{
+	PythonBoot::AppRequestQuit();
+}

extension/src/platform/UserInterface/ProcessCRC.cpp

@@ -0,0 +1,23 @@
+// Platform skeleton for UserInterface/ProcessCRC.h (40250 UserInterface/ProcessCRC.cpp), generated by platform_stub.py.
+// Every MT_PLATFORM_STUB() body is unimplemented: replace it with the platform implementation.
+#include "UserInterface/StdAfx.h"
+#include "UserInterface/ProcessCRC.h"
+
+#include "../PlatformStub.h"
+
+auto GetExeCRC(DWORD &, DWORD &) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto BuildProcessCRC() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto GetProcessCRCMagicCubePiece() -> BYTE
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<BYTE>();
+}

extension/src/platform/UserInterface/PythonApplication.cpp

@@ -5,6 +5,9 @@
 #include "EterLib/Camera.h"
 #include "EterBase/Timer.h"
 #include "EterLib/ResourceManager.h"
+#include "UserInterface/PythonNetworkStream.h"
+#include "UserInterface/AccountConnector.h"
+#include "EterLib/NetDevice.h"
 #include "../PlatformStub.h"
 #include "../EterLib/UIRenderCommands.h"
 #include "../ScriptLib/PythonBoot.h"
@@ -63,6 +66,15 @@ bool CPythonApplication::Create(PyObject*, const char*, int, int, int)
 		PyErr_SetString(PyExc_RuntimeError, "CREATE_DEVICE");
 		return false;
 	}
+
+	// In 40250 m_netDevice is a member created here (PythonApplication.cpp:1242).
+	static CNetworkDevice s_netDevice;
+	if (!s_netDevice.Create())
+	{
+		TraceError("NetDevice::Create failed");
+		PyErr_SetString(PyExc_RuntimeError, "CREATE_NETWORK");
+		return false;
+	}
 	return true;
 }
 void CPythonApplication::UpdateGame() { MT_PLATFORM_STUB(); }
@@ -79,6 +91,12 @@ bool CPythonApplication::Process()
 	CTimer& rkTimer=CTimer::Instance();
 	rkTimer.Advance();
 
+	// Network I/O
+	CPythonNetworkStream::Instance().Process();
+	// PORT: m_kGuildMarkUploader/m_kGuildMarkDownloader.Process() follow here in 40250; the guild mark
+	// transfer is not ported yet (GuildMarkDownloader.cpp/GuildMarkUploader.cpp).
+	CAccountConnector::Instance().Process();
+
 	CResourceManager::Instance().Update();
 
 	OnUIUpdate();
@@ -137,7 +155,6 @@ void CPythonApplication::SetForceSightRange(int) { MT_PLATFORM_STUB(); }
 
 void CCamera::SetResistance(float) { MT_PLATFORM_STUB(); }
 void CCamera::SetCameraMaxDistance(float) { MT_PLATFORM_STUB(); }
-void CGuildMarkManager::SetMarkPathPrefix(const char*) { MT_PLATFORM_STUB(); }
 void CMovieMan::PlayLogo(const char*) { MT_PLATFORM_STUB(); }
 
 float GetDegreeDifference(float, float) { MT_PLATFORM_STUB(); return 0; }
@@ -173,6 +190,46 @@ void LocaleService_ForceSetLocale(const char* name, const char* path) {
     locale_path = path ? path : "";
 }
 
+// 40250 UserInterface/Locale.cpp:9-31, 168-172 and 393-423 (the non-Japan branch), verbatim: what the network
+// slice (批次 2V1) and InsultChecker call.
+const char* LSS_YMIR		= "YMIR";
+const char* LSS_JAPAN		= "JAPAN";
+const char* LSS_ENGLISH		= "ENGLISH";
+const char* LSS_HONGKONG	= "HONGKONG";
+const char* LSS_TAIWAN		= "TAIWAN";
+const char* LSS_NEWCIBN		= "NEWCIBN";
+const char* LSS_EUROPE		= "EUROPE";
+const char* LSS_GLOBAL		= "GLOBAL";
+
+#ifndef LSS_SECURITY_KEY
+#define LSS_SECURITY_KEY	"testtesttesttest"
+#endif
+
+std::string __SECURITY_KEY_STRING__ = LSS_SECURITY_KEY;
+
+const char*	LocaleService_GetSecurityKey()
+{
+	return __SECURITY_KEY_STRING__.c_str();
+}
+
+bool LocaleService_IsYMIR()		{ return (stricmp( LocaleService_GetName(), LSS_YMIR ) == 0) || (stricmp( LocaleService_GetLocaleName(), "ymir" ) == 0);	}
+bool LocaleService_IsJAPAN()	{ return (stricmp( LocaleService_GetName(), LSS_JAPAN ) == 0) || (stricmp( LocaleService_GetLocaleName(), "japan" ) == 0);	}
+bool LocaleService_IsENGLISH()	{ return (stricmp( LocaleService_GetName(), LSS_ENGLISH ) == 0);	}
+bool LocaleService_IsEUROPE()	{ return (stricmp( LocaleService_GetName(), LSS_EUROPE ) == 0);		}
+bool LocaleService_IsHONGKONG()	{ return (stricmp( LocaleService_GetName(), LSS_HONGKONG ) == 0);	}
+bool LocaleService_IsTAIWAN()	{ return (stricmp( LocaleService_GetName(), LSS_TAIWAN ) == 0);		}
+bool LocaleService_IsNEWCIBN()	{ return (stricmp( LocaleService_GetName(), LSS_NEWCIBN ) == 0);	}
+
+BOOL LocaleService_IsLeadByte( const char chByte )
+{
+	return (((unsigned char) chByte) & 0x80) != 0;
+}
+
+int LocaleService_StringCompareCI( LPCSTR szStringLeft, LPCSTR szStringRight, size_t sizeLength )
+{
+	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.

extension/src/platform/UserInterface/UserInterface.cpp

@@ -23,6 +23,9 @@
 #include <dirent.h>
 #endif
 
+// 40250 UserInterface.cpp:49.
+bool __IS_TEST_SERVER_MODE__=false;
+
 namespace
 {
 // Lowercased file name -> on-disk spelling, for the files directly in `folder`.

extension/src/platform/UserInterface/WiseLogicXTrap.cpp

@@ -0,0 +1,29 @@
+// 40250 UserInterface/WiseLogicXTrap.cpp: the build without XTRAP_CLIENT_ENABLE (the XTrap anti-cheat SDK is
+// Win32-only and not shipped), verbatim.
+#include "UserInterface/StdAfx.h"
+#include "UserInterface/Locale.h"
+#include "UserInterface/WiseLogicXTrap.h"
+
+bool XTrap_Init()
+{
+	return true;
+}
+
+bool XTrap_CheckInit()
+{
+	return true;
+}
+
+void XTrap_PollEvent()
+{
+}
+
+void XTrap_SetUserInfo(LPCSTR szUserID, LPCSTR szServerName, LPCSTR szCharacterName, LPCSTR szCharacterClass, SOCKET hSocket)
+{
+
+}
+
+void XTrap_ValidateCheckStream( LPVOID PacketBufferIn, LPVOID PacketBufferOut )
+{
+
+}

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

@@ -0,0 +1,76 @@
+// Stand-in for the 40250 logic unit GameLib/FlyingObjectManager.cpp, not ported yet: the platform_stub.py skeleton of its
+// header, so the units that call it (批次 2V1, the network slice) link. Delete this file in the commit
+// that ports the unit into port/ (docs/PORT-PLAN.md 2V1).
+#include "GameLib/StdAfx.h"
+#include "GameLib/FlyingObjectManager.h"
+
+#include "../../PlatformStub.h"
+
+CFlyingManager::CFlyingManager()
+{
+	MT_PLATFORM_STUB();
+}
+
+CFlyingManager::~CFlyingManager()
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CFlyingManager::Destroy() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CFlyingManager::DeleteAllInstances() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CFlyingManager::RegisterFlyingData(const char *) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CFlyingManager::RegisterFlyingData(const char *, DWORD &) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CFlyingManager::CreateFlyingInstanceFlyTarget(const DWORD, const D3DXVECTOR3 &, const CFlyTarget &, bool) -> CFlyingInstance *
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<CFlyingInstance *>();
+}
+
+auto CFlyingManager::Update() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CFlyingManager::Render() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CFlyingManager::RegisterIndexedFlyData(DWORD, BYTE, const char *) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CFlyingManager::CreateIndexedFly(DWORD, CActorInstance *, CActorInstance *) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CFlyingManager::__DestroyFlyingInstanceList() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CFlyingManager::__DestroyFlyingDataMap() -> void
+{
+	MT_PLATFORM_STUB();
+}

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

@@ -0,0 +1,164 @@
+// Stand-in for the 40250 logic unit UserInterface/GuildMarkDownloader.cpp, not ported yet: the platform_stub.py skeleton of its
+// header, so the units that call it (批次 2V1, the network slice) link. Delete this file in the commit
+// that ports the unit into port/ (docs/PORT-PLAN.md 2V1).
+#include "UserInterface/StdAfx.h"
+#include "UserInterface/GuildMarkDownloader.h"
+
+#include "../../PlatformStub.h"
+
+CGuildMarkDownloader::CGuildMarkDownloader()
+{
+	MT_PLATFORM_STUB();
+}
+
+CGuildMarkDownloader::~CGuildMarkDownloader()
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkDownloader::Connect(const CNetworkAddress &, DWORD, DWORD) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::ConnectToRecvSymbol(const CNetworkAddress &, DWORD, DWORD, const std::vector<DWORD> &) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::Process() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkDownloader::OnConnectFailure() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkDownloader::OnConnectSuccess() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkDownloader::OnRemoteDisconnect() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkDownloader::OnDisconnect() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkDownloader::__Initialize() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkDownloader::__StateProcess() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::__GetPacketSize(UINT) -> UINT
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<UINT>();
+}
+
+auto CGuildMarkDownloader::__DispatchPacket(UINT) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::__OfflineState_Set() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkDownloader::__CompleteState_Set() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkDownloader::__LoginState_Set() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkDownloader::__LoginState_Process() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::__LoginState_RecvPhase() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::__LoginState_RecvHandshake() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::__LoginState_RecvPing() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::__LoginState_RecvMarkIndex() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::__LoginState_RecvMarkBlock() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::__LoginState_RecvSymbolData() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::__LoginState_RecvKeyAgreement() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::__LoginState_RecvKeyAgreementCompleted() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::__SendMarkIDXList() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::__SendMarkCRCList() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkDownloader::__SendSymbolCRCList() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}

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

@@ -0,0 +1,163 @@
+// Stand-in for the 40250 logic unit UserInterface/GuildMarkUploader.cpp, not ported yet: the platform_stub.py skeleton of its
+// header, so the units that call it (批次 2V1, the network slice) link. Delete this file in the commit
+// that ports the unit into port/ (docs/PORT-PLAN.md 2V1).
+#include "UserInterface/StdAfx.h"
+#include "UserInterface/GuildMarkUploader.h"
+
+#include "../../PlatformStub.h"
+
+CGuildMarkUploader::CGuildMarkUploader()
+{
+	MT_PLATFORM_STUB();
+}
+
+CGuildMarkUploader::~CGuildMarkUploader()
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkUploader::Disconnect() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkUploader::Connect(const CNetworkAddress &, DWORD, DWORD, DWORD, const char *, UINT *) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::ConnectToSendSymbol(const CNetworkAddress &, DWORD, DWORD, DWORD, const char *, UINT *) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::IsCompleteUploading() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::Process() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkUploader::OnConnectFailure() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkUploader::OnConnectSuccess() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkUploader::OnRemoteDisconnect() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkUploader::OnDisconnect() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkUploader::__Load(const char *, UINT *) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::__LoadSymbol(const char *, UINT *) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::__Save(const char *) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::__Inialize() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkUploader::__StateProcess() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::__OfflineState_Set() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkUploader::__CompleteState_Set() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkUploader::__LoginState_Set() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkUploader::__LoginState_Process() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::__LoginState_RecvPhase() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::__LoginState_RecvHandshake() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::__LoginState_RecvPing() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::__LoginState_RecvKeyAgreement() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::__LoginState_RecvKeyAgreementCompleted() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::__AnalyzePacket(UINT, UINT, bool (CGuildMarkUploader::*)()) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::__SendMarkPacket() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkUploader::__SendSymbolPacket() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}

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

@@ -0,0 +1,158 @@
+// Stand-in for the 40250 logic unit UserInterface/MarkManager.cpp, not ported yet: the platform_stub.py skeleton of its
+// header, so the units that call it (批次 2V1, the network slice) link. Delete this file in the commit
+// that ports the unit into port/ (docs/PORT-PLAN.md 2V1).
+#include "UserInterface/StdAfx.h"
+#include "UserInterface/MarkManager.h"
+
+#include "../../PlatformStub.h"
+
+CGuildMarkManager::CGuildMarkManager()
+{
+	MT_PLATFORM_STUB();
+}
+
+CGuildMarkManager::~CGuildMarkManager()
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkManager::GetGuildSymbol(DWORD) -> const TGuildSymbol *
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<const TGuildSymbol *>();
+}
+
+auto CGuildMarkManager::LoadSymbol(const char *) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkManager::SaveSymbol(const char *) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkManager::UploadSymbol(DWORD, int, const BYTE *) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkManager::SetMarkPathPrefix(const char *) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkManager::LoadMarkIndex() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkManager::SaveMarkIndex() -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkManager::LoadMarkImages() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkManager::SaveMarkImage(DWORD) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkManager::GetMarkImageFilename(DWORD, std::string &) const -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkManager::AddMarkIDByGuildID(DWORD, DWORD) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkManager::GetMarkImageCount() const -> DWORD
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<DWORD>();
+}
+
+auto CGuildMarkManager::GetMarkCount() const -> DWORD
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<DWORD>();
+}
+
+auto CGuildMarkManager::GetMarkID(DWORD) -> DWORD
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<DWORD>();
+}
+
+auto CGuildMarkManager::CopyMarkIdx(char *) const -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkManager::SaveMark(DWORD, BYTE *) -> DWORD
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<DWORD>();
+}
+
+auto CGuildMarkManager::DeleteMark(DWORD) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkManager::GetDiffBlocks(DWORD, const DWORD *, std::map<BYTE, const SGuildMarkBlock *> &) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkManager::SaveBlockFromCompressedData(DWORD, DWORD, const BYTE *, DWORD) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkManager::GetBlockCRCList(DWORD, DWORD *) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CGuildMarkManager::__NewImage() -> CGuildMarkImage *
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<CGuildMarkImage *>();
+}
+
+auto CGuildMarkManager::__DeleteImage(CGuildMarkImage *) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CGuildMarkManager::__AllocMarkID(DWORD) -> DWORD
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<DWORD>();
+}
+
+auto CGuildMarkManager::__GetImage(DWORD) -> CGuildMarkImage *
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<CGuildMarkImage *>();
+}
+
+auto CGuildMarkManager::__GetImagePtr(DWORD) -> CGuildMarkImage *
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<CGuildMarkImage *>();
+}

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

@@ -0,0 +1,177 @@
+// Stand-in for the 40250 logic unit UserInterface/NetworkActorManager.cpp, not ported yet: the platform_stub.py skeleton of its
+// header, so the units that call it (批次 2V1, the network slice) link. Delete this file in the commit
+// that ports the unit into port/ (docs/PORT-PLAN.md 2V1).
+#include "UserInterface/StdAfx.h"
+#include "UserInterface/NetworkActorManager.h"
+#include "UserInterface/PythonCharacterManager.h" // the __GetCharacterManager return type
+
+#include "../../PlatformStub.h"
+
+SNetworkActorData::SNetworkActorData()
+{
+	MT_PLATFORM_STUB();
+}
+
+auto SNetworkActorData::SetDstPosition(DWORD, LONG, LONG, DWORD) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto SNetworkActorData::SetPosition(LONG, LONG) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto SNetworkActorData::UpdatePosition() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+SNetworkActorData::SNetworkActorData(const SNetworkActorData &)
+{
+	MT_PLATFORM_STUB();
+}
+
+auto SNetworkActorData::operator=(const SNetworkActorData &) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto SNetworkActorData::__copy__(const SNetworkActorData &) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+CNetworkActorManager::CNetworkActorManager()
+{
+	MT_PLATFORM_STUB();
+}
+
+CNetworkActorManager::~CNetworkActorManager()
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::Destroy() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::SetMainActorVID(DWORD) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::RemoveActor(DWORD) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::AppendActor(const SNetworkActorData &) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::UpdateActor(const SNetworkUpdateActorData &) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::MoveActor(const SNetworkMoveActorData &) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::SyncActor(DWORD, LONG, LONG) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::SetActorOwner(DWORD, DWORD) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::Update() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::__OLD_Update() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::__UpdateMainActor() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::__IsVisiblePos(LONG, LONG) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CNetworkActorManager::__IsVisibleActor(const SNetworkActorData &) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CNetworkActorManager::__IsMainActorVID(DWORD) -> bool
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+auto CNetworkActorManager::__RemoveAllGroundItems() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::__RemoveAllActors() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::__RemoveDynamicActors() -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::__RemoveCharacterManagerActor(SNetworkActorData &) -> void
+{
+	MT_PLATFORM_STUB();
+}
+
+auto CNetworkActorManager::__FindActorData(DWORD) -> SNetworkActorData *
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<SNetworkActorData *>();
+}
+
+auto CNetworkActorManager::__AppendCharacterManagerActor(SNetworkActorData &) -> CInstanceBase *
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<CInstanceBase *>();
+}
+
+auto CNetworkActorManager::__FindActor(SNetworkActorData &) -> CInstanceBase *
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<CInstanceBase *>();
+}
+
+auto CNetworkActorManager::__FindActor(SNetworkActorData &, LONG, LONG) -> CInstanceBase *
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<CInstanceBase *>();
+}
+
+auto CNetworkActorManager::__GetCharacterManager() -> CPythonCharacterManager &
+{
+	// PORT: the 40250 body (NetworkActorManager.cpp:310-313); a stub's default reference would construct a
+	// character manager.
+	return CPythonCharacterManager::Instance();
+}

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

@@ -0,0 +1,13 @@
+// Stand-in for the 40250 unit UserInterface/PythonGuild.cpp, not ported yet: the CPythonGuild member the ported
+// net module (批次 2V1) references, as an MT_PLATFORM_STUB(). Delete this file in the commit that ports the unit
+// into port/ (docs/PORT-PLAN.md 2V1).
+#include "UserInterface/StdAfx.h"
+#include "UserInterface/PythonGuild.h"
+
+#include "../../PlatformStub.h"
+
+BOOL CPythonGuild::GetMemberDataPtrByName(const char *, TGuildMemberData **)
+{
+	MT_PLATFORM_STUB();
+	return FALSE;
+}

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

@@ -0,0 +1,304 @@
+// Stand-in for the 40250 logic unit UserInterface/PythonNetworkStreamPhaseGame.cpp, not ported yet: the CPythonNetworkStream
+// members it defines that the ported network slice (批次 2V1) references, as MT_PLATFORM_STUB()s. Delete this
+// file in the commit that ports the unit into port/ (docs/PORT-PLAN.md 2V1).
+#include "UserInterface/StdAfx.h"
+#include "UserInterface/PythonNetworkStream.h"
+
+#include "../../PlatformStub.h"
+
+BOOL gs_bEmpireLanuageEnable = TRUE;
+
+void CPythonNetworkStream::GamePhase()
+{
+	MT_PLATFORM_STUB();
+}
+
+// PORT: consumes the packet only, so the loading phase keeps reading; the handler body comes with the unit.
+bool CPythonNetworkStream::RecvPointChange()
+{
+	MT_PLATFORM_STUB();
+	TPacketGCPointChange PointChange;
+	return Recv(sizeof(PointChange), &PointChange);
+}
+
+void CPythonNetworkStream::RegisterEmoticonString(const char *)
+{
+	MT_PLATFORM_STUB();
+}
+
+bool CPythonNetworkStream::SendAnswerMakeGuildPacket(const char *)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendCharacterPositionPacket(BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendChatPacket(const char *, BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendClientVersionPacket()
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendExchangeAcceptPacket()
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendExchangeElkAddPacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendExchangeExitPacket()
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendExchangeItemAddPacket(TItemPos, BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendExchangeItemDelPacket(BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendExchangeStartPacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGiveItemPacket(DWORD, TItemPos, int)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildAddMemberPacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildChangeGradeAuthorityPacket(BYTE, BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildChangeGradeNamePacket(BYTE, const char *)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildChangeMemberGeneralPacket(DWORD, BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildChangeMemberGradePacket(DWORD, BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildChargeGSPPacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildDeleteCommentPacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildDepositMoneyPacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildInviteAnswerPacket(DWORD, BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildOfferPacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildPostCommentPacket(const char *)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildRefreshCommentsPacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildRemoveMemberPacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildUseSkillPacket(DWORD, DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendGuildWithdrawMoneyPacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendMessengerAddByNamePacket(const char *)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendMessengerAddByVIDPacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendMessengerRemovePacket(const char *, const char *)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendMobileMessagePacket(const char *, const char *)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendOnClickPacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendPartyInviteAnswerPacket(DWORD, BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendPartyInvitePacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendPartyParameterPacket(BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendPartyRemovePacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendPartySetStatePacket(DWORD, BYTE, BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendPartyUseSkillPacket(BYTE, DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendQuestConfirmPacket(BYTE, DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendQuestInputStringPacket(const char *)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendRefinePacket(BYTE, BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendSelectItemPacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendWhisperPacket(const char *, const char *)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+void CPythonNetworkStream::SetGamePhase()
+{
+	MT_PLATFORM_STUB();
+}
+
+void CPythonNetworkStream::ToggleGameDebugInfo()
+{
+	MT_PLATFORM_STUB();
+}
+
+void CPythonNetworkStream::Warp(LONG, LONG)
+{
+	MT_PLATFORM_STUB();
+}
+
+void CPythonNetworkStream::__InitializeGamePhase()
+{
+	MT_PLATFORM_STUB();
+}
+
+void CPythonNetworkStream::__TEST_SetSkillGroupFake(int)
+{
+	MT_PLATFORM_STUB();
+}

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

@@ -0,0 +1,15 @@
+// Stand-in for the 40250 logic unit UserInterface/PythonNetworkStreamPhaseGameActor.cpp, not ported yet: the CPythonNetworkStream
+// members it defines that the ported network slice (批次 2V1) references, as MT_PLATFORM_STUB()s. Delete this
+// file in the commit that ports the unit into port/ (docs/PORT-PLAN.md 2V1).
+#include "UserInterface/StdAfx.h"
+#include "UserInterface/PythonNetworkStream.h"
+
+#include "../../PlatformStub.h"
+
+// PORT: consumes the packet only, so the loading phase keeps reading; the handler body comes with the unit.
+bool CPythonNetworkStream::RecvCharacterUpdatePacket()
+{
+	MT_PLATFORM_STUB();
+	TPacketGCCharacterUpdate chrUpdatePacket;
+	return Recv(sizeof(chrUpdatePacket), &chrUpdatePacket);
+}

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

@@ -0,0 +1,113 @@
+// Stand-in for the 40250 logic unit UserInterface/PythonNetworkStreamPhaseGameItem.cpp, not ported yet: the CPythonNetworkStream
+// members it defines that the ported network slice (批次 2V1) references, as MT_PLATFORM_STUB()s. Delete this
+// file in the commit that ports the unit into port/ (docs/PORT-PLAN.md 2V1).
+#include "UserInterface/StdAfx.h"
+#include "UserInterface/PythonNetworkStream.h"
+
+#include "../../PlatformStub.h"
+
+// PORT: consumes the packet only, so the loading phase keeps reading; the handler body comes with the unit.
+bool CPythonNetworkStream::RecvItemSetPacket()
+{
+	MT_PLATFORM_STUB();
+	TPacketGCItemSet packet_item_set;
+	return Recv(sizeof(packet_item_set), &packet_item_set);
+}
+
+// PORT: consumes the packet only, so the loading phase keeps reading; the handler body comes with the unit.
+bool CPythonNetworkStream::RecvQuickSlotAddPacket()
+{
+	MT_PLATFORM_STUB();
+	TPacketGCQuickSlotAdd packet_quick_slot_add;
+	return Recv(sizeof(packet_quick_slot_add), &packet_quick_slot_add);
+}
+
+bool CPythonNetworkStream::SendItemDropPacket(TItemPos, DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendItemDropPacketNew(TItemPos, DWORD, DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendItemMovePacket(TItemPos, TItemPos, BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendItemPickUpPacket(DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendItemUsePacket(TItemPos)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendItemUseToItemPacket(TItemPos, TItemPos)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendMallCheckoutPacket(BYTE, TItemPos)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendSafeBoxCheckinPacket(TItemPos, BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendSafeBoxCheckoutPacket(BYTE, TItemPos)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendSafeBoxItemMovePacket(BYTE, BYTE, BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendSafeBoxMoneyPacket(BYTE, DWORD)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendShopBuyPacket(BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendShopEndPacket()
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendShopSellPacket(BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}
+
+bool CPythonNetworkStream::SendShopSellPacketNew(BYTE, BYTE)
+{
+	MT_PLATFORM_STUB();
+	return mt_platform_stub_return<bool>();
+}

extension/src/port/CMakeLists.txt

@@ -31,7 +31,9 @@ target_include_directories(port_logic PUBLIC ${MT_PORT_SHIMS})
 # Libraries 40250 links that are vendored as-is: <lzo/lzo1x.h> (EterBase/lzo.h), <cryptopp/*>
 # (EterBase/cipher.h), <Python-2.7/*> (ScriptLib).
 target_link_libraries(port_logic PUBLIC mt3p::minilzo mt3p::cryptopp)
-# common/Win32Crt.cpp converts non-UTF-8 code pages with iconv (MT_ICONV_LIBRARY, extension/CMakeLists.txt).
+# common/Win32Crt.cpp converts non-UTF-8 code pages with iconv. macOS ships it as a separate library;
+# extension/CMakeLists.txt finds it for mtnet, but the port-only build (script/port_gate.sh) never reads that file.
+find_library(MT_ICONV_LIBRARY NAMES iconv)
 if(MT_ICONV_LIBRARY)
     target_link_libraries(port_logic PUBLIC ${MT_ICONV_LIBRARY})
 endif()
@@ -174,6 +176,12 @@ if(BUILD_TESTING AND CMAKE_SYSTEM_NAME STREQUAL CMAKE_HOST_SYSTEM_NAME)
     add_test(NAME port.text COMMAND $<TARGET_FILE:port_text_test>)
     set_tests_properties(port.text PROPERTIES SKIP_RETURN_CODE 77)
 
+    # 批次 2V1: Packet.h struct sizes against the classic wire layouts.
+    add_executable(port_packet_test ${CMAKE_CURRENT_SOURCE_DIR}/../../tests/port_packet_test.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/../../tests/port_packet_test_wire.cpp)
+    target_link_libraries(port_packet_test PRIVATE port_logic)
+    add_test(NAME port.packet COMMAND $<TARGET_FILE:port_packet_test>)
+
     add_executable(port_net_test ${CMAKE_CURRENT_SOURCE_DIR}/../../tests/port_net_test.cpp)
     target_link_libraries(port_net_test PRIVATE port_platform)
     add_test(NAME port.net COMMAND $<TARGET_FILE:port_net_test>)

extension/src/port/EterBase/Singleton.h

@@ -54,8 +54,9 @@ public:
 	singleton()
 	{ 
 		assert(!ms_singleton);
-		int offset = (int) (T*) 1 - (int) (singleton <T>*) (T*) 1; 
-		ms_singleton = (T*) ((int) this + offset);
+		// PORT: was (int) casts (ILP32 Win32); intptr_t keeps the pointer width on 64-bit targets.
+		intptr_t offset = (intptr_t) (T*) 1 - (intptr_t) (singleton <T>*) (T*) 1; 
+		ms_singleton = (T*) ((intptr_t) this + offset);
 	} 
 
 	virtual ~singleton()

extension/src/port/UserInterface/AccountConnector.cpp

@@ -0,0 +1,745 @@
+#include "StdAfx.h"
+#include "AccountConnector.h"
+#include "Packet.h"
+#include "PythonNetworkStream.h"
+#include "../EterBase/tea.h"
+#include "../EterPack/EterPackManager.h"
+
+#include "Hackshield.h"
+#include "WiseLogicXTrap.h"
+
+// CHINA_CRYPT_KEY
+extern DWORD g_adwEncryptKey[4];
+extern DWORD g_adwDecryptKey[4];
+// END_OF_CHINA_CRYPT_KEY
+
+#ifdef USE_OPENID
+extern int openid_test;
+#endif
+
+void CAccountConnector::SetHandler(PyObject* poHandler)
+{
+	m_poHandler = poHandler;
+}
+
+void CAccountConnector::SetLoginInfo(const char * c_szName, const char * c_szPwd)
+{
+	m_strID = c_szName;
+	m_strPassword = c_szPwd;
+}
+
+
+void CAccountConnector::ClearLoginInfo( void )
+{
+	m_strPassword = "";
+}
+
+bool CAccountConnector::Connect(const char * c_szAddr, int iPort, const char * c_szAccountAddr, int iAccountPort)
+{
+#ifndef _IMPROVED_PACKET_ENCRYPTION_
+	__BuildClientKey();
+#endif
+
+	m_strAddr = c_szAddr;
+	m_iPort = iPort;
+
+	__OfflineState_Set();
+
+	// CHINA_CRYPT_KEY
+	if (LocaleService_IsYMIR())
+	{
+	}	
+	else
+	{
+		__BuildClientKey_20050304Myevan();		
+	}
+	// END_OF_CHINA_CRYPT_KEY
+
+	return CNetworkStream::Connect(c_szAccountAddr, iAccountPort);
+}
+
+void CAccountConnector::Disconnect()
+{
+	CNetworkStream::Disconnect();
+	__OfflineState_Set();
+}
+
+bool CAccountConnector::SendNEWCIBNPasspodAnswerPacket(const char * answer)
+{
+	TPacketCGNEWCIBNPasspodAnswer answerPacket;
+	answerPacket.bHeader = HEADER_CG_NEWCIBN_PASSPOD_ANSWER;
+	strncpy(answerPacket.szAnswer, answer, NEWCIBN_PASSPOD_ANSWER_MAX_LEN);
+	answerPacket.szAnswer[NEWCIBN_PASSPOD_ANSWER_MAX_LEN] = '\0';	
+	if (!Send(sizeof(answerPacket), &answerPacket))
+	{
+		TraceError("SendNEWCIBNPasspodAnswerPacket");
+		return false;
+	}
+	return SendSequence();
+}
+
+bool CAccountConnector::SendRunupMatrixCardPacket(const char * c_szMatrixCardString)
+{
+	TPacketCGRunupMatrixAnswer answerPacket;
+	answerPacket.bHeader = HEADER_CG_RUNUP_MATRIX_ANSWER;
+	strncpy(answerPacket.szAnswer, c_szMatrixCardString, RUNUP_MATRIX_ANSWER_MAX_LEN);
+	answerPacket.szAnswer[RUNUP_MATRIX_ANSWER_MAX_LEN] = '\0';
+	if (!Send(sizeof(answerPacket), &answerPacket))
+	{
+		TraceError("SendRunupMatrixCardPacketError");
+		return false;
+	}
+	return SendSequence();
+}
+
+bool CAccountConnector::SendChinaMatrixCardPacket(const char * c_szMatrixCardString)
+{
+	TPacketCGChinaMatrixCard MatrixCardPacket;
+	MatrixCardPacket.bHeader = HEADER_CG_CHINA_MATRIX_CARD;
+	strncpy(MatrixCardPacket.szAnswer, c_szMatrixCardString, CHINA_MATRIX_ANSWER_MAX_LEN);
+	MatrixCardPacket.szAnswer[CHINA_MATRIX_ANSWER_MAX_LEN] = '\0';
+
+	if (!Send(sizeof(MatrixCardPacket), &MatrixCardPacket))
+	{
+		Tracen("SendLogin Error");
+		return false;
+	}
+
+	CPythonNetworkStream::Instance().SetWaitFlag();
+	m_isWaitKey = TRUE;
+
+	return SendSequence();
+}
+
+void CAccountConnector::Process()
+{
+	CNetworkStream::Process();
+
+	if (!__StateProcess())
+	{
+		__OfflineState_Set();
+		Disconnect();
+	}
+}
+
+bool CAccountConnector::__StateProcess()
+{
+	switch (m_eState)
+	{
+		case STATE_HANDSHAKE:
+			return __HandshakeState_Process();
+			break;
+		case STATE_AUTH:
+			return __AuthState_Process();
+			break;
+	}
+
+	return true;
+}
+
+bool CAccountConnector::__HandshakeState_Process()
+{
+	if (!__AnalyzePacket(HEADER_GC_PHASE, sizeof(TPacketGCPhase), &CAccountConnector::__AuthState_RecvPhase))
+		return false;
+
+	if (!__AnalyzePacket(HEADER_GC_HANDSHAKE, sizeof(TPacketGCHandshake), &CAccountConnector::__AuthState_RecvHandshake))
+		return false;
+
+	if (!__AnalyzePacket(HEADER_GC_PING, sizeof(TPacketGCPing), &CAccountConnector::__AuthState_RecvPing))
+		return false;
+
+	//  TODO :  차후 서버와 동일하게 가변길이 data serialize & deserialize  작업해야 한다.
+	if (!__AnalyzeVarSizePacket(HEADER_GC_HYBRIDCRYPT_KEYS, &CAccountConnector::__AuthState_RecvHybridCryptKeys))
+		return false;
+
+	if (!__AnalyzeVarSizePacket(HEADER_GC_HYBRIDCRYPT_SDB, &CAccountConnector::__AuthState_RecvHybridCryptSDB))
+		return false;
+
+#ifdef _IMPROVED_PACKET_ENCRYPTION_
+	if (!__AnalyzePacket(HEADER_GC_KEY_AGREEMENT, sizeof(TPacketKeyAgreement), &CAccountConnector::__AuthState_RecvKeyAgreement))
+		return false;
+
+	if (!__AnalyzePacket(HEADER_GC_KEY_AGREEMENT_COMPLETED, sizeof(TPacketKeyAgreementCompleted), &CAccountConnector::__AuthState_RecvKeyAgreementCompleted))
+		return false;
+#endif
+
+	return true;
+}
+
+bool CAccountConnector::__AuthState_Process()
+{
+	if (!__AnalyzePacket(0, sizeof(BYTE), &CAccountConnector::__AuthState_RecvEmpty))
+		return true;
+
+	if (!__AnalyzePacket(HEADER_GC_PHASE, sizeof(TPacketGCPhase), &CAccountConnector::__AuthState_RecvPhase))
+		return false;
+
+	if (!__AnalyzePacket(HEADER_GC_PING, sizeof(TPacketGCPing), &CAccountConnector::__AuthState_RecvPing))
+		return false;
+
+	if (!__AnalyzePacket(HEADER_GC_AUTH_SUCCESS, sizeof(TPacketGCAuthSuccess), &CAccountConnector::__AuthState_RecvAuthSuccess))
+		return true;
+
+#ifdef USE_OPENID
+	if (!__AnalyzePacket(HEADER_GC_AUTH_SUCCESS_OPENID, sizeof(TPacketGCAuthSuccess), &CAccountConnector::__AuthState_RecvAuthSuccess_OpenID))
+		return true;
+#endif /* USE_OPENID */
+
+	if (!__AnalyzePacket(HEADER_GC_LOGIN_FAILURE, sizeof(TPacketGCAuthSuccess), &CAccountConnector::__AuthState_RecvAuthFailure))
+		return true;
+
+	if (!__AnalyzePacket(HEADER_GC_CHINA_MATRIX_CARD, sizeof(TPacketGCChinaMatrixCard), &CAccountConnector::__AuthState_RecvChinaMatrixCard))
+		return true;
+
+	if (!__AnalyzePacket(HEADER_GC_RUNUP_MATRIX_QUIZ, sizeof(TPacketGCRunupMatrixQuiz), &CAccountConnector::__AuthState_RecvRunupMatrixQuiz))
+		return true;
+
+	if (!__AnalyzePacket(HEADER_GC_NEWCIBN_PASSPOD_REQUEST, sizeof(TPacketGCNEWCIBNPasspodRequest), &CAccountConnector::__AuthState_RecvNEWCIBNPasspodRequest))
+		return true;
+
+	if (!__AnalyzePacket(HEADER_GC_HANDSHAKE, sizeof(TPacketGCHandshake), &CAccountConnector::__AuthState_RecvHandshake))
+		return false;
+
+	if (!__AnalyzePacket(HEADER_GC_PANAMA_PACK, sizeof(TPacketGCPanamaPack), &CAccountConnector::__AuthState_RecvPanamaPack))
+		return false;
+
+#ifdef _IMPROVED_PACKET_ENCRYPTION_
+	if (!__AnalyzePacket(HEADER_GC_KEY_AGREEMENT, sizeof(TPacketKeyAgreement), &CAccountConnector::__AuthState_RecvKeyAgreement))
+		return false;
+
+	if (!__AnalyzePacket(HEADER_GC_KEY_AGREEMENT_COMPLETED, sizeof(TPacketKeyAgreementCompleted), &CAccountConnector::__AuthState_RecvKeyAgreementCompleted))
+		return false;
+#endif
+
+	//  TODO :  차후 서버와 동일하게 가변길이 data serialize & deserialize  작업해야 한다.
+	if (!__AnalyzeVarSizePacket(HEADER_GC_HYBRIDCRYPT_KEYS, &CAccountConnector::__AuthState_RecvHybridCryptKeys))
+		return false;
+
+	if (!__AnalyzeVarSizePacket(HEADER_GC_HYBRIDCRYPT_SDB, &CAccountConnector::__AuthState_RecvHybridCryptSDB))
+		return false;
+
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvEmpty()
+{
+	BYTE byEmpty;
+	Recv(sizeof(BYTE), &byEmpty);
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvPhase()
+{
+	TPacketGCPhase kPacketPhase;
+	if (!Recv(sizeof(kPacketPhase), &kPacketPhase))
+		return false;
+
+	if (kPacketPhase.phase == PHASE_HANDSHAKE)
+	{
+		__HandshakeState_Set();
+	}
+	else if (kPacketPhase.phase == PHASE_AUTH)
+	{
+#ifndef _IMPROVED_PACKET_ENCRYPTION_
+		const char* key = LocaleService_GetSecurityKey();
+		SetSecurityMode(true, key);
+#endif
+
+#ifdef USE_OPENID		
+		if (!openid_test)
+		{
+			//2012.07.19 OpenID : 김용욱 
+			//Ongoing : 오픈 아이디 경우-> TPacketCGLogin5
+			//클라가 가지고 있는 인증키만을 서버에 보내도록.
+
+			//const char* tempAuthKey = "d4025bc1f752b64fe5d51ae575ec4730"; //하드코딩 길이 32
+			TPacketCGLogin5 LoginPacket;
+			LoginPacket.header = HEADER_CG_LOGIN5_OPENID;
+
+			strncpy(LoginPacket.authKey, LocaleService_GetOpenIDAuthKey(), OPENID_AUTHKEY_LEN);
+			LoginPacket.authKey[OPENID_AUTHKEY_LEN] = '\0';
+			
+			for (DWORD i = 0; i < 4; ++i)
+				LoginPacket.adwClientKey[i] = g_adwEncryptKey[i];
+
+			if (!Send(sizeof(LoginPacket), &LoginPacket))
+			{
+				Tracen(" CAccountConnector::__AuthState_RecvPhase - SendLogin5 Error");
+				return false;
+			}
+
+			if (!SendSequence())
+			{
+				return false;
+			}
+		}
+		else
+		{
+			TPacketCGLogin3 LoginPacket;
+			LoginPacket.header = HEADER_CG_LOGIN3;
+
+			strncpy(LoginPacket.name, m_strID.c_str(), ID_MAX_NUM);
+			strncpy(LoginPacket.pwd, m_strPassword.c_str(), PASS_MAX_NUM);
+			LoginPacket.name[ID_MAX_NUM] = '\0';
+			LoginPacket.pwd[PASS_MAX_NUM] = '\0';
+
+			// 비밀번호를 메모리에 계속 갖고 있는 문제가 있어서, 사용 즉시 날리는 것으로 변경
+			ClearLoginInfo();
+			CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
+			rkNetStream.ClearLoginInfo();
+
+			m_strPassword = "";
+
+			for (DWORD i = 0; i < 4; ++i)
+				LoginPacket.adwClientKey[i] = g_adwEncryptKey[i];
+
+			if (!Send(sizeof(LoginPacket), &LoginPacket))
+			{
+				Tracen(" CAccountConnector::__AuthState_RecvPhase - SendLogin3 Error");
+				return false;
+			}
+
+			if (!SendSequence())
+			{
+				return false;
+			}
+		}
+#else /* USE_OPENID */
+
+#ifdef USE_AHNLAB_HACKSHIELD
+		HackShield_SetUserInfo(m_strID.c_str());
+#endif
+#ifdef XTRAP_CLIENT_ENABLE
+		XTrap_SetUserInfo(m_strID.c_str(), NULL, NULL, NULL, NULL);
+#endif
+
+
+		TPacketCGLogin3 LoginPacket;
+		LoginPacket.header = HEADER_CG_LOGIN3;
+
+		strncpy(LoginPacket.name, m_strID.c_str(), ID_MAX_NUM);
+		strncpy(LoginPacket.pwd, m_strPassword.c_str(), PASS_MAX_NUM);
+		LoginPacket.name[ID_MAX_NUM] = '\0';
+		LoginPacket.pwd[PASS_MAX_NUM] = '\0';
+
+		// 비밀번호를 메모리에 계속 갖고 있는 문제가 있어서, 사용 즉시 날리는 것으로 변경
+		ClearLoginInfo();
+		CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
+		rkNetStream.ClearLoginInfo();
+
+		m_strPassword = "";
+
+		for (DWORD i = 0; i < 4; ++i)
+			LoginPacket.adwClientKey[i] = g_adwEncryptKey[i];
+
+		if (!Send(sizeof(LoginPacket), &LoginPacket))
+		{
+			Tracen(" CAccountConnector::__AuthState_RecvPhase - SendLogin3 Error");
+			return false;
+		}
+
+		if (!SendSequence())
+		{
+			return false;
+		}
+#endif /* USE_OPENID */
+
+		__AuthState_Set();
+	}
+
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvHandshake()
+{
+	TPacketGCHandshake kPacketHandshake;
+	if (!Recv(sizeof(kPacketHandshake), &kPacketHandshake))
+		return false;
+
+	// HandShake
+	{
+		Tracenf("HANDSHAKE RECV %u %d", kPacketHandshake.dwTime, kPacketHandshake.lDelta);
+
+		ELTimer_SetServerMSec(kPacketHandshake.dwTime+ kPacketHandshake.lDelta);
+
+		//DWORD dwBaseServerTime = kPacketHandshake.dwTime+ kPacketHandshake.lDelta;
+		//DWORD dwBaseClientTime = ELTimer_GetMSec();
+
+		kPacketHandshake.dwTime = kPacketHandshake.dwTime + kPacketHandshake.lDelta + kPacketHandshake.lDelta;
+		kPacketHandshake.lDelta = 0;
+
+		Tracenf("HANDSHAKE SEND %u", kPacketHandshake.dwTime);
+
+		if (!Send(sizeof(kPacketHandshake), &kPacketHandshake))
+		{
+			Tracen(" CAccountConnector::__AuthState_RecvHandshake - SendHandshake Error");
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvPanamaPack()
+{
+	TPacketGCPanamaPack kPacket;
+
+	if (!Recv(sizeof(TPacketGCPanamaPack), &kPacket))
+		return false;
+
+	CEterPackManager::instance().RegisterPack(kPacket.szPackName, "*", kPacket.abIV);
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvHybridCryptKeys(int iTotalSize)
+{
+	int iFixedHeaderSize = TPacketGCHybridCryptKeys::GetFixedHeaderSize();
+	
+	TPacketGCHybridCryptKeys kPacket(iTotalSize-iFixedHeaderSize);
+
+	if (!Recv(iFixedHeaderSize, &kPacket))
+		return false;
+
+	if (!Recv(kPacket.iKeyStreamLen, kPacket.m_pStream))
+		return false;
+
+	CEterPackManager::Instance().RetrieveHybridCryptPackKeys( kPacket.m_pStream ); 
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvHybridCryptSDB(int iTotalSize)
+{
+	int iFixedHeaderSize = TPacketGCHybridSDB::GetFixedHeaderSize();
+
+	TPacketGCHybridSDB kPacket(iTotalSize-iFixedHeaderSize);
+
+	if (!Recv(iFixedHeaderSize, &kPacket))
+		return false;
+
+	if (!Recv(kPacket.iSDBStreamLen, kPacket.m_pStream))
+		return false;
+
+	CEterPackManager::Instance().RetrieveHybridCryptPackSDB( kPacket.m_pStream ); 
+	return true;
+}
+
+
+bool CAccountConnector::__AuthState_RecvPing()
+{
+	TPacketGCPing kPacketPing;
+	if (!Recv(sizeof(kPacketPing), &kPacketPing))
+		return false;
+
+	__AuthState_SendPong();
+
+	return true;
+}
+
+bool CAccountConnector::__AuthState_SendPong()
+{
+	TPacketCGPong kPacketPong;
+	kPacketPong.bHeader = HEADER_CG_PONG;
+	if (!Send(sizeof(kPacketPong), &kPacketPong))
+		return false;
+
+	if (IsSecurityMode())
+		return SendSequence();
+
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvAuthSuccess()
+{
+	TPacketGCAuthSuccess kAuthSuccessPacket;
+	if (!Recv(sizeof(kAuthSuccessPacket), &kAuthSuccessPacket))
+		return false;
+
+	if (!kAuthSuccessPacket.bResult)
+	{
+		if (m_poHandler)
+			PyCallClassMemberFunc(m_poHandler, "OnLoginFailure", Py_BuildValue("(s)", "BESAMEKEY"));
+	}
+	else
+	{
+		DWORD dwPanamaKey = kAuthSuccessPacket.dwLoginKey ^ g_adwEncryptKey[0] ^ g_adwEncryptKey[1] ^ g_adwEncryptKey[2] ^ g_adwEncryptKey[3];
+		CEterPackManager::instance().DecryptPackIV(dwPanamaKey);
+
+		CPythonNetworkStream & rkNet = CPythonNetworkStream::Instance();
+		rkNet.SetLoginKey(kAuthSuccessPacket.dwLoginKey);
+		rkNet.Connect(m_strAddr.c_str(), m_iPort);
+	}
+
+	Disconnect();
+	__OfflineState_Set();
+
+	return true;
+}
+
+#ifdef USE_OPENID
+bool CAccountConnector::__AuthState_RecvAuthSuccess_OpenID()
+{
+	TPacketGCAuthSuccessOpenID kAuthSuccessOpenIDPacket;
+	if (!Recv(sizeof(kAuthSuccessOpenIDPacket), &kAuthSuccessOpenIDPacket))
+		return false;
+
+	if (!kAuthSuccessOpenIDPacket.bResult)
+	{
+		if (m_poHandler)
+			PyCallClassMemberFunc(m_poHandler, "OnLoginFailure", Py_BuildValue("(s)", "BESAMEKEY"));
+	}
+	else
+	{
+		DWORD dwPanamaKey = kAuthSuccessOpenIDPacket.dwLoginKey ^ g_adwEncryptKey[0] ^ g_adwEncryptKey[1] ^ g_adwEncryptKey[2] ^ g_adwEncryptKey[3];
+		CEterPackManager::instance().DecryptPackIV(dwPanamaKey);
+
+		CPythonNetworkStream & rkNet = CPythonNetworkStream::Instance();
+		rkNet.SetLoginInfo(kAuthSuccessOpenIDPacket.login, "0000");		//OpenID 인증 과정에서 비밀번호는 사용되지 않는다.
+		rkNet.SetLoginKey(kAuthSuccessOpenIDPacket.dwLoginKey);
+		rkNet.Connect(m_strAddr.c_str(), m_iPort);
+	}
+
+	Disconnect();
+	__OfflineState_Set();
+
+	return true;
+}
+#endif /* USE_OPENID */
+
+
+bool CAccountConnector::__AuthState_RecvAuthFailure()
+{
+	TPacketGCLoginFailure packet_failure;
+	if (!Recv(sizeof(TPacketGCLoginFailure), &packet_failure))
+		return false;
+
+	if (m_poHandler)
+		PyCallClassMemberFunc(m_poHandler, "OnLoginFailure", Py_BuildValue("(s)", packet_failure.szStatus));
+
+//	__OfflineState_Set();
+
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvRunupMatrixQuiz()
+{
+	TPacketGCRunupMatrixQuiz kMatrixQuizPacket;
+	if (!Recv(sizeof(TPacketGCRunupMatrixQuiz), &kMatrixQuizPacket))
+		return false;
+
+	PyCallClassMemberFunc(m_poHandler, "BINARY_OnRunupMatrixQuiz", Py_BuildValue("(s)", kMatrixQuizPacket.szQuiz));	
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvNEWCIBNPasspodRequest()
+{
+	TPacketGCNEWCIBNPasspodRequest kRequestPacket;
+	if (!Recv(sizeof(kRequestPacket), &kRequestPacket))
+		return false;
+
+	PyCallClassMemberFunc(m_poHandler, "BINARY_OnNEWCIBNPasspodRequest", Py_BuildValue("()"));	
+	return true;
+}
+
+#define ROW(rows, i) ((rows >> ((4 - i - 1) * 8)) & 0x000000FF)
+#define COL(cols, i) ((cols >> ((4 - i - 1) * 8)) & 0x000000FF)
+
+bool CAccountConnector::__AuthState_RecvChinaMatrixCard()
+{
+	TPacketGCChinaMatrixCard kMatrixCardPacket;
+	if (!Recv(sizeof(TPacketGCChinaMatrixCard), &kMatrixCardPacket))
+		return false;
+
+	if (m_poHandler)
+	{
+		PyObject * pyValue = Py_BuildValue("(iiiiiiii)",	ROW(kMatrixCardPacket.dwRows, 0),
+															ROW(kMatrixCardPacket.dwRows, 1),
+															ROW(kMatrixCardPacket.dwRows, 2),
+															ROW(kMatrixCardPacket.dwRows, 3),
+															COL(kMatrixCardPacket.dwCols, 0),
+															COL(kMatrixCardPacket.dwCols, 1),
+															COL(kMatrixCardPacket.dwCols, 2),
+															COL(kMatrixCardPacket.dwCols, 3));
+		PyCallClassMemberFunc(m_poHandler, "OnMatrixCard", pyValue);
+	}
+
+	return true;
+}
+
+#ifdef _IMPROVED_PACKET_ENCRYPTION_
+bool CAccountConnector::__AuthState_RecvKeyAgreement()
+{
+	TPacketKeyAgreement packet;
+	if (!Recv(sizeof(packet), &packet))
+	{
+		return false;
+	}
+
+	Tracenf("KEY_AGREEMENT RECV %u", packet.wDataLength);
+
+	TPacketKeyAgreement packetToSend;
+	size_t dataLength = TPacketKeyAgreement::MAX_DATA_LEN;
+	size_t agreedLength = Prepare(packetToSend.data, &dataLength);
+	if (agreedLength == 0)
+	{
+		// 초기화 실패
+		Disconnect();
+		return false;
+	}
+	assert(dataLength <= TPacketKeyAgreement::MAX_DATA_LEN);
+
+	if (Activate(packet.wAgreedLength, packet.data, packet.wDataLength))
+	{
+		// Key agreement 성공, 응답 전송
+		packetToSend.bHeader = HEADER_CG_KEY_AGREEMENT;
+		packetToSend.wAgreedLength = (WORD)agreedLength;
+		packetToSend.wDataLength = (WORD)dataLength;
+
+		if (!Send(sizeof(packetToSend), &packetToSend))
+		{
+			Tracen(" CAccountConnector::__AuthState_RecvKeyAgreement - SendKeyAgreement Error");
+			return false;
+		}
+		Tracenf("KEY_AGREEMENT SEND %u", packetToSend.wDataLength);
+	}
+	else
+	{
+		// 키 협상 실패
+		Disconnect();
+		return false;
+	}
+	return true;
+}
+
+bool CAccountConnector::__AuthState_RecvKeyAgreementCompleted()
+{
+	TPacketKeyAgreementCompleted packet;
+	if (!Recv(sizeof(packet), &packet))
+	{
+		return false;
+	}
+
+	Tracenf("KEY_AGREEMENT_COMPLETED RECV");
+
+	ActivateCipher();
+
+	return true;
+}
+#endif // _IMPROVED_PACKET_ENCRYPTION_
+
+bool CAccountConnector::__AnalyzePacket(UINT uHeader, UINT uPacketSize, bool (CAccountConnector::*pfnDispatchPacket)())
+{
+	BYTE bHeader;
+	if (!Peek(sizeof(bHeader), &bHeader))
+		return true;
+
+	if (bHeader!=uHeader)
+		return true;
+
+	if (!Peek(uPacketSize))
+		return true;
+
+	return (this->*pfnDispatchPacket)();
+}
+
+bool CAccountConnector::__AnalyzeVarSizePacket(UINT uHeader, bool (CAccountConnector::*pfnDispatchPacket)(int))
+{
+	BYTE bHeader;
+	if (!Peek(sizeof(bHeader), &bHeader))
+		return true;
+
+	if (bHeader!=uHeader)
+		return true;
+
+	TDynamicSizePacketHeader dynamicHeader;
+
+	if (!Peek(sizeof(dynamicHeader), &dynamicHeader))
+		return true;
+
+	if (!Peek(dynamicHeader.size))
+		return true;
+
+	return (this->*pfnDispatchPacket)(dynamicHeader.size);
+}
+
+
+void CAccountConnector::__OfflineState_Set()
+{
+	__Inialize();
+}
+
+void CAccountConnector::__HandshakeState_Set()
+{
+	m_eState=STATE_HANDSHAKE;
+}
+
+void CAccountConnector::__AuthState_Set()
+{
+	m_eState=STATE_AUTH;
+}
+
+void CAccountConnector::OnConnectFailure()
+{
+	if (m_poHandler)
+		PyCallClassMemberFunc(m_poHandler, "OnConnectFailure", Py_BuildValue("()"));
+
+	__OfflineState_Set();
+}
+
+void CAccountConnector::OnConnectSuccess()
+{
+	m_eState = STATE_HANDSHAKE;
+}
+
+void CAccountConnector::OnRemoteDisconnect()
+{
+	// Matrix Card Number 를 보내 놓았는데 close 되면 프로그램을 종료 한다.
+	if (m_isWaitKey)
+	{
+		if (m_poHandler)
+		{
+			PyCallClassMemberFunc(m_poHandler, "OnExit", Py_BuildValue("()"));
+			return;
+		}
+	}
+
+	__OfflineState_Set();
+}
+
+void CAccountConnector::OnDisconnect()
+{
+	__OfflineState_Set();
+}
+
+#ifndef _IMPROVED_PACKET_ENCRYPTION_
+void CAccountConnector::__BuildClientKey()
+{
+	for (DWORD i = 0; i < 4; ++i)
+		g_adwEncryptKey[i] = random();
+
+	const BYTE * c_pszKey = (const BYTE *) "JyTxtHljHJlVJHorRM301vf@4fvj10-v";
+	tea_encrypt((DWORD *) g_adwDecryptKey, (const DWORD *) g_adwEncryptKey, (const DWORD *) c_pszKey, 16);
+}
+#endif
+
+void CAccountConnector::__Inialize()
+{
+	m_eState=STATE_OFFLINE;
+	m_isWaitKey = FALSE;
+}
+
+CAccountConnector::CAccountConnector()
+{
+	m_poHandler = NULL;
+	m_strAddr = "";
+	m_iPort = 0;
+
+	SetLoginInfo("", "");
+	SetRecvBufferSize(1024 * 128);
+	SetSendBufferSize(2048);
+	__Inialize();
+}
+
+CAccountConnector::~CAccountConnector()
+{
+	__OfflineState_Set();
+}

extension/src/port/UserInterface/AffectFlagContainer.cpp

@@ -0,0 +1,92 @@
+#include "StdAfx.h"
+#include "AffectFlagContainer.h"
+
+CAffectFlagContainer::CAffectFlagContainer()
+{
+	Clear();
+}
+
+CAffectFlagContainer::~CAffectFlagContainer()
+{
+}
+
+void CAffectFlagContainer::Clear()
+{
+	memset(m_aElement, 0, sizeof(m_aElement));
+}
+
+void CAffectFlagContainer::CopyInstance(const CAffectFlagContainer& c_rkAffectContainer)
+{
+	memcpy(m_aElement, c_rkAffectContainer.m_aElement, sizeof(m_aElement));
+}
+
+void CAffectFlagContainer::CopyData(UINT uPos, UINT uByteSize, const void* c_pvData)
+{
+	const BYTE* c_pbData=(const BYTE*)c_pvData; 
+	Element bMask=0x01;
+
+	UINT uBitEnd=uPos+uByteSize*8;
+	for (UINT i=uPos; i<uBitEnd; ++i)
+	{
+		Set(i, (*c_pbData & bMask) ? true : false);
+		bMask<<=1;
+
+		if (bMask==0)
+		{
+			++c_pbData;
+			bMask=0x01;
+		}
+	}
+}
+
+void CAffectFlagContainer::ConvertToPosition(unsigned* uRetX, unsigned* uRetY) const
+{
+	DWORD* pos = (DWORD*)m_aElement;
+	*uRetX = pos[0];
+	*uRetY = pos[1];
+}
+/*
+const void * CAffectFlagContainer::GetDataPtr(UINT uPos) const
+{
+	if (uPos/8>=BYTE_SIZE)
+	{
+		return NULL;
+	}
+
+	return (const void *)&m_aElement[uPos];
+}
+*/
+
+void CAffectFlagContainer::Set(UINT uPos, bool isSet)
+{
+	if (uPos/8>=BYTE_SIZE)
+	{
+		TraceError("CAffectFlagContainer::Set(uPos=%d>%d, isSet=%d", uPos, BYTE_SIZE*8, isSet);
+		return;
+	}
+
+	BYTE& rElement=m_aElement[uPos/8];
+
+	BYTE bMask=BYTE(1<<(uPos&7));
+	if (isSet)
+		rElement|=bMask;
+	else
+		rElement&=~bMask;
+}
+
+bool CAffectFlagContainer::IsSet(UINT uPos) const
+{
+	if (uPos/8>=BYTE_SIZE)
+	{
+		TraceError("CAffectFlagContainer::IsSet(uPos=%d>%d", uPos, BYTE_SIZE*8);
+		return false;
+	}
+
+	const BYTE& c_rElement=m_aElement[uPos/8];
+
+	BYTE bMask=BYTE(1<<(uPos&7));
+	if (c_rElement&bMask)
+		return true;
+
+	return false;
+}

extension/src/port/UserInterface/InsultChecker.cpp

@@ -0,0 +1,97 @@
+#include "StdAfx.h"
+#include "InsultChecker.h"
+
+CInsultChecker& CInsultChecker::GetSingleton()
+{
+	static CInsultChecker s_kInsultChecker;
+	return s_kInsultChecker;
+}
+
+CInsultChecker::CInsultChecker()
+{
+}
+
+CInsultChecker::~CInsultChecker()
+{
+}
+
+void CInsultChecker::Clear()
+{
+	m_kList_stInsult.clear();
+}
+
+void CInsultChecker::AppendInsult(const std::string& c_rstInsult)
+{
+	if (c_rstInsult.length()>0)
+		m_kList_stInsult.push_back(c_rstInsult);
+}
+
+bool CInsultChecker::__GetInsultLength(const char* c_szWord, UINT* puInsultLen)
+{
+	std::list<std::string>::iterator i;
+	for (i=m_kList_stInsult.begin(); i!=m_kList_stInsult.end(); ++i)
+	{
+		std::string& rstInsult=*i;
+
+		int ret=LocaleService_StringCompareCI(c_szWord, rstInsult.c_str(), rstInsult.length());		
+		if (0==ret)
+		{
+			*puInsultLen=rstInsult.length();
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool CInsultChecker::__IsInsult(const char* c_szWord)
+{
+	UINT uInsultLen;
+	return __GetInsultLength(c_szWord, &uInsultLen);
+}
+
+void CInsultChecker::FilterInsult(char* szLine, UINT uLineLen)
+{
+	const char INSULT_FILTER_CHAR = '*'; 
+	for (UINT uPos=0; uPos<uLineLen;)
+	{
+		BYTE bChr=szLine[uPos];
+		UINT uInsultLen;
+		if (__GetInsultLength(szLine+uPos, &uInsultLen))
+		{
+			memset(szLine+uPos, INSULT_FILTER_CHAR, uInsultLen);
+			uPos += uInsultLen;
+		}
+		else
+		{
+			if ( LocaleService_IsLeadByte( bChr ) )
+				uPos += 2;
+			else
+				uPos++;
+		}
+	}
+}
+
+bool CInsultChecker::IsInsultIn(const char* c_szLine, UINT uLineLen)
+{
+	for (UINT uPos=0; uPos<uLineLen;)
+	{
+		BYTE bChr=c_szLine[uPos];
+		if (bChr & 0x80)
+		{
+			if (__IsInsult(c_szLine+uPos))
+				return true;
+
+			uPos+=2;
+		}
+		else
+		{
+			if (__IsInsult(c_szLine+uPos))
+				return true;
+
+			uPos++;
+		}
+	}
+
+	return false;
+}

extension/src/port/UserInterface/NetworkActorManager.h

@@ -0,0 +1,164 @@
+#pragma once
+
+#include "InstanceBase.h"
+
+struct SNetworkActorData
+{
+	std::string m_stName;
+	
+	CAffectFlagContainer	m_kAffectFlags;
+
+	BYTE	m_bType;
+	DWORD	m_dwVID;
+	DWORD	m_dwStateFlags;
+	DWORD	m_dwEmpireID;
+	DWORD	m_dwRace;
+	DWORD	m_dwMovSpd;
+	DWORD	m_dwAtkSpd;
+	FLOAT	m_fRot;
+	LONG	m_lCurX;
+	LONG	m_lCurY;
+	LONG	m_lSrcX;
+	LONG	m_lSrcY;
+	LONG	m_lDstX;
+	LONG	m_lDstY;
+	
+
+	DWORD	m_dwServerSrcTime;
+	DWORD	m_dwClientSrcTime;
+	DWORD	m_dwDuration;
+
+	DWORD	m_dwArmor;
+	DWORD	m_dwWeapon;
+	DWORD	m_dwHair;
+
+	DWORD	m_dwOwnerVID;
+
+	short	m_sAlignment;
+	BYTE	m_byPKMode;
+	DWORD	m_dwMountVnum;
+
+	DWORD	m_dwGuildID;
+	DWORD	m_dwLevel;
+	
+	SNetworkActorData();
+
+	void SetDstPosition(DWORD dwServerTime, LONG lDstX, LONG lDstY, DWORD dwDuration);
+	void SetPosition(LONG lPosX, LONG lPosY);
+	void UpdatePosition();	
+
+	// NETWORK_ACTOR_DATA_COPY
+	SNetworkActorData(const SNetworkActorData& src);
+	void operator=(const SNetworkActorData& src);
+	void __copy__(const SNetworkActorData& src);	
+	// END_OF_NETWORK_ACTOR_DATA_COPY
+};
+
+struct SNetworkMoveActorData
+{
+	DWORD	m_dwVID;
+	DWORD	m_dwTime;
+	LONG	m_lPosX;
+	LONG	m_lPosY;
+	float	m_fRot;
+	DWORD	m_dwFunc;
+	DWORD	m_dwArg;
+	DWORD	m_dwDuration;
+
+	SNetworkMoveActorData()
+	{
+		m_dwVID=0;
+		m_dwTime=0;
+		m_fRot=0.0f;
+		m_lPosX=0;
+		m_lPosY=0;
+		m_dwFunc=0;
+		m_dwArg=0;
+		m_dwDuration=0;
+	}
+};
+
+struct SNetworkUpdateActorData
+{
+	DWORD m_dwVID;
+	DWORD m_dwGuildID;
+	DWORD m_dwArmor;
+	DWORD m_dwWeapon;
+	DWORD m_dwHair;
+	DWORD m_dwMovSpd;
+	DWORD m_dwAtkSpd;
+	short m_sAlignment;
+	BYTE m_byPKMode;
+	DWORD m_dwMountVnum;
+	DWORD m_dwStateFlags; // 본래 Create 때만 쓰이는 변수임
+	CAffectFlagContainer m_kAffectFlags;
+
+	SNetworkUpdateActorData()
+	{
+		m_dwGuildID=0;
+		m_dwVID=0;
+		m_dwArmor=0;
+		m_dwWeapon=0;
+		m_dwHair=0;
+		m_dwMovSpd=0;
+		m_dwAtkSpd=0;
+		m_sAlignment=0;
+		m_byPKMode=0;
+		m_dwMountVnum=0;
+		m_dwStateFlags=0;
+		m_kAffectFlags.Clear();
+	}
+};
+
+class CPythonCharacterManager;
+
+class CNetworkActorManager : public CReferenceObject
+{
+	public:
+		CNetworkActorManager();
+		virtual ~CNetworkActorManager();
+
+		void Destroy();
+
+		void SetMainActorVID(DWORD dwVID);
+
+		void RemoveActor(DWORD dwVID);
+		void AppendActor(const SNetworkActorData& c_rkNetActorData);
+		void UpdateActor(const SNetworkUpdateActorData& c_rkNetUpdateActorData);
+		void MoveActor(const SNetworkMoveActorData& c_rkNetMoveActorData);
+
+		void SyncActor(DWORD dwVID, LONG lPosX, LONG lPosY);
+		void SetActorOwner(DWORD dwOwnerVID, DWORD dwVictimVID);
+
+		void Update();
+
+	protected:
+		void __OLD_Update();
+
+		void __UpdateMainActor();
+
+		bool __IsVisiblePos(LONG lPosX, LONG lPosY);
+		bool __IsVisibleActor(const SNetworkActorData& c_rkNetActorData);
+		bool __IsMainActorVID(DWORD dwVID);
+
+		void __RemoveAllGroundItems();
+		void __RemoveAllActors();
+		void __RemoveDynamicActors();
+		void __RemoveCharacterManagerActor(SNetworkActorData& rkNetActorData);
+
+		SNetworkActorData* __FindActorData(DWORD dwVID);
+
+		CInstanceBase* __AppendCharacterManagerActor(SNetworkActorData& rkNetActorData);
+		CInstanceBase* __FindActor(SNetworkActorData& rkNetActorData);
+		CInstanceBase* __FindActor(SNetworkActorData& rkNetActorData, LONG lDstX, LONG lDstY);
+
+		CPythonCharacterManager& __GetCharacterManager();
+
+	protected:
+		DWORD m_dwMainVID;
+
+		LONG m_lMainPosX;
+		LONG m_lMainPosY;
+
+		std::map<DWORD, SNetworkActorData> m_kNetActorDict;
+};

extension/src/port/UserInterface/Packet.h

@@ -766,8 +766,8 @@ typedef struct command_move
 typedef struct command_sync_position_element 
 { 
     DWORD       dwVID; 
-    long        lX; 
-    long        lY; 
+    LONG        lX; // PORT: LONG, the 32-bit Win32 long
+    LONG        lY; // PORT: LONG, the 32-bit Win32 long
 } TPacketCGSyncPositionElement; 
 
 typedef struct command_sync_position
@@ -780,8 +780,8 @@ typedef struct command_fly_targeting
 {
 	BYTE		bHeader;
 	DWORD		dwTargetVID;
-	long		lX;
-	long		lY;
+	LONG		lX; // PORT: LONG, the 32-bit Win32 long
+	LONG		lY; // PORT: LONG, the 32-bit Win32 long
 } TPacketCGFlyTargeting;
 
 typedef struct packet_fly_targeting
@@ -789,8 +789,8 @@ typedef struct packet_fly_targeting
     BYTE        bHeader;
 	DWORD		dwShooterVID;
 	DWORD		dwTargetVID;
-	long		lX;
-	long		lY;
+	LONG		lX; // PORT: LONG, the 32-bit Win32 long
+	LONG		lY; // PORT: LONG, the 32-bit Win32 long
 } TPacketGCFlyTargeting;
 
 typedef struct packet_shoot
@@ -1186,7 +1186,7 @@ typedef struct SSimplePlayerInformation
     BYTE                bChangeName;
 	WORD				wHairPart;
     BYTE                bDummy[4];
-	long				x, y;
+	LONG				x, y; // PORT: LONG, the 32-bit Win32 long
 	LONG				lAddr;
 	WORD				wPort;
 	BYTE				bySkillGroup;
@@ -1312,9 +1312,9 @@ typedef struct packet_add_char
     //char        name[CHARACTER_NAME_MAX_LEN + 1];
 
     float       angle;
-    long        x;
-    long        y;
-    long        z;
+    LONG        x; // PORT: LONG, the 32-bit Win32 long
+    LONG        y; // PORT: LONG, the 32-bit Win32 long
+    LONG        z; // PORT: LONG, the 32-bit Win32 long
 
 	BYTE		bType;
     WORD        wRaceNum;
@@ -1340,9 +1340,9 @@ typedef struct packet_add_char2
     char        name[CHARACTER_NAME_MAX_LEN + 1];
 
     float       angle;
-    long        x;
-    long        y;
-    long        z;
+    LONG        x; // PORT: LONG, the 32-bit Win32 long
+    LONG        y; // PORT: LONG, the 32-bit Win32 long
+    LONG        z; // PORT: LONG, the 32-bit Win32 long
 
 	BYTE		bType;
     WORD        wRaceNum;
@@ -1457,7 +1457,7 @@ typedef struct packet_main_character
     DWORD       dwVID;
 	WORD		wRaceNum;
     char        szName[CHARACTER_NAME_MAX_LEN + 1];
-    long        lX, lY, lZ;
+    LONG        lX, lY, lZ; // PORT: LONG, the 32-bit Win32 long
 	BYTE		bySkillGroup;
 } TPacketGCMainCharacter;
 
@@ -1468,7 +1468,7 @@ typedef struct packet_main_character2_empire
     DWORD       dwVID;
 	WORD		wRaceNum;
     char        szName[CHARACTER_NAME_MAX_LEN + 1];
-    long        lX, lY, lZ;
+    LONG        lX, lY, lZ; // PORT: LONG, the 32-bit Win32 long
 	BYTE		byEmpire;
 	BYTE		bySkillGroup;
 } TPacketGCMainCharacter2_EMPIRE;
@@ -1484,7 +1484,7 @@ typedef struct packet_main_character3_bgm
 	WORD		wRaceNum;
     char        szUserName[CHARACTER_NAME_MAX_LEN + 1];
 	char        szBGMName[MUSIC_NAME_MAX_LEN + 1];
-    long        lX, lY, lZ;
+    LONG        lX, lY, lZ; // PORT: LONG, the 32-bit Win32 long
 	BYTE		byEmpire;
 	BYTE		bySkillGroup;
 } TPacketGCMainCharacter3_BGM;
@@ -1501,7 +1501,7 @@ typedef struct packet_main_character4_bgm_vol
     char        szUserName[CHARACTER_NAME_MAX_LEN + 1];
 	char        szBGMName[MUSIC_NAME_MAX_LEN + 1];
 	float		fBGMVol;
-    long        lX, lY, lZ;
+    LONG        lX, lY, lZ; // PORT: LONG, the 32-bit Win32 long
 	BYTE		byEmpire;
 	BYTE		bySkillGroup;
 } TPacketGCMainCharacter4_BGM_VOL;
@@ -1679,7 +1679,7 @@ enum EPointTypes
 typedef struct packet_points
 {
     BYTE        header;
-    long        points[POINT_MAX_NUM];
+    LONG        points[POINT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
 } TPacketGCPoints;
 
 typedef struct packet_point_change
@@ -1689,8 +1689,8 @@ typedef struct packet_point_change
 	DWORD		dwVID;
 	BYTE		Type;
 
-	long        amount; // 바뀐 값
-    long        value;  // 현재 값
+	LONG        amount; // 바뀐 값 // PORT: LONG, the 32-bit Win32 long
+    LONG        value; // 현재 값 // PORT: LONG, the 32-bit Win32 long
 } TPacketGCPointChange;
 
 typedef struct packet_motion
@@ -1718,7 +1718,7 @@ struct TPacketGCItemDelDeprecate
     BYTE    pos;
     DWORD   vnum;
     BYTE    count;
-    long    alSockets[ITEM_SOCKET_SLOT_MAX_NUM];
+    LONG    alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
     TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
 };
 
@@ -1729,7 +1729,7 @@ typedef struct packet_set_item
 	DWORD		vnum;
 	BYTE		count;
 	DWORD		flags;	// 플래그 추가
-	long		alSockets[ITEM_SOCKET_SLOT_MAX_NUM];
+	LONG		alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
     TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
 } TPacketGCItemSet;
 
@@ -1745,7 +1745,7 @@ typedef struct packet_set_item
 	TItemPos	Cell;
 	DWORD		vnum;
 	BYTE		count;
-	long		alSockets[ITEM_SOCKET_SLOT_MAX_NUM];
+	LONG		alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
     TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
 } TPacketGCItemSet;
 
@@ -1758,7 +1758,7 @@ typedef struct packet_set_item2
 	DWORD		flags;	// 플래그 추가
 	DWORD		anti_flags;	// 플래그 추가
 	bool		highlight;
-	long		alSockets[ITEM_SOCKET_SLOT_MAX_NUM];
+	LONG		alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
     TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
 } TPacketGCItemSet2;
 #endif
@@ -1784,16 +1784,16 @@ typedef struct packet_update_item
 	BYTE		header;
 	TItemPos	Cell;
 	BYTE		count;
-	long		alSockets[ITEM_SOCKET_SLOT_MAX_NUM];
+	LONG		alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
     TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
 } TPacketGCItemUpdate;
 
 typedef struct packet_ground_add_item
 {
     BYTE        bHeader;
-    long        lX;
-	long		lY;
-	long		lZ;
+    LONG        lX; // PORT: LONG, the 32-bit Win32 long
+	LONG		lY; // PORT: LONG, the 32-bit Win32 long
+	LONG		lZ; // PORT: LONG, the 32-bit Win32 long
 
     DWORD       dwVID;
     DWORD       dwVnum;
@@ -1892,7 +1892,7 @@ typedef struct packet_exchange
     DWORD       arg1;
     TItemPos       arg2;
     DWORD       arg3;
-	long		alValues[ITEM_SOCKET_SLOT_MAX_NUM];
+	LONG		alValues[ITEM_SOCKET_SLOT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
     TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
 } TPacketGCExchange;
 
@@ -2000,7 +2000,7 @@ typedef struct packet_quest_confirm
 {
     BYTE header;
     char msg[64+1];
-    long timeout;
+    LONG timeout; // PORT: LONG, the 32-bit Win32 long
     DWORD requestPID;
 } TPacketGCQuestConfirm;
 
@@ -2021,8 +2021,8 @@ typedef struct packet_c2c
 typedef struct packetd_sync_position_element 
 { 
     DWORD       dwVID; 
-    long        lX; 
-    long        lY; 
+    LONG        lX; // PORT: LONG, the 32-bit Win32 long
+    LONG        lY; // PORT: LONG, the 32-bit Win32 long
 } TPacketGCSyncPositionElement; 
 
 typedef struct packetd_sync_position
@@ -2291,7 +2291,7 @@ typedef struct SPacketGuildWarPoint
 {
     DWORD dwGainGuildID;
     DWORD dwOpponentGuildID;
-    long lPoint;
+    LONG lPoint; // PORT: LONG, the 32-bit Win32 long
 } TPacketGuildWarPoint;
 
 // SubHeader - Dungeon
@@ -2419,8 +2419,8 @@ struct TNPCPosition
 {
     BYTE bType;
     char name[CHARACTER_NAME_MAX_LEN+1];
-    long x;
-    long y;
+    LONG x; // PORT: LONG, the 32-bit Win32 long
+    LONG y; // PORT: LONG, the 32-bit Win32 long
 };
 
 typedef struct SPacketGCChangeName
@@ -2495,7 +2495,7 @@ typedef struct SEquipmentItemSet
 {
 	DWORD   vnum;
 	BYTE    count;
-	long    alSockets[ITEM_SOCKET_SLOT_MAX_NUM];
+	LONG    alSockets[ITEM_SOCKET_SLOT_MAX_NUM]; // PORT: LONG, the 32-bit Win32 long
 	TPlayerItemAttribute aAttr[ITEM_ATTRIBUTE_SLOT_MAX_NUM];
 } TEquipmentItemSet;
 
@@ -2509,8 +2509,8 @@ typedef struct pakcet_view_equip
 typedef struct
 {
     DWORD       dwID;
-    long        x, y;
-    long        width, height;
+    LONG        x, y; // PORT: LONG, the 32-bit Win32 long
+    LONG        width, height; // PORT: LONG, the 32-bit Win32 long
     DWORD       dwGuildID;
 } TLandPacketElement;
 
@@ -2523,7 +2523,7 @@ typedef struct packet_land_list
 typedef struct
 {
     BYTE        bHeader;
-    long        lID;
+    LONG        lID; // PORT: LONG, the 32-bit Win32 long
     char        szTargetName[32+1];
 } TPacketGCTargetCreate;
 
@@ -2537,7 +2537,7 @@ enum
 typedef struct
 {
 	BYTE		bHeader;
-	long		lID;
+	LONG		lID; // PORT: LONG, the 32-bit Win32 long
 	char		szTargetName[32+1];
 	DWORD		dwVID;
 	BYTE		byType;
@@ -2546,24 +2546,24 @@ typedef struct
 typedef struct
 {
     BYTE        bHeader;
-    long        lID;
-    long        lX, lY;
+    LONG        lID; // PORT: LONG, the 32-bit Win32 long
+    LONG        lX, lY; // PORT: LONG, the 32-bit Win32 long
 } TPacketGCTargetUpdate;
 
 typedef struct
 {
     BYTE        bHeader;
-    long        lID;
+    LONG        lID; // PORT: LONG, the 32-bit Win32 long
 } TPacketGCTargetDelete;
 
 typedef struct
 {
     DWORD       dwType;
     BYTE        bPointIdxApplyOn;
-    long        lApplyValue;
+    LONG        lApplyValue; // PORT: LONG, the 32-bit Win32 long
     DWORD       dwFlag;
-    long        lDuration;
-    long        lSPCost;
+    LONG        lDuration; // PORT: LONG, the 32-bit Win32 long
+    LONG        lSPCost; // PORT: LONG, the 32-bit Win32 long
 } TPacketAffectElement;
 
 typedef struct 

extension/src/port/UserInterface/ProcessCRC.h

@@ -0,0 +1,6 @@
+#pragma once
+
+extern bool GetExeCRC(DWORD & r_dwProcCRC, DWORD & r_dwFileCRC);
+
+extern void BuildProcessCRC();
+extern BYTE GetProcessCRCMagicCubePiece();

extension/src/port/UserInterface/PythonNetworkStream.cpp

@@ -0,0 +1,911 @@
+#include "StdAfx.h"
+#include "../EterLib/NetPacketHeaderMap.h"
+
+#include "PythonNetworkStream.h"
+#include "Packet.h"
+#include "NetworkActorManager.h"
+
+#include "GuildMarkDownloader.h"
+#include "GuildMarkUploader.h"
+#include "MarkManager.h"
+
+#include "ProcessCRC.h"
+
+// MARK_BUG_FIX
+static DWORD gs_nextDownloadMarkTime = 0;
+// END_OF_MARK_BUG_FIX
+
+// Packet ---------------------------------------------------------------------------
+class CMainPacketHeaderMap : public CNetworkPacketHeaderMap
+{
+	public:
+		enum
+		{
+			STATIC_SIZE_PACKET = false,
+			DYNAMIC_SIZE_PACKET = true,
+		};
+
+	public:
+		CMainPacketHeaderMap()
+		{
+			Set(HEADER_GC_EMPIRE,				CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCEmpire), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_WARP,					CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCWarp), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_SKILL_COOLTIME_END,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSkillCoolTimeEnd), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_QUEST_INFO,			CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuestInfo), DYNAMIC_SIZE_PACKET));
+			Set(HEADER_GC_REQUEST_MAKE_GUILD,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBlank), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_PVP,					CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPVP), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_DUEL_START,			CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDuelStart), DYNAMIC_SIZE_PACKET));
+			Set(HEADER_GC_CHARACTER_ADD,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterAdd), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_CHAR_ADDITIONAL_INFO,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterAdditionalInfo), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_CHARACTER_ADD2,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterAdd2), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_CHARACTER_UPDATE,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterUpdate), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_CHARACTER_UPDATE2,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterUpdate2), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_CHARACTER_DEL,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCharacterDelete), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_CHARACTER_MOVE,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMove), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_CHAT,					CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChat), DYNAMIC_SIZE_PACKET));
+
+			Set(HEADER_GC_SYNC_POSITION,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCC2C), DYNAMIC_SIZE_PACKET));
+
+			Set(HEADER_GC_LOGIN_SUCCESS3,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoginSuccess3), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_LOGIN_SUCCESS4,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoginSuccess4), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_LOGIN_FAILURE,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoginFailure), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_PLAYER_CREATE_SUCCESS,		 CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPlayerCreateSuccess), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_PLAYER_CREATE_FAILURE,		 CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCreateFailure), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_PLAYER_DELETE_SUCCESS,		 CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBlank), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_PLAYER_DELETE_WRONG_SOCIAL_ID, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBlank), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_STUN,					CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCStun), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_DEAD,					CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDead), STATIC_SIZE_PACKET));
+			
+			Set(HEADER_GC_MAIN_CHARACTER,			CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMainCharacter), STATIC_SIZE_PACKET));
+
+			// SUPPORT_BGM
+			Set(HEADER_GC_MAIN_CHARACTER2_EMPIRE,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMainCharacter2_EMPIRE), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_MAIN_CHARACTER3_BGM,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMainCharacter3_BGM), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_MAIN_CHARACTER4_BGM_VOL,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMainCharacter4_BGM_VOL), STATIC_SIZE_PACKET));
+			// END_OFSUPPORT_BGM
+
+			Set(HEADER_GC_PLAYER_POINTS,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPoints), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_PLAYER_POINT_CHANGE,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPointChange), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_ITEM_SET,				CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemSet), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_ITEM_SET2,			CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemSet2), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_ITEM_USE,				CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemUse), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_ITEM_UPDATE,			CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemUpdate), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_ITEM_GROUND_ADD,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemGroundAdd), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_ITEM_GROUND_DEL,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemGroundDel), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_ITEM_OWNERSHIP,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemOwnership), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_QUICKSLOT_ADD,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuickSlotAdd), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_QUICKSLOT_DEL,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuickSlotDel), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_QUICKSLOT_SWAP,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuickSlotSwap), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_WHISPER,				CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCWhisper), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_CHARACTER_POSITION,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPosition), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_MOTION,				CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMotion), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_SHOP,			CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCShop), DYNAMIC_SIZE_PACKET));
+			Set(HEADER_GC_SHOP_SIGN,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCShopSign), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_EXCHANGE,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCExchange), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_PING,			CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPing), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_SCRIPT,			CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCScript), DYNAMIC_SIZE_PACKET));
+			Set(HEADER_GC_QUEST_CONFIRM,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCQuestConfirm), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_TARGET,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTarget), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_MOUNT,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMount), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_CHANGE_SPEED,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChangeSpeed), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_HANDSHAKE,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCHandshake), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_HANDSHAKE_OK,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBlank), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_BINDUDP,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCBindUDP), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_OWNERSHIP,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCOwnership), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_CREATE_FLY,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCCreateFly), STATIC_SIZE_PACKET));
+#ifdef _IMPROVED_PACKET_ENCRYPTION_
+			Set(HEADER_GC_KEY_AGREEMENT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketKeyAgreement), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_KEY_AGREEMENT_COMPLETED, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketKeyAgreementCompleted), STATIC_SIZE_PACKET));
+#endif
+			Set(HEADER_GC_ADD_FLY_TARGETING, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCFlyTargeting), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_FLY_TARGETING, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCFlyTargeting), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_PHASE,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPhase), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_SKILL_LEVEL,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSkillLevel), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_SKILL_LEVEL_NEW,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSkillLevelNew), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_MESSENGER,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMessenger), DYNAMIC_SIZE_PACKET));
+			Set(HEADER_GC_GUILD,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCGuild), DYNAMIC_SIZE_PACKET));
+
+			Set(HEADER_GC_PARTY_INVITE,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyInvite), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_PARTY_ADD,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyAdd), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_PARTY_UPDATE,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyUpdate), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_PARTY_REMOVE,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyRemove), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_PARTY_LINK,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyLink), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_PARTY_UNLINK,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyUnlink), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_PARTY_PARAMETER,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCPartyParameter), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_SAFEBOX_SET,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemSet), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_SAFEBOX_DEL,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemDel), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_SAFEBOX_WRONG_PASSWORD,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSafeboxWrongPassword), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_SAFEBOX_SIZE,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSafeboxSize), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_SAFEBOX_MONEY_CHANGE,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSafeboxMoneyChange), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_FISHING,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCFishing), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_DUNGEON, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDungeon), DYNAMIC_SIZE_PACKET));
+			//Set(HEADER_GC_SLOW_TIMER, CNetworkPacketHeaderMap::TPacketType(sizeof(BYTE), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_TIME, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTime), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_WALK_MODE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCWalkMode), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_CHANGE_SKILL_GROUP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChangeSkillGroup), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_REFINE_INFORMATION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCRefineInformation), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_REFINE_INFORMATION_NEW, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCRefineInformationNew), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_SEPCIAL_EFFECT, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSpecialEffect), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_NPC_POSITION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCNPCPosition), DYNAMIC_SIZE_PACKET));
+			Set(HEADER_GC_CHANGE_NAME, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChangeName), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_CHINA_MATRIX_CARD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChinaMatrixCard), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_RUNUP_MATRIX_QUIZ, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCRunupMatrixQuiz), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_NEWCIBN_PASSPOD_REQUEST, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCNEWCIBNPasspodRequest), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_NEWCIBN_PASSPOD_FAILURE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCNEWCIBNPasspodFailure), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_LOGIN_KEY, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoginKey), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_AUTH_SUCCESS, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCAuthSuccess), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_AUTH_SUCCESS_OPENID, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCAuthSuccessOpenID), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_CHANNEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCChannel), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_VIEW_EQUIP, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCViewEquip), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_LAND_LIST, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLandList), DYNAMIC_SIZE_PACKET));
+
+			//Set(HEADER_GC_TARGET_CREATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTargetCreate), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_TARGET_UPDATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTargetUpdate), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_TARGET_DELETE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTargetDelete), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_TARGET_CREATE_NEW, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCTargetCreateNew), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_AFFECT_ADD, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCAffectAdd), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_AFFECT_REMOVE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCAffectRemove), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_MALL_OPEN, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCMallOpen), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_MALL_SET, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemSet), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_MALL_DEL, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCItemDel), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_LOVER_INFO, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLoverInfo), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_LOVE_POINT_UPDATE, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCLovePointUpdate), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_DIG_MOTION, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDigMotion), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_DAMAGE_INFO, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDamageInfo), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_HS_REQUEST, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketHSCheck), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_XTRAP_CS1_REQUEST, CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketXTrapCSVerify), STATIC_SIZE_PACKET));
+
+			Set(HEADER_GC_HYBRIDCRYPT_KEYS,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCHybridCryptKeys), DYNAMIC_SIZE_PACKET));
+			Set(HEADER_GC_HYBRIDCRYPT_SDB,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCHybridSDB), DYNAMIC_SIZE_PACKET));
+			Set(HEADER_GC_SPECIFIC_EFFECT,	CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCSpecificEffect), STATIC_SIZE_PACKET));
+			Set(HEADER_GC_DRAGON_SOUL_REFINE,		CNetworkPacketHeaderMap::TPacketType(sizeof(TPacketGCDragonSoulRefine), STATIC_SIZE_PACKET));
+			
+		}
+};
+
+int g_iLastPacket[2] = { 0, 0 };
+
+void CPythonNetworkStream::ExitApplication()
+{
+	if (__IsNotPing())
+	{
+		AbsoluteExitApplication();
+	}
+	else
+	{
+		SendChatPacket("/quit");
+	}
+}
+
+void CPythonNetworkStream::ExitGame()
+{
+	if (__IsNotPing())
+	{
+		LogOutGame();
+	}
+	else
+	{
+		SendChatPacket("/phase_select");
+	}
+}
+
+
+void CPythonNetworkStream::LogOutGame()
+{
+	if (__IsNotPing())
+	{		
+		AbsoluteExitGame();
+	}	
+	else
+	{
+		SendChatPacket("/logout");
+	}
+}
+
+void CPythonNetworkStream::AbsoluteExitGame()
+{
+	if (!IsOnline())
+		return;
+
+	OnRemoteDisconnect();		
+	Disconnect();
+}
+
+void CPythonNetworkStream::AbsoluteExitApplication()
+{
+	PostQuitMessage(0);
+}
+
+bool CPythonNetworkStream::__IsNotPing()
+{
+	// 원래는 핑이 안올때 체크이나 서버랑 정확히 맞추어야 한다.
+	return false;
+}
+
+DWORD CPythonNetworkStream::GetGuildID()
+{
+	return m_dwGuildID;
+}
+
+UINT CPythonNetworkStream::UploadMark(const char * c_szImageFileName)
+{
+	// MARK_BUG_FIX
+	// 길드를 만든 직후는 길드 아이디가 0이다.
+	if (0 == m_dwGuildID)
+		return ERROR_MARK_UPLOAD_NEED_RECONNECT;
+
+	gs_nextDownloadMarkTime = 0;
+	// END_OF_MARK_BUG_FIX
+
+	UINT uError=ERROR_UNKNOWN;
+	CGuildMarkUploader& rkGuildMarkUploader=CGuildMarkUploader::Instance();
+	if (!rkGuildMarkUploader.Connect(m_kMarkAuth.m_kNetAddr, m_kMarkAuth.m_dwHandle, m_kMarkAuth.m_dwRandomKey, m_dwGuildID, c_szImageFileName, &uError))
+	{
+		switch (uError)
+		{
+			case CGuildMarkUploader::ERROR_CONNECT:
+				return ERROR_CONNECT_MARK_SERVER;
+				break;
+			case CGuildMarkUploader::ERROR_LOAD:
+				return ERROR_LOAD_MARK;
+				break;
+			case CGuildMarkUploader::ERROR_WIDTH:
+				return ERROR_MARK_WIDTH;
+				break;
+			case CGuildMarkUploader::ERROR_HEIGHT:
+				return ERROR_MARK_HEIGHT;
+				break;
+			default:
+				return ERROR_UNKNOWN;
+		}
+	}
+
+	// MARK_BUG_FIX	
+	__DownloadMark();
+	// END_OF_MARK_BUG_FIX
+	
+	if (CGuildMarkManager::INVALID_MARK_ID == CGuildMarkManager::Instance().GetMarkID(m_dwGuildID))
+		return ERROR_MARK_CHECK_NEED_RECONNECT;
+
+	return ERROR_NONE;
+}
+
+UINT CPythonNetworkStream::UploadSymbol(const char* c_szImageFileName)
+{
+	UINT uError=ERROR_UNKNOWN;
+	CGuildMarkUploader& rkGuildMarkUploader=CGuildMarkUploader::Instance();
+	if (!rkGuildMarkUploader.ConnectToSendSymbol(m_kMarkAuth.m_kNetAddr, m_kMarkAuth.m_dwHandle, m_kMarkAuth.m_dwRandomKey, m_dwGuildID, c_szImageFileName, &uError))
+	{
+		switch (uError)
+		{
+			case CGuildMarkUploader::ERROR_CONNECT:
+				return ERROR_CONNECT_MARK_SERVER;
+				break;
+			case CGuildMarkUploader::ERROR_LOAD:
+				return ERROR_LOAD_MARK;
+				break;
+			case CGuildMarkUploader::ERROR_WIDTH:
+				return ERROR_MARK_WIDTH;
+				break;
+			case CGuildMarkUploader::ERROR_HEIGHT:
+				return ERROR_MARK_HEIGHT;
+				break;
+			default:
+				return ERROR_UNKNOWN;
+		}
+	}
+
+	return ERROR_NONE;
+}
+
+void CPythonNetworkStream::__DownloadMark()
+{
+	// 3분 안에는 다시 접속하지 않는다.
+	DWORD curTime = ELTimer_GetMSec();
+
+	if (curTime < gs_nextDownloadMarkTime)
+		return;
+
+	gs_nextDownloadMarkTime = curTime + 60000 * 3; // 3분
+
+	CGuildMarkDownloader& rkGuildMarkDownloader = CGuildMarkDownloader::Instance();
+	rkGuildMarkDownloader.Connect(m_kMarkAuth.m_kNetAddr, m_kMarkAuth.m_dwHandle, m_kMarkAuth.m_dwRandomKey);
+}
+
+void CPythonNetworkStream::__DownloadSymbol(const std::vector<DWORD> & c_rkVec_dwGuildID)
+{
+	CGuildMarkDownloader& rkGuildMarkDownloader=CGuildMarkDownloader::Instance();
+	rkGuildMarkDownloader.ConnectToRecvSymbol(m_kMarkAuth.m_kNetAddr, m_kMarkAuth.m_dwHandle, m_kMarkAuth.m_dwRandomKey, c_rkVec_dwGuildID);
+}
+
+void CPythonNetworkStream::SetPhaseWindow(UINT ePhaseWnd, PyObject* poPhaseWnd)
+{
+	if (ePhaseWnd>=PHASE_WINDOW_NUM)
+		return;
+
+	m_apoPhaseWnd[ePhaseWnd]=poPhaseWnd;
+}
+
+void CPythonNetworkStream::ClearPhaseWindow(UINT ePhaseWnd, PyObject* poPhaseWnd)
+{
+	if (ePhaseWnd>=PHASE_WINDOW_NUM)
+		return;
+
+	if (poPhaseWnd != m_apoPhaseWnd[ePhaseWnd])
+		return;
+
+	m_apoPhaseWnd[ePhaseWnd]=0;
+}
+
+void CPythonNetworkStream::SetServerCommandParserWindow(PyObject* poWnd)
+{
+	m_poSerCommandParserWnd = poWnd;
+}
+
+bool CPythonNetworkStream::IsSelectedEmpire()
+{
+	if (m_dwEmpireID)
+		return true;
+	
+	return false;
+}
+
+UINT CPythonNetworkStream::GetAccountCharacterSlotDatau(UINT iSlot, UINT eType)
+{
+	if (iSlot >= PLAYER_PER_ACCOUNT4)
+		return 0;
+		
+	TSimplePlayerInformation&	rkSimplePlayerInfo=m_akSimplePlayerInfo[iSlot];
+	
+	switch (eType)
+	{
+		case ACCOUNT_CHARACTER_SLOT_ID:
+			return rkSimplePlayerInfo.dwID;
+		case ACCOUNT_CHARACTER_SLOT_RACE:
+			return rkSimplePlayerInfo.byJob;
+		case ACCOUNT_CHARACTER_SLOT_LEVEL:
+			return rkSimplePlayerInfo.byLevel;
+		case ACCOUNT_CHARACTER_SLOT_STR:
+			return rkSimplePlayerInfo.byST;
+		case ACCOUNT_CHARACTER_SLOT_DEX:
+			return rkSimplePlayerInfo.byDX;
+		case ACCOUNT_CHARACTER_SLOT_HTH:
+			return rkSimplePlayerInfo.byHT;
+		case ACCOUNT_CHARACTER_SLOT_INT:			
+			return rkSimplePlayerInfo.byIQ;
+		case ACCOUNT_CHARACTER_SLOT_PLAYTIME:
+			return rkSimplePlayerInfo.dwPlayMinutes;
+		case ACCOUNT_CHARACTER_SLOT_FORM:
+//			return rkSimplePlayerInfo.wParts[CRaceData::PART_MAIN];
+			return rkSimplePlayerInfo.wMainPart;
+		case ACCOUNT_CHARACTER_SLOT_PORT:
+			return rkSimplePlayerInfo.wPort;
+		case ACCOUNT_CHARACTER_SLOT_GUILD_ID:
+			return m_adwGuildID[iSlot];
+			break;
+		case ACCOUNT_CHARACTER_SLOT_CHANGE_NAME_FLAG:
+			return rkSimplePlayerInfo.bChangeName;
+			break;
+		case ACCOUNT_CHARACTER_SLOT_HAIR:
+			return rkSimplePlayerInfo.wHairPart;
+			break;
+	}
+	return 0;
+}
+
+const char* CPythonNetworkStream::GetAccountCharacterSlotDataz(UINT iSlot, UINT eType)
+{
+	static const char* sc_szEmpty="";
+
+	if (iSlot >= PLAYER_PER_ACCOUNT4)
+		return sc_szEmpty;
+		
+	TSimplePlayerInformation&	rkSimplePlayerInfo=m_akSimplePlayerInfo[iSlot];
+	
+	switch (eType)
+	{
+		case ACCOUNT_CHARACTER_SLOT_ADDR:
+			{				
+				BYTE ip[4];
+
+				const int LEN = 4;
+				for (int i = 0; i < LEN; i++)
+				{
+					ip[i] = BYTE(rkSimplePlayerInfo.lAddr&0xff);
+					rkSimplePlayerInfo.lAddr>>=8;
+				}
+
+
+				static char s_szAddr[256];
+				sprintf(s_szAddr, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
+				return s_szAddr;
+			}
+			break;
+		case ACCOUNT_CHARACTER_SLOT_NAME:
+			return rkSimplePlayerInfo.szName;
+			break;		
+		case ACCOUNT_CHARACTER_SLOT_GUILD_NAME:
+			return m_astrGuildName[iSlot].c_str();
+			break;
+	}
+	return sc_szEmpty;
+}
+
+void CPythonNetworkStream::ConnectLoginServer(const char* c_szAddr, UINT uPort)
+{
+	CNetworkStream::Connect(c_szAddr, uPort);		
+}
+
+void CPythonNetworkStream::SetMarkServer(const char* c_szAddr, UINT uPort)
+{
+	m_kMarkAuth.m_kNetAddr.Set(c_szAddr, uPort);
+}
+
+void CPythonNetworkStream::ConnectGameServer(UINT iChrSlot)
+{
+	if (iChrSlot >= PLAYER_PER_ACCOUNT4)
+		return;
+
+	m_dwSelectedCharacterIndex = iChrSlot;
+
+	__DirectEnterMode_Set(iChrSlot);
+
+	TSimplePlayerInformation&	rkSimplePlayerInfo=m_akSimplePlayerInfo[iChrSlot];	
+	CNetworkStream::Connect((DWORD)rkSimplePlayerInfo.lAddr, rkSimplePlayerInfo.wPort);
+}
+
+void CPythonNetworkStream::SetLoginInfo(const char* c_szID, const char* c_szPassword)
+{
+	m_stID=c_szID;
+	m_stPassword=c_szPassword;
+}
+
+void CPythonNetworkStream::ClearLoginInfo( void )
+{
+	m_stPassword = "";
+}
+
+void CPythonNetworkStream::SetLoginKey(DWORD dwLoginKey)
+{
+	m_dwLoginKey = dwLoginKey;
+}
+
+bool CPythonNetworkStream::CheckPacket(TPacketHeader * pRetHeader)
+{
+	*pRetHeader = 0;
+
+	static CMainPacketHeaderMap s_packetHeaderMap;
+
+	TPacketHeader header;
+
+	if (!Peek(sizeof(TPacketHeader), &header))
+		return false;
+
+	if (0 == header)
+	{
+		if (!Recv(sizeof(TPacketHeader), &header))
+			return false;
+		
+		while (Peek(sizeof(TPacketHeader), &header))
+		{
+			if (0 == header)
+			{
+				if (!Recv(sizeof(TPacketHeader), &header))
+					return false;
+			}
+			else
+			{
+				break;
+			}
+		}
+
+		if (0 == header)
+			return false;
+	}
+
+	CNetworkPacketHeaderMap::TPacketType PacketType;
+
+	if (!s_packetHeaderMap.Get(header, &PacketType))
+	{
+		TraceError("Unknown packet header: %d, last: %d %d", header, g_iLastPacket[0], g_iLastPacket[1]);
+		ClearRecvBuffer();
+
+		PostQuitMessage(0);
+		return false;
+	}
+
+	// Code for dynamic size packet
+	if (PacketType.isDynamicSizePacket)
+	{
+		TDynamicSizePacketHeader DynamicSizePacketHeader;
+
+		if (!Peek(sizeof(TDynamicSizePacketHeader), &DynamicSizePacketHeader))
+			return false;
+
+		if (!Peek(DynamicSizePacketHeader.size))
+		{
+			Tracef("CPythonNetworkStream::CheckPacket - Not enough dynamic packet size: header %d packet size: %d\n", 
+				DynamicSizePacketHeader.header,
+				DynamicSizePacketHeader.size);
+			return false;
+		}
+	}
+	else
+	{
+		if (!Peek(PacketType.iPacketSize))
+		{
+			//Tracef("Not enough packet size: header %d packet size: %d, recv buffer size: %d",
+			//	header,
+			//	PacketType.iPacketSize,
+			//	GetRecvBufferSize());
+			return false;
+		}
+	}
+
+	if (!header)
+		return false;
+
+	*pRetHeader = header;	
+
+	g_iLastPacket[0] = g_iLastPacket[1];
+	g_iLastPacket[1] = header;
+	//Tracenf("header %d size %d", header, PacketType.iPacketSize);
+	//Tracenf("header %d size %d outputpos[%d] security %u", header, PacketType.iPacketSize, m_recvBufOutputPos, IsSecurityMode());
+	return true;
+}
+
+bool CPythonNetworkStream::RecvErrorPacket(int header)
+{
+	TraceError("Phase %s does not handle this header (header: %d, last: %d, %d)",
+		m_strPhase.c_str(), header, g_iLastPacket[0], g_iLastPacket[1]);
+
+	ClearRecvBuffer();
+	return true;
+}
+
+bool CPythonNetworkStream::RecvPhasePacket()
+{
+	TPacketGCPhase packet_phase;
+
+	if (!Recv(sizeof(TPacketGCPhase), &packet_phase))
+		return false;
+
+	switch (packet_phase.phase)
+	{
+		case PHASE_CLOSE:				// 끊기는 상태 (또는 끊기 전 상태)
+			ClosePhase();
+			break;
+
+		case PHASE_HANDSHAKE:			// 악수..;;
+			SetHandShakePhase();
+			break;
+
+		case PHASE_LOGIN:				// 로그인 중
+			SetLoginPhase();
+			break;
+
+		case PHASE_SELECT:				// 캐릭터 선택 화면
+			SetSelectPhase();
+#if defined(ENABLE_DISCORD_RPC)
+			Discord_Update(false);
+#endif
+
+			BuildProcessCRC();
+	
+			// MARK_BUG_FIX
+			__DownloadMark();
+			// END_OF_MARK_BUG_FIX
+			break;
+
+		case PHASE_LOADING:				// 선택 후 로딩 화면
+			SetLoadingPhase();
+			break;
+
+		case PHASE_GAME:				// 게임 화면
+			SetGamePhase();
+#if defined(ENABLE_DISCORD_RPC)
+			Discord_Update(true);
+#endif
+			break;
+
+		case PHASE_DEAD:				// 죽었을 때.. (게임 안에 있는 것일 수도..)
+			break;
+	}
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvPingPacket()
+{
+	Tracef("recv ping packet. (securitymode %u)\n", IsSecurityMode());
+
+	TPacketGCPing kPacketPing;
+
+	if (!Recv(sizeof(TPacketGCPing), &kPacketPing))
+		return false;
+
+	m_dwLastGamePingTime = ELTimer_GetMSec();
+
+	TPacketCGPong kPacketPong;
+	kPacketPong.bHeader = HEADER_CG_PONG;
+
+	if (!Send(sizeof(TPacketCGPong), &kPacketPong))
+		return false;
+
+	if (IsSecurityMode())
+		return SendSequence();
+	else
+		return true;
+}
+
+bool CPythonNetworkStream::RecvDefaultPacket(int header)
+{
+	if (!header)
+		return true;
+
+	TraceError("\xc3\xb3\xb8\xae\xb5\xc7\xc1\xf6 \xbe\xca\xc0\xba \xc6\xd0\xc5\xb6 \xc7\xec\xb4\xf5 %d, state %s\n", header, m_strPhase.c_str()); // PORT: CP949 bytes of "처리되지 않은 패킷 헤더 %d, state %s\n"
+	ClearRecvBuffer();
+	return true;
+}
+
+bool CPythonNetworkStream::OnProcess()
+{
+	if (m_isStartGame)
+	{
+		m_isStartGame = FALSE;
+
+		PyCallClassMemberFunc(m_poHandler, "SetGamePhase", Py_BuildValue("()"));
+//		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "StartGame", Py_BuildValue("()"));
+	}
+	
+	m_rokNetActorMgr->Update();
+
+	if (m_phaseProcessFunc.IsEmpty())
+		return true;
+
+	//TPacketHeader header;
+	//while(CheckPacket(&header))
+	{
+		m_phaseProcessFunc.Run();
+	}
+
+	return true;
+}
+
+
+// Set
+void CPythonNetworkStream::SetOffLinePhase()
+{
+	if ("OffLine" != m_strPhase)
+		m_phaseLeaveFunc.Run();
+
+	m_strPhase = "OffLine";
+
+	Tracen("");
+	Tracen("## Network - OffLine Phase ##");	
+	Tracen("");
+	
+#if defined(ENABLE_DISCORD_RPC)
+	Discord_Update(false);
+#endif
+
+	m_dwChangingPhaseTime = ELTimer_GetMSec();
+	m_phaseProcessFunc.Set(this, &CPythonNetworkStream::OffLinePhase);
+	m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveOfflinePhase);
+
+	SetGameOffline();
+
+	m_dwSelectedCharacterIndex = 0;
+
+	__DirectEnterMode_Initialize();
+	__BettingGuildWar_Initialize();
+}
+
+
+void CPythonNetworkStream::ClosePhase()
+{
+	PyCallClassMemberFunc(m_poHandler, "SetLoginPhase", Py_BuildValue("()"));
+}
+
+// Game Online
+void CPythonNetworkStream::SetGameOnline()
+{
+	m_isGameOnline = TRUE;
+}
+
+void CPythonNetworkStream::SetGameOffline()
+{
+	m_isGameOnline = FALSE;
+}
+
+BOOL CPythonNetworkStream::IsGameOnline()
+{
+	return m_isGameOnline;
+}
+
+// Handler
+void CPythonNetworkStream::SetHandler(PyObject* poHandler)
+{
+	m_poHandler = poHandler;
+}
+
+// ETC
+DWORD CPythonNetworkStream::GetMainActorVID()
+{
+	return m_dwMainActorVID;
+}
+
+DWORD CPythonNetworkStream::GetMainActorRace()
+{
+	return m_dwMainActorRace;
+}
+
+DWORD CPythonNetworkStream::GetMainActorEmpire()
+{
+	return m_dwMainActorEmpire;
+}
+
+DWORD CPythonNetworkStream::GetMainActorSkillGroup()
+{
+	return m_dwMainActorSkillGroup;
+}
+
+void CPythonNetworkStream::SetEmpireID(DWORD dwEmpireID)
+{
+	m_dwEmpireID = dwEmpireID;
+}
+
+DWORD CPythonNetworkStream::GetEmpireID()
+{
+	return m_dwEmpireID;
+}
+
+void CPythonNetworkStream::__ClearSelectCharacterData()
+{
+	NANOBEGIN
+	memset(&m_akSimplePlayerInfo, 0, sizeof(m_akSimplePlayerInfo));
+
+	for (int i = 0; i < PLAYER_PER_ACCOUNT4; ++i)
+	{
+		m_adwGuildID[i] = 0;
+		m_astrGuildName[i] = "";
+	}
+	NANOEND
+}
+
+void CPythonNetworkStream::__DirectEnterMode_Initialize()
+{
+	m_kDirectEnterMode.m_isSet=false;
+	m_kDirectEnterMode.m_dwChrSlotIndex=0;	
+}
+
+void CPythonNetworkStream::__DirectEnterMode_Set(UINT uChrSlotIndex)
+{
+	m_kDirectEnterMode.m_isSet=true;
+	m_kDirectEnterMode.m_dwChrSlotIndex=uChrSlotIndex;
+}
+
+bool CPythonNetworkStream::__DirectEnterMode_IsSet()
+{
+	return m_kDirectEnterMode.m_isSet;
+}
+
+void CPythonNetworkStream::__InitializeMarkAuth()
+{
+	m_kMarkAuth.m_dwHandle=0;
+	m_kMarkAuth.m_dwRandomKey=0;
+}
+
+void CPythonNetworkStream::__BettingGuildWar_Initialize()
+{
+	m_kBettingGuildWar.m_dwBettingMoney=0;
+	m_kBettingGuildWar.m_dwObserverCount=0;
+}
+
+void CPythonNetworkStream::__BettingGuildWar_SetObserverCount(UINT uObserverCount)
+{
+	m_kBettingGuildWar.m_dwObserverCount=uObserverCount;
+}
+
+void CPythonNetworkStream::__BettingGuildWar_SetBettingMoney(UINT uBettingMoney)
+{
+	m_kBettingGuildWar.m_dwBettingMoney=uBettingMoney;
+}
+
+DWORD CPythonNetworkStream::EXPORT_GetBettingGuildWarValue(const char* c_szValueName)
+{
+	if (stricmp(c_szValueName, "OBSERVER_COUNT") == 0)
+		return m_kBettingGuildWar.m_dwObserverCount;
+
+	if (stricmp(c_szValueName, "BETTING_MONEY") == 0)
+		return m_kBettingGuildWar.m_dwBettingMoney;
+
+	return 0;
+}
+
+void CPythonNetworkStream::__ServerTimeSync_Initialize()
+{
+	m_kServerTimeSync.m_dwChangeClientTime=0;
+	m_kServerTimeSync.m_dwChangeServerTime=0;
+}
+
+void CPythonNetworkStream::SetWaitFlag()
+{
+	m_isWaitLoginKey = TRUE;
+}
+
+void CPythonNetworkStream::SendEmoticon(UINT eEmoticon)
+{
+	if(eEmoticon < m_EmoticonStringVector.size())
+		SendChatPacket(m_EmoticonStringVector[eEmoticon].c_str());
+	else
+		assert(false && "SendEmoticon Error");
+}
+
+CPythonNetworkStream::CPythonNetworkStream()
+{
+	m_rokNetActorMgr=new CNetworkActorManager;
+
+	memset(m_akSimplePlayerInfo, 0, sizeof(m_akSimplePlayerInfo));
+
+	m_phaseProcessFunc.Clear();
+
+	m_dwEmpireID = 0;
+	m_dwGuildID = 0;
+
+	m_dwMainActorVID = 0;
+	m_dwMainActorRace = 0;
+	m_dwMainActorEmpire = 0;
+	m_dwMainActorSkillGroup = 0;
+	m_poHandler = NULL;
+
+	m_dwLastGamePingTime = 0;
+
+	m_dwLoginKey = 0;
+	m_isWaitLoginKey = FALSE;
+	m_isStartGame = FALSE;
+	m_isEnableChatInsultFilter = FALSE;
+	m_bComboSkillFlag = FALSE;
+	m_strPhase = "OffLine";
+	
+	__InitializeGamePhase();
+	__InitializeMarkAuth();
+
+	__DirectEnterMode_Initialize();
+	__BettingGuildWar_Initialize();
+
+	std::fill(m_apoPhaseWnd, m_apoPhaseWnd+PHASE_WINDOW_NUM, (PyObject*)NULL);
+	m_poSerCommandParserWnd = NULL;
+
+	SetOffLinePhase();
+}
+
+CPythonNetworkStream::~CPythonNetworkStream()
+{
+	Tracen("PythonNetworkMainStream Clear");
+}

extension/src/port/UserInterface/PythonNetworkStreamEvent.cpp

@@ -0,0 +1,18 @@
+#include "StdAfx.h"
+#include "PythonNetworkStream.h"
+
+void CPythonNetworkStream::OnRemoteDisconnect()
+{
+	PyCallClassMemberFunc(m_poHandler, "SetLoginPhase", Py_BuildValue("()"));
+}
+
+void CPythonNetworkStream::OnDisconnect()
+{
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Main Game
+void CPythonNetworkStream::OnScriptEventStart(int iSkin, int iIndex)
+{
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "OpenQuestWindow", Py_BuildValue("(ii)", iSkin, iIndex));
+}

extension/src/port/UserInterface/PythonNetworkStreamPhaseHandShake.cpp

@@ -0,0 +1,331 @@
+#include "StdAfx.h"
+#include "PythonNetworkStream.h"
+#include "PythonApplication.h"
+#include "Packet.h"
+#include "../EterPack/EterPackManager.h"
+#include "Hackshield.h"
+#include "WiseLogicXTrap.h"
+
+#ifdef USE_AHNLAB_HACKSHIELD
+#include METIN2HS_INCLUDE_HSHIELD
+#endif
+
+// HandShake ---------------------------------------------------------------------------
+void CPythonNetworkStream::HandShakePhase()
+{
+	TPacketHeader header;
+
+	if (!CheckPacket(&header))
+		return;
+
+	switch (header)
+	{
+		case HEADER_GC_PHASE:
+			if (RecvPhasePacket())
+				return;
+			break;
+
+		case HEADER_GC_BINDUDP:
+			{
+				TPacketGCBindUDP BindUDP;
+				
+				if (!Recv(sizeof(TPacketGCBindUDP), &BindUDP))
+					return;
+
+				return;
+			}
+			break;
+
+		case HEADER_GC_HANDSHAKE:
+			{
+				if (!Recv(sizeof(TPacketGCHandshake), &m_HandshakeData))
+					return;
+
+				Tracenf("HANDSHAKE RECV %u %d", m_HandshakeData.dwTime, m_HandshakeData.lDelta);
+
+				ELTimer_SetServerMSec(m_HandshakeData.dwTime+ m_HandshakeData.lDelta);
+
+				//m_dwBaseServerTime = m_HandshakeData.dwTime+ m_HandshakeData.lDelta;
+				//m_dwBaseClientTime = ELTimer_GetMSec();
+
+				m_HandshakeData.dwTime = m_HandshakeData.dwTime + m_HandshakeData.lDelta + m_HandshakeData.lDelta;
+				m_HandshakeData.lDelta = 0;
+
+				Tracenf("HANDSHAKE SEND %u", m_HandshakeData.dwTime);
+
+				if (!Send(sizeof(TPacketGCHandshake), &m_HandshakeData))
+				{
+					assert(!"Failed Sending Handshake");
+					return;
+				}
+
+				CTimer::Instance().SetBaseTime();
+				return;
+			}
+			break;
+		case HEADER_GC_PING:
+			RecvPingPacket();
+			return;
+			break;
+
+		case HEADER_GC_HYBRIDCRYPT_KEYS:
+			RecvHybridCryptKeyPacket();
+			return;
+			break;
+
+		case HEADER_GC_HYBRIDCRYPT_SDB:
+			RecvHybridCryptSDBPacket();
+			return;
+			break;
+
+#ifdef _IMPROVED_PACKET_ENCRYPTION_
+		case HEADER_GC_KEY_AGREEMENT:
+			RecvKeyAgreementPacket();
+			return;
+			break;
+
+		case HEADER_GC_KEY_AGREEMENT_COMPLETED:
+			RecvKeyAgreementCompletedPacket();
+			return;
+			break;
+#endif
+	}
+
+	RecvErrorPacket(header);
+}
+
+void CPythonNetworkStream::SetHandShakePhase()
+{
+	if ("HandShake"!=m_strPhase)
+		m_phaseLeaveFunc.Run();
+
+	Tracen("");
+	Tracen("## Network - Hand Shake Phase ##");
+	Tracen("");
+
+	m_strPhase = "HandShake";
+
+	m_dwChangingPhaseTime = ELTimer_GetMSec();
+	m_phaseProcessFunc.Set(this, &CPythonNetworkStream::HandShakePhase);
+	m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveHandshakePhase);
+
+	SetGameOnline();
+
+	if (__DirectEnterMode_IsSet())
+	{
+		// None
+	}
+	else
+	{
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "OnHandShake", Py_BuildValue("()"));
+	}
+}
+
+bool CPythonNetworkStream::RecvHandshakePacket()
+{
+	TPacketGCHandshake kHandshakeData;
+	if (!Recv(sizeof(TPacketGCHandshake), &kHandshakeData))
+		return false;
+
+	Tracenf("HANDSHAKE RECV %u %d", kHandshakeData.dwTime, kHandshakeData.lDelta);
+
+	m_kServerTimeSync.m_dwChangeServerTime = kHandshakeData.dwTime + kHandshakeData.lDelta;
+	m_kServerTimeSync.m_dwChangeClientTime = ELTimer_GetMSec();
+	
+	kHandshakeData.dwTime = kHandshakeData.dwTime + kHandshakeData.lDelta + kHandshakeData.lDelta;
+	kHandshakeData.lDelta = 0;
+
+	Tracenf("HANDSHAKE SEND %u", kHandshakeData.dwTime);
+
+	kHandshakeData.header = HEADER_CG_TIME_SYNC;
+	if (!Send(sizeof(TPacketGCHandshake), &kHandshakeData))
+	{
+		assert(!"Failed Sending Handshake");
+		return false;
+	}
+
+	SendSequence();
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvHandshakeOKPacket()
+{
+	TPacketGCBlank kBlankPacket;
+	if (!Recv(sizeof(TPacketGCBlank), &kBlankPacket))
+		return false;
+
+	DWORD dwDelta=ELTimer_GetMSec()-m_kServerTimeSync.m_dwChangeClientTime;
+	ELTimer_SetServerMSec(m_kServerTimeSync.m_dwChangeServerTime+dwDelta);
+
+	Tracenf("HANDSHAKE OK RECV %u %u", m_kServerTimeSync.m_dwChangeServerTime, dwDelta);
+
+	return true;
+}
+
+bool CPythonNetworkStream::RecvHybridCryptKeyPacket()
+{
+	int iFixedHeaderSize = TPacketGCHybridCryptKeys::GetFixedHeaderSize();
+
+	TDynamicSizePacketHeader header;
+	if( !Peek( sizeof(header), &header) )
+		return false;
+
+	TPacketGCHybridCryptKeys kPacket(header.size-iFixedHeaderSize);
+
+	if (!Recv(iFixedHeaderSize, &kPacket))
+		return false;
+
+	if (!Recv(kPacket.iKeyStreamLen, kPacket.m_pStream))
+		return false;
+
+	CEterPackManager::Instance().RetrieveHybridCryptPackKeys( kPacket.m_pStream ); 
+	return true;
+}
+
+bool CPythonNetworkStream::RecvHybridCryptSDBPacket()
+{
+	int iFixedHeaderSize = TPacketGCHybridSDB::GetFixedHeaderSize();
+
+	TDynamicSizePacketHeader header;
+	if( !Peek( sizeof(header), &header) )
+		return false;
+
+	TPacketGCHybridSDB kPacket(header.size-iFixedHeaderSize);
+
+	if (!Recv(iFixedHeaderSize, &kPacket))
+		return false;
+
+	if (!Recv(kPacket.iSDBStreamLen, kPacket.m_pStream))
+		return false;
+
+	CEterPackManager::Instance().RetrieveHybridCryptPackSDB( kPacket.m_pStream ); 
+	return true;
+}
+
+
+#ifdef _IMPROVED_PACKET_ENCRYPTION_
+bool CPythonNetworkStream::RecvKeyAgreementPacket()
+{
+	TPacketKeyAgreement packet;
+	if (!Recv(sizeof(packet), &packet))
+	{
+		return false;
+	}
+
+	Tracenf("KEY_AGREEMENT RECV %u", packet.wDataLength);
+
+	TPacketKeyAgreement packetToSend;
+	size_t dataLength = TPacketKeyAgreement::MAX_DATA_LEN;
+	size_t agreedLength = Prepare(packetToSend.data, &dataLength);
+	if (agreedLength == 0)
+	{
+		// 초기화 실패
+		Disconnect();
+		return false;
+	}
+	assert(dataLength <= TPacketKeyAgreement::MAX_DATA_LEN);
+
+	if (Activate(packet.wAgreedLength, packet.data, packet.wDataLength))
+	{
+		// Key agreement 성공, 응답 전송
+		packetToSend.bHeader = HEADER_CG_KEY_AGREEMENT;
+		packetToSend.wAgreedLength = (WORD)agreedLength;
+		packetToSend.wDataLength = (WORD)dataLength;
+
+		if (!Send(sizeof(packetToSend), &packetToSend))
+		{
+			assert(!"Failed Sending KeyAgreement");
+			return false;
+		}
+		Tracenf("KEY_AGREEMENT SEND %u", packetToSend.wDataLength);
+	}
+	else
+	{
+		// 키 협상 실패
+		Disconnect();
+		return false;
+	}
+	return true;
+}
+
+bool CPythonNetworkStream::RecvKeyAgreementCompletedPacket()
+{
+	TPacketKeyAgreementCompleted packet;
+	if (!Recv(sizeof(packet), &packet))
+	{
+		return false;
+	}
+
+	Tracenf("KEY_AGREEMENT_COMPLETED RECV");
+
+	ActivateCipher();
+
+	return true;
+}
+#endif // _IMPROVED_PACKET_ENCRYPTION_
+
+bool CPythonNetworkStream::RecvHSCheckRequest()
+{
+	TPacketHSCheck packet;
+
+	if (!Recv(sizeof(packet), &packet))
+	{
+		TraceError("HShield: Recv failed");
+
+		return false;
+	}
+
+#if defined(USE_AHNLAB_HACKSHIELD) || defined(LOCALE_SERVICE_GLOBAL)
+	TPacketHSCheck pack_ret;
+	memset(&pack_ret, 0, sizeof(pack_ret));
+	pack_ret.bHeader = HEADER_CG_HS_ACK;
+
+#if defined(USE_AHNLAB_HACKSHIELD)
+	unsigned long ret = _AhnHS_MakeResponse( packet.Req.byBuffer, packet.Req.nLength, &pack_ret.Req );
+
+	if (ERROR_SUCCESS != ret)
+	{
+		TraceError("HShield: _AhnHS_MakeResponse return error(%u)", ret);
+
+		return false;
+	}
+#endif
+
+	if (!Send(sizeof(pack_ret), &pack_ret))
+	{
+		TraceError("HShield: Send failed");
+
+		return false;
+	}
+
+	return true;
+#else
+	return false;
+#endif
+}
+
+bool CPythonNetworkStream::RecvXTrapVerifyRequest()
+{
+	TPacketXTrapCSVerify packet;
+
+	if (!Recv(sizeof(packet), &packet))
+	{
+		TraceError("XTrap: Recv failed");
+
+		return false;
+	}
+
+	TPacketXTrapCSVerify packet_res;
+	packet_res.bHeader = HEADER_CG_XTRAP_ACK;
+
+	XTrap_ValidateCheckStream( packet.bPacketData, packet_res.bPacketData );
+
+	if (!Send(sizeof(packet_res), &packet_res))
+	{
+		TraceError("XTrap: Send failed");
+		return false;
+	}
+
+	return true;
+}

extension/src/port/UserInterface/PythonNetworkStreamPhaseLoading.cpp

@@ -0,0 +1,361 @@
+#include "StdAfx.h"
+#include "PythonNetworkStream.h"
+#include "Packet.h"
+#include "PythonApplication.h"
+#include "NetworkActorManager.h"
+
+#include "AbstractPlayer.h"
+
+#include "../EterPack/EterPackManager.h"
+
+void CPythonNetworkStream::EnableChatInsultFilter(bool isEnable)
+{
+	m_isEnableChatInsultFilter=isEnable;
+}
+
+void CPythonNetworkStream::__FilterInsult(char* szLine, UINT uLineLen)
+{
+	m_kInsultChecker.FilterInsult(szLine, uLineLen);
+}
+
+bool CPythonNetworkStream::IsChatInsultIn(const char* c_szMsg)
+{
+	if (m_isEnableChatInsultFilter)
+		return false;
+
+	return IsInsultIn(c_szMsg);
+}
+
+bool CPythonNetworkStream::IsInsultIn(const char* c_szMsg)
+{
+	return m_kInsultChecker.IsInsultIn(c_szMsg, strlen(c_szMsg));
+}
+
+bool CPythonNetworkStream::LoadInsultList(const char* c_szInsultListFileName)
+{
+	CMappedFile file;
+	const VOID* pvData;
+	if (!CEterPackManager::Instance().Get(file, c_szInsultListFileName, &pvData))
+		return false;
+
+	CMemoryTextFileLoader kMemTextFileLoader;
+	kMemTextFileLoader.Bind(file.Size(), pvData);
+
+	m_kInsultChecker.Clear();
+	for (DWORD dwLineIndex=0; dwLineIndex<kMemTextFileLoader.GetLineCount(); ++dwLineIndex)
+	{
+		const std::string& c_rstLine=kMemTextFileLoader.GetLineString(dwLineIndex);		
+		m_kInsultChecker.AppendInsult(c_rstLine);
+	}
+	return true;
+}
+
+bool CPythonNetworkStream::LoadConvertTable(DWORD dwEmpireID, const char* c_szFileName)
+{
+	if (dwEmpireID<1 || dwEmpireID>=4)
+		return false;
+
+	CMappedFile file;
+	const VOID* pvData;
+	if (!CEterPackManager::Instance().Get(file, c_szFileName, &pvData))
+		return false;
+
+	DWORD dwEngCount=26;
+	DWORD dwHanCount=(0xc8-0xb0+1)*(0xfe - 0xa1+1); // PORT: `0xfe-0xa1` lexes as one pp-number (the `e-` exponent) outside MSVC
+	DWORD dwHanSize=dwHanCount*2;
+	DWORD dwFileSize=dwEngCount*2+dwHanSize;
+
+	if (file.Size()<dwFileSize)
+		return false;
+
+	char* pcData=(char*)pvData;
+
+	STextConvertTable& rkTextConvTable=m_aTextConvTable[dwEmpireID-1];		
+	memcpy(rkTextConvTable.acUpper, pcData, dwEngCount);pcData+=dwEngCount;
+	memcpy(rkTextConvTable.acLower, pcData, dwEngCount);pcData+=dwEngCount;
+	memcpy(rkTextConvTable.aacHan, pcData, dwHanSize);
+
+	return true;
+}
+
+// Loading ---------------------------------------------------------------------------
+void CPythonNetworkStream::LoadingPhase()
+{
+	TPacketHeader header;
+
+	if (!CheckPacket(&header))
+		return;
+
+	switch (header)
+	{
+		case HEADER_GC_PHASE:
+			if (RecvPhasePacket())
+				return;
+			break;
+
+		case HEADER_GC_MAIN_CHARACTER:
+			if (RecvMainCharacter())
+				return;
+			break;
+
+		// SUPPORT_BGM
+		case HEADER_GC_MAIN_CHARACTER2_EMPIRE:
+			if (RecvMainCharacter2_EMPIRE())
+				return;
+			break;
+
+		case HEADER_GC_MAIN_CHARACTER3_BGM:
+			if (RecvMainCharacter3_BGM())
+				return;
+			break;
+
+		case HEADER_GC_MAIN_CHARACTER4_BGM_VOL:
+			if (RecvMainCharacter4_BGM_VOL())
+				return;
+			break;
+
+		// END_OF_SUPPORT_BGM
+
+		case HEADER_GC_CHARACTER_UPDATE:
+			if (RecvCharacterUpdatePacket())
+				return;
+			break;
+
+		case HEADER_GC_PLAYER_POINTS:
+			if (__RecvPlayerPoints())
+				return;
+			break;
+
+		case HEADER_GC_PLAYER_POINT_CHANGE:
+			if (RecvPointChange())
+				return;
+			break;
+
+		case HEADER_GC_ITEM_SET:
+			if (RecvItemSetPacket())
+				return;
+			break;
+
+		case HEADER_GC_PING:
+			if (RecvPingPacket())
+				return;
+			break;
+
+		case HEADER_GC_QUICKSLOT_ADD:
+			if (RecvQuickSlotAddPacket())
+				return;
+			break;
+
+		case HEADER_GC_HYBRIDCRYPT_KEYS:
+			RecvHybridCryptKeyPacket();
+			return;
+			break;
+
+		case HEADER_GC_HYBRIDCRYPT_SDB:
+			RecvHybridCryptSDBPacket();
+			return;
+			break;
+
+
+		default:
+			GamePhase();
+			return;
+			break;
+	}
+
+	RecvErrorPacket(header);
+}
+
+void CPythonNetworkStream::SetLoadingPhase()
+{
+	if ("Loading"!=m_strPhase)
+		m_phaseLeaveFunc.Run();
+
+	Tracen("");
+	Tracen("## Network - Loading Phase ##");
+	Tracen("");
+
+	m_strPhase = "Loading";	
+
+	m_dwChangingPhaseTime = ELTimer_GetMSec();
+	m_phaseProcessFunc.Set(this, &CPythonNetworkStream::LoadingPhase);
+	m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveLoadingPhase);
+
+	CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
+	rkPlayer.Clear();
+
+	CFlyingManager::Instance().DeleteAllInstances();
+	CEffectManager::Instance().DeleteAllInstances();
+
+	__DirectEnterMode_Initialize();
+}
+
+bool CPythonNetworkStream::RecvMainCharacter()
+{
+	TPacketGCMainCharacter MainChrPacket;
+	if (!Recv(sizeof(TPacketGCMainCharacter), &MainChrPacket))
+		return false;
+
+	m_dwMainActorVID = MainChrPacket.dwVID;
+	m_dwMainActorRace = MainChrPacket.wRaceNum;
+	m_dwMainActorEmpire = 0;
+	m_dwMainActorSkillGroup = MainChrPacket.bySkillGroup;
+
+	m_rokNetActorMgr->SetMainActorVID(m_dwMainActorVID);
+
+	CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
+	rkPlayer.SetName(MainChrPacket.szName);
+	rkPlayer.SetMainCharacterIndex(GetMainActorVID());
+
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOAD], "LoadData", Py_BuildValue("(ii)", MainChrPacket.lX, MainChrPacket.lY));
+
+	//Tracef(" >> RecvMainCharacter\n");
+
+	SendClientVersionPacket();
+	return true;
+}
+
+// SUPPORT_BGM
+bool CPythonNetworkStream::RecvMainCharacter2_EMPIRE()
+{
+	TPacketGCMainCharacter2_EMPIRE mainChrPacket;
+	if (!Recv(sizeof(mainChrPacket), &mainChrPacket))
+		return false;
+
+	m_dwMainActorVID = mainChrPacket.dwVID;
+	m_dwMainActorRace = mainChrPacket.wRaceNum;
+	m_dwMainActorEmpire = mainChrPacket.byEmpire;
+	m_dwMainActorSkillGroup = mainChrPacket.bySkillGroup;
+
+	m_rokNetActorMgr->SetMainActorVID(m_dwMainActorVID);
+
+	CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
+	rkPlayer.SetName(mainChrPacket.szName);
+	rkPlayer.SetMainCharacterIndex(GetMainActorVID());
+
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOAD], "LoadData", Py_BuildValue("(ii)", mainChrPacket.lX, mainChrPacket.lY));
+
+	//Tracef(" >> RecvMainCharacterNew : %d\n", m_dwMainActorEmpire);
+
+	SendClientVersionPacket();
+	return true;
+}
+
+bool CPythonNetworkStream::RecvMainCharacter3_BGM()
+{
+	TPacketGCMainCharacter3_BGM mainChrPacket;
+	if (!Recv(sizeof(mainChrPacket), &mainChrPacket))
+		return false;
+
+	m_dwMainActorVID = mainChrPacket.dwVID;
+	m_dwMainActorRace = mainChrPacket.wRaceNum;
+	m_dwMainActorEmpire = mainChrPacket.byEmpire;
+	m_dwMainActorSkillGroup = mainChrPacket.bySkillGroup;
+
+	m_rokNetActorMgr->SetMainActorVID(m_dwMainActorVID);
+
+	CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
+	rkPlayer.SetName(mainChrPacket.szUserName);
+	rkPlayer.SetMainCharacterIndex(GetMainActorVID());
+
+	__SetFieldMusicFileName(mainChrPacket.szBGMName);
+
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOAD], "LoadData", Py_BuildValue("(ii)", mainChrPacket.lX, mainChrPacket.lY));
+
+	//Tracef(" >> RecvMainCharacterNew : %d\n", m_dwMainActorEmpire);
+
+	SendClientVersionPacket();
+	return true;
+}
+
+bool CPythonNetworkStream::RecvMainCharacter4_BGM_VOL()
+{
+	TPacketGCMainCharacter4_BGM_VOL mainChrPacket;
+	if (!Recv(sizeof(mainChrPacket), &mainChrPacket))
+		return false;
+
+	m_dwMainActorVID = mainChrPacket.dwVID;
+	m_dwMainActorRace = mainChrPacket.wRaceNum;
+	m_dwMainActorEmpire = mainChrPacket.byEmpire;
+	m_dwMainActorSkillGroup = mainChrPacket.bySkillGroup;
+
+	m_rokNetActorMgr->SetMainActorVID(m_dwMainActorVID);
+
+	CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
+	rkPlayer.SetName(mainChrPacket.szUserName);
+	rkPlayer.SetMainCharacterIndex(GetMainActorVID());
+
+	__SetFieldMusicFileInfo(mainChrPacket.szBGMName, mainChrPacket.fBGMVol);
+
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOAD], "LoadData", Py_BuildValue("(ii)", mainChrPacket.lX, mainChrPacket.lY));
+
+	//Tracef(" >> RecvMainCharacterNew : %d\n", m_dwMainActorEmpire);
+
+	SendClientVersionPacket();
+	return true;
+}
+
+
+static std::string	gs_fieldMusic_fileName;
+static float		gs_fieldMusic_volume = 1.0f / 5.0f * 0.1f;
+
+void CPythonNetworkStream::__SetFieldMusicFileName(const char* musicName)
+{
+	gs_fieldMusic_fileName = musicName;
+}
+
+void CPythonNetworkStream::__SetFieldMusicFileInfo(const char* musicName, float vol)
+{
+	gs_fieldMusic_fileName = musicName;
+	gs_fieldMusic_volume = vol;
+}
+
+const char* CPythonNetworkStream::GetFieldMusicFileName()
+{
+	return gs_fieldMusic_fileName.c_str();	
+}
+
+float CPythonNetworkStream::GetFieldMusicVolume()
+{
+	return gs_fieldMusic_volume;
+}
+// END_OF_SUPPORT_BGM
+
+
+bool CPythonNetworkStream::__RecvPlayerPoints()
+{
+	TPacketGCPoints PointsPacket;
+
+	if (!Recv(sizeof(TPacketGCPoints), &PointsPacket))
+		return false;
+
+	for (DWORD i = 0; i < POINT_MAX_NUM; ++i)
+		CPythonPlayer::Instance().SetStatus(i, PointsPacket.points[i]);
+
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_GAME], "RefreshStatus", Py_BuildValue("()"));
+	return true;
+}
+
+void CPythonNetworkStream::StartGame()
+{
+	m_isStartGame=TRUE;
+}
+	
+bool CPythonNetworkStream::SendEnterGame()
+{
+	TPacketCGEnterFrontGame EnterFrontGamePacket;
+
+	EnterFrontGamePacket.header = HEADER_CG_ENTERGAME;
+
+	if (!Send(sizeof(EnterFrontGamePacket), &EnterFrontGamePacket))
+	{
+		Tracen("Send EnterFrontGamePacket");
+		return false;
+	}
+
+	if (!SendSequence())
+		return false;
+
+	__SendInternalBuffer();
+	return true;
+}

extension/src/port/UserInterface/PythonNetworkStreamPhaseLogin.cpp

@@ -0,0 +1,416 @@
+#include "StdAfx.h"
+#include "PythonNetworkStream.h"
+#include "Packet.h"
+#include "Test.h"
+#include "AccountConnector.h"
+
+#include "Hackshield.h"
+#include "WiseLogicXTrap.h"
+
+// Login ---------------------------------------------------------------------------
+void CPythonNetworkStream::LoginPhase()
+{
+	TPacketHeader header;
+	if (!CheckPacket(&header))
+		return;
+
+	switch (header)
+	{
+		case HEADER_GC_PHASE:
+			if (RecvPhasePacket())
+				return;
+			break;
+
+		case HEADER_GC_LOGIN_SUCCESS3:
+			if (__RecvLoginSuccessPacket3())
+				return;
+			break;
+		case HEADER_GC_LOGIN_SUCCESS4:
+			if (__RecvLoginSuccessPacket4())
+				return;
+			break;
+
+
+		case HEADER_GC_LOGIN_FAILURE:
+			if (__RecvLoginFailurePacket())
+				return;		
+			break;
+
+		case HEADER_GC_EMPIRE:
+			if (__RecvEmpirePacket())
+				return;
+			break;
+
+		case HEADER_GC_CHINA_MATRIX_CARD:
+			if (__RecvChinaMatrixCardPacket())
+				return;
+			break;
+
+		case HEADER_GC_RUNUP_MATRIX_QUIZ:
+			if (__RecvRunupMatrixQuizPacket())
+				return;
+			break;
+
+		case HEADER_GC_NEWCIBN_PASSPOD_REQUEST:
+			if (__RecvNEWCIBNPasspodRequestPacket())
+				return;
+			break;
+		case HEADER_GC_NEWCIBN_PASSPOD_FAILURE:
+			if (__RecvNEWCIBNPasspodFailurePacket())
+				return;
+			break;
+
+
+		case HEADER_GC_LOGIN_KEY:
+			if (__RecvLoginKeyPacket())
+				return;
+			break;
+
+		case HEADER_GC_PING:
+			if (RecvPingPacket())
+				return;
+			break;
+
+		case HEADER_GC_HYBRIDCRYPT_KEYS:
+			RecvHybridCryptKeyPacket();
+			return;
+			break;
+
+		case HEADER_GC_HYBRIDCRYPT_SDB:
+			RecvHybridCryptSDBPacket();
+			return;
+			break;
+
+		default:
+			if (RecvDefaultPacket(header))
+				return;
+			break;
+	}
+
+	RecvErrorPacket(header);
+}
+
+void CPythonNetworkStream::SetLoginPhase()
+{
+	const char* key = LocaleService_GetSecurityKey();
+#ifndef _IMPROVED_PACKET_ENCRYPTION_
+	SetSecurityMode(true, key);
+#endif
+
+	if ("Login" != m_strPhase)
+		m_phaseLeaveFunc.Run();
+
+	Tracen("");
+	Tracen("## Network - Login Phase ##");
+	Tracen("");
+
+	m_strPhase = "Login";	
+
+	m_phaseProcessFunc.Set(this, &CPythonNetworkStream::LoginPhase);
+	m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveLoginPhase);
+
+	m_dwChangingPhaseTime = ELTimer_GetMSec();
+
+	if (__DirectEnterMode_IsSet())
+	{
+		if (0 != m_dwLoginKey)
+			SendLoginPacketNew(m_stID.c_str(), m_stPassword.c_str());
+		else
+			SendLoginPacket(m_stID.c_str(), m_stPassword.c_str());
+
+		// 비밀번호를 메모리에 계속 갖고 있는 문제가 있어서, 사용 즉시 날리는 것으로 변경
+		ClearLoginInfo();
+		CAccountConnector & rkAccountConnector = CAccountConnector::Instance();
+		rkAccountConnector.ClearLoginInfo();
+	}
+	else
+	{
+		if (0 != m_dwLoginKey)
+			SendLoginPacketNew(m_stID.c_str(), m_stPassword.c_str());
+		else
+			SendLoginPacket(m_stID.c_str(), m_stPassword.c_str());
+
+		// 비밀번호를 메모리에 계속 갖고 있는 문제가 있어서, 사용 즉시 날리는 것으로 변경
+		ClearLoginInfo();
+		CAccountConnector & rkAccountConnector = CAccountConnector::Instance();
+		rkAccountConnector.ClearLoginInfo();
+
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "OnLoginStart", Py_BuildValue("()"));
+
+		__ClearSelectCharacterData();
+	}
+}
+
+bool CPythonNetworkStream::__RecvEmpirePacket()
+{
+	TPacketGCEmpire kPacketEmpire;
+	if (!Recv(sizeof(kPacketEmpire), &kPacketEmpire))
+		return false;
+
+	m_dwEmpireID=kPacketEmpire.bEmpire;
+	return true;
+}
+
+bool CPythonNetworkStream::__RecvLoginSuccessPacket3()
+{
+	TPacketGCLoginSuccess3 kPacketLoginSuccess;
+
+	if (!Recv(sizeof(kPacketLoginSuccess), &kPacketLoginSuccess))
+		return false;	
+	
+	for (int i = 0; i<PLAYER_PER_ACCOUNT3; ++i)
+	{
+		m_akSimplePlayerInfo[i]=kPacketLoginSuccess.akSimplePlayerInformation[i];
+		m_adwGuildID[i]=kPacketLoginSuccess.guild_id[i];
+		m_astrGuildName[i]=kPacketLoginSuccess.guild_name[i];
+	}
+
+	m_kMarkAuth.m_dwHandle=kPacketLoginSuccess.handle;
+	m_kMarkAuth.m_dwRandomKey=kPacketLoginSuccess.random_key;	
+
+	if (__DirectEnterMode_IsSet())
+	{
+	}
+	else
+	{
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "Refresh", Py_BuildValue("()"));		
+	}
+
+	return true;
+}
+
+bool CPythonNetworkStream::__RecvLoginSuccessPacket4()
+{
+	TPacketGCLoginSuccess4 kPacketLoginSuccess;
+
+	if (!Recv(sizeof(kPacketLoginSuccess), &kPacketLoginSuccess))
+		return false;	
+	
+	for (int i = 0; i<PLAYER_PER_ACCOUNT4; ++i)
+	{
+		m_akSimplePlayerInfo[i]=kPacketLoginSuccess.akSimplePlayerInformation[i];
+		m_adwGuildID[i]=kPacketLoginSuccess.guild_id[i];
+		m_astrGuildName[i]=kPacketLoginSuccess.guild_name[i];
+	}
+
+	m_kMarkAuth.m_dwHandle=kPacketLoginSuccess.handle;
+	m_kMarkAuth.m_dwRandomKey=kPacketLoginSuccess.random_key;	
+
+	if (__DirectEnterMode_IsSet())
+	{
+	}
+	else
+	{
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "Refresh", Py_BuildValue("()"));		
+	}
+
+	return true;
+}
+
+
+void CPythonNetworkStream::OnConnectFailure()
+{
+	if (__DirectEnterMode_IsSet())
+	{
+		ClosePhase();
+	}
+	else
+	{
+		PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "OnConnectFailure", Py_BuildValue("()"));	
+	}
+}
+
+
+bool CPythonNetworkStream::__RecvLoginFailurePacket()
+{
+	TPacketGCLoginFailure packet_failure;
+	if (!Recv(sizeof(TPacketGCLoginFailure), &packet_failure))
+		return false;
+
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "OnLoginFailure", Py_BuildValue("(s)", packet_failure.szStatus));
+#ifdef _DEBUG
+	Tracef(" RecvLoginFailurePacket : [%s]\n", packet_failure.szStatus);
+#endif
+	return true;
+}
+
+bool CPythonNetworkStream::SendDirectEnterPacket(const char* c_szID, const char* c_szPassword, UINT uChrSlot)
+{
+	TPacketCGDirectEnter kPacketDirectEnter;
+	kPacketDirectEnter.bHeader=HEADER_CG_DIRECT_ENTER;
+	kPacketDirectEnter.index=uChrSlot;
+	strncpy(kPacketDirectEnter.login, c_szID, ID_MAX_NUM);
+	strncpy(kPacketDirectEnter.passwd, c_szPassword, PASS_MAX_NUM);
+
+	if (!Send(sizeof(kPacketDirectEnter), &kPacketDirectEnter))
+	{
+		Tracen("SendDirectEnter");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendLoginPacket(const char* c_szName, const char* c_szPassword)
+{
+	TPacketCGLogin LoginPacket;
+	LoginPacket.header = HEADER_CG_LOGIN;
+
+	strncpy(LoginPacket.name, c_szName, sizeof(LoginPacket.name)-1);
+	strncpy(LoginPacket.pwd, c_szPassword, sizeof(LoginPacket.pwd)-1);
+
+	LoginPacket.name[ID_MAX_NUM]='\0';
+	LoginPacket.pwd[PASS_MAX_NUM]='\0';
+
+	if (!Send(sizeof(LoginPacket), &LoginPacket))
+	{
+		Tracen("SendLogin Error");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendLoginPacketNew(const char * c_szName, const char * c_szPassword)
+{
+	TPacketCGLogin2 LoginPacket;
+	LoginPacket.header = HEADER_CG_LOGIN2;
+	LoginPacket.login_key = m_dwLoginKey;
+
+	strncpy(LoginPacket.name, c_szName, sizeof(LoginPacket.name)-1);
+	LoginPacket.name[ID_MAX_NUM]='\0';
+
+	extern DWORD g_adwEncryptKey[4];
+	extern DWORD g_adwDecryptKey[4];
+	for (DWORD i = 0; i < 4; ++i)
+		LoginPacket.adwClientKey[i] = g_adwEncryptKey[i];
+
+	if (!Send(sizeof(LoginPacket), &LoginPacket))
+	{
+		Tracen("SendLogin Error");
+		return false;
+	}
+
+	if (!SendSequence())
+	{
+		Tracen("SendLogin Error");
+		return false;
+	}
+
+	__SendInternalBuffer();
+
+#ifndef _IMPROVED_PACKET_ENCRYPTION_
+	SetSecurityMode(true, (const char *) g_adwEncryptKey, (const char *) g_adwDecryptKey);
+#endif
+	return true;
+}
+
+bool CPythonNetworkStream::__RecvRunupMatrixQuizPacket()
+{
+	TPacketGCRunupMatrixQuiz kMatrixQuizPacket;
+	if (!Recv(sizeof(TPacketGCRunupMatrixQuiz), &kMatrixQuizPacket))
+		return false;
+
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "BINARY_OnRunupMatrixQuiz", Py_BuildValue("(s)", kMatrixQuizPacket.szQuiz));	
+	return true;
+}
+
+bool CPythonNetworkStream::SendRunupMatrixAnswerPacket(const char * c_szMatrixCardString)
+{
+	TPacketCGRunupMatrixAnswer answerPacket;
+	answerPacket.bHeader = HEADER_CG_RUNUP_MATRIX_ANSWER;
+	strncpy(answerPacket.szAnswer, c_szMatrixCardString, RUNUP_MATRIX_ANSWER_MAX_LEN);
+	answerPacket.szAnswer[RUNUP_MATRIX_ANSWER_MAX_LEN] = '\0';
+	if (!Send(sizeof(answerPacket), &answerPacket))
+	{
+		TraceError("SendRunupMatrixCardPacketError");
+		return false;
+	}
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::__RecvNEWCIBNPasspodRequestPacket()
+{
+	TPacketGCNEWCIBNPasspodRequest kRequestPacket;
+	if (!Recv(sizeof(kRequestPacket), &kRequestPacket))
+		return false;
+
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "BINARY_OnNEWCIBNPasspodRequest", Py_BuildValue("()"));	
+	return true;
+}
+
+bool CPythonNetworkStream::__RecvNEWCIBNPasspodFailurePacket()
+{
+	TPacketGCNEWCIBNPasspodFailure kFailurePacket;
+	if (!Recv(sizeof(kFailurePacket), &kFailurePacket))
+		return false;
+
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "BINARY_OnNEWCIBNPasspodFailure", Py_BuildValue("()"));	
+	return true;
+}
+
+
+bool CPythonNetworkStream::SendNEWCIBNPasspodAnswerPacket(const char * answer)
+{
+	TPacketCGNEWCIBNPasspodAnswer answerPacket;
+	answerPacket.bHeader = HEADER_CG_NEWCIBN_PASSPOD_ANSWER;
+	strncpy(answerPacket.szAnswer, answer, NEWCIBN_PASSPOD_ANSWER_MAX_LEN);
+	answerPacket.szAnswer[NEWCIBN_PASSPOD_ANSWER_MAX_LEN] = '\0';	
+	if (!Send(sizeof(answerPacket), &answerPacket))
+	{
+		TraceError("SendNEWCIBNPasspodAnswerPacket");
+		return false;
+	}
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendChinaMatrixCardPacket(const char * c_szMatrixCardString)
+{
+	TPacketCGChinaMatrixCard MatrixCardPacket;
+	MatrixCardPacket.bHeader = HEADER_CG_CHINA_MATRIX_CARD;
+	strncpy(MatrixCardPacket.szAnswer, c_szMatrixCardString, CHINA_MATRIX_ANSWER_MAX_LEN);
+	MatrixCardPacket.szAnswer[CHINA_MATRIX_ANSWER_MAX_LEN]='\0';
+
+	if (!Send(sizeof(MatrixCardPacket), &MatrixCardPacket))
+	{
+		Tracen("SendLogin Error");
+		return false;
+	}
+
+	m_isWaitLoginKey = TRUE;
+
+	return SendSequence();
+}
+
+#define ROW(rows, i) ((rows >> ((4 - i - 1) * 8)) & 0x000000FF)
+#define COL(cols, i) ((cols >> ((4 - i - 1) * 8)) & 0x000000FF)
+
+bool CPythonNetworkStream::__RecvChinaMatrixCardPacket()
+{
+	TPacketGCChinaMatrixCard kMatrixCardPacket;
+	if (!Recv(sizeof(TPacketGCChinaMatrixCard), &kMatrixCardPacket))
+		return false;
+
+	PyObject * pyValue = Py_BuildValue("(iiiiiiii)",	ROW(kMatrixCardPacket.dwRows, 0),
+														ROW(kMatrixCardPacket.dwRows, 1),
+														ROW(kMatrixCardPacket.dwRows, 2),
+														ROW(kMatrixCardPacket.dwRows, 3),
+														COL(kMatrixCardPacket.dwCols, 0),
+														COL(kMatrixCardPacket.dwCols, 1),
+														COL(kMatrixCardPacket.dwCols, 2),
+														COL(kMatrixCardPacket.dwCols, 3));
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_LOGIN], "OnMatrixCard", pyValue);
+	return true;
+}
+
+bool CPythonNetworkStream::__RecvLoginKeyPacket()
+{
+	TPacketGCLoginKey kLoginKeyPacket;
+	if (!Recv(sizeof(TPacketGCLoginKey), &kLoginKeyPacket))
+		return false;
+
+	m_dwLoginKey = kLoginKeyPacket.dwLoginKey;
+	m_isWaitLoginKey = FALSE;
+
+	return true;
+}

extension/src/port/UserInterface/PythonNetworkStreamPhaseOffline.cpp

@@ -0,0 +1,22 @@
+#include "StdAfx.h"
+#include "PythonNetworkStream.h"
+#include "PythonApplication.h"
+#include "Packet.h"
+
+void CPythonNetworkStream::OffLinePhase()
+{
+	TPacketHeader header;
+
+	if (!CheckPacket(&header))
+		return;
+
+	switch (header)
+	{
+		case HEADER_GC_PHASE:
+			if (RecvPhasePacket())
+				return;
+			break;
+	}
+
+	RecvErrorPacket(header);
+}

extension/src/port/UserInterface/PythonNetworkStreamPhaseSelect.cpp

@@ -0,0 +1,308 @@
+#include "StdAfx.h"
+#include "PythonNetworkStream.h"
+#include "Packet.h"
+
+extern DWORD g_adwEncryptKey[4];
+extern DWORD g_adwDecryptKey[4];
+
+// Select Character ---------------------------------------------------------------------------
+void CPythonNetworkStream::SetSelectPhase()
+{
+	if ("Select" != m_strPhase)
+		m_phaseLeaveFunc.Run();
+
+	Tracen("");
+	Tracen("## Network - Select Phase ##");
+	Tracen("");
+
+	m_strPhase = "Select";	
+
+#ifndef _IMPROVED_PACKET_ENCRYPTION_
+	SetSecurityMode(true, (const char *) g_adwEncryptKey, (const char *) g_adwDecryptKey);
+#endif
+
+	m_dwChangingPhaseTime = ELTimer_GetMSec();
+	m_phaseProcessFunc.Set(this, &CPythonNetworkStream::SelectPhase);
+	m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveSelectPhase);
+
+	if (__DirectEnterMode_IsSet())
+	{
+		PyCallClassMemberFunc(m_poHandler, "SetLoadingPhase", Py_BuildValue("()"));	
+	}
+	else
+	{
+		if (IsSelectedEmpire())
+			PyCallClassMemberFunc(m_poHandler, "SetSelectCharacterPhase", Py_BuildValue("()"));
+		else
+			PyCallClassMemberFunc(m_poHandler, "SetSelectEmpirePhase", Py_BuildValue("()"));
+	}
+}
+
+void CPythonNetworkStream::SelectPhase()
+{
+	TPacketHeader header;
+
+	if (!CheckPacket(&header))
+		return;
+
+	switch (header)
+	{
+		case HEADER_GC_PHASE:
+			if (RecvPhasePacket())
+				return;	
+			break;
+
+		case HEADER_GC_EMPIRE:
+			if (__RecvEmpirePacket())
+				return;
+			break;
+
+		case HEADER_GC_LOGIN_SUCCESS3:
+			if (__RecvLoginSuccessPacket3())
+				return;
+			break;
+
+		case HEADER_GC_LOGIN_SUCCESS4:
+			if (__RecvLoginSuccessPacket4())
+				return;
+			break;
+
+
+		case HEADER_GC_PLAYER_CREATE_SUCCESS:
+			if (__RecvPlayerCreateSuccessPacket())
+				return;
+			break;
+
+		case HEADER_GC_PLAYER_CREATE_FAILURE:
+			if (__RecvPlayerCreateFailurePacket())
+				return;
+			break;
+
+		case HEADER_GC_PLAYER_DELETE_WRONG_SOCIAL_ID:
+			if (__RecvPlayerDestroyFailurePacket())
+				return;
+			break;
+
+		case HEADER_GC_PLAYER_DELETE_SUCCESS:
+			if (__RecvPlayerDestroySuccessPacket())
+				return;
+			break;
+
+		case HEADER_GC_CHANGE_NAME:
+			if (__RecvChangeName())
+				return;
+			break;
+
+		case HEADER_GC_HANDSHAKE:
+			RecvHandshakePacket();
+			return;
+			break;
+
+		case HEADER_GC_HANDSHAKE_OK:
+			RecvHandshakeOKPacket();
+			return;
+			break;
+
+		case HEADER_GC_HYBRIDCRYPT_KEYS:
+			RecvHybridCryptKeyPacket();
+			return;
+			break;
+
+		case HEADER_GC_HYBRIDCRYPT_SDB:
+			RecvHybridCryptSDBPacket();
+			return;
+			break;
+
+
+#ifdef _IMPROVED_PACKET_ENCRYPTION_
+		case HEADER_GC_KEY_AGREEMENT:
+			RecvKeyAgreementPacket();
+			return;
+			break;
+
+		case HEADER_GC_KEY_AGREEMENT_COMPLETED:
+			RecvKeyAgreementCompletedPacket();
+			return;
+			break;
+#endif
+
+		case HEADER_GC_PLAYER_POINT_CHANGE:
+			TPacketGCPointChange PointChange;
+			Recv(sizeof(TPacketGCPointChange), &PointChange);
+			return;
+			break;
+
+		///////////////////////////////////////////////////////////////////////////////////////////
+		case HEADER_GC_PING:
+			if (RecvPingPacket())
+				return;
+			break;
+	}
+
+	RecvErrorPacket(header);
+}
+
+bool CPythonNetworkStream::SendSelectEmpirePacket(DWORD dwEmpireID)
+{
+	TPacketCGEmpire kPacketEmpire;
+	kPacketEmpire.bHeader=HEADER_CG_EMPIRE;
+	kPacketEmpire.bEmpire=dwEmpireID;
+
+	if (!Send(sizeof(kPacketEmpire), &kPacketEmpire))
+	{
+		Tracen("SendSelectEmpirePacket - Error");
+		return false;
+	}
+
+	SetEmpireID(dwEmpireID);
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendSelectCharacterPacket(BYTE Index)
+{
+	TPacketCGSelectCharacter SelectCharacterPacket;
+
+	SelectCharacterPacket.header = HEADER_CG_PLAYER_SELECT;
+	SelectCharacterPacket.player_index = Index;
+
+	if (!Send(sizeof(TPacketCGSelectCharacter), &SelectCharacterPacket))
+	{
+		Tracen("SendSelectCharacterPacket - Error");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendDestroyCharacterPacket(BYTE index, const char * szPrivateCode)
+{
+    TPacketCGDestroyCharacter DestroyCharacterPacket;
+
+	DestroyCharacterPacket.header = HEADER_CG_PLAYER_DESTROY;
+	DestroyCharacterPacket.index = index;
+	strncpy(DestroyCharacterPacket.szPrivateCode, szPrivateCode, PRIVATE_CODE_LENGTH-1);
+
+	if (!Send(sizeof(TPacketCGDestroyCharacter), &DestroyCharacterPacket))
+	{
+		Tracen("SendDestroyCharacterPacket");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendCreateCharacterPacket(BYTE index, const char *name, BYTE job, BYTE shape, BYTE byCON, BYTE byINT, BYTE bySTR, BYTE byDEX)
+{
+	TPacketCGCreateCharacter createCharacterPacket;
+
+	createCharacterPacket.header = HEADER_CG_PLAYER_CREATE;
+	createCharacterPacket.index = index;
+	strncpy(createCharacterPacket.name, name, CHARACTER_NAME_MAX_LEN);
+	createCharacterPacket.job = job;
+	createCharacterPacket.shape = shape;
+	createCharacterPacket.CON = byCON;
+	createCharacterPacket.INT = byINT;
+	createCharacterPacket.STR = bySTR;
+	createCharacterPacket.DEX = byDEX;
+
+	if (!Send(sizeof(TPacketCGCreateCharacter), &createCharacterPacket))
+	{
+		Tracen("Failed to SendCreateCharacterPacket");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::SendChangeNamePacket(BYTE index, const char *name)
+{
+	TPacketCGChangeName ChangeNamePacket;
+	ChangeNamePacket.header = HEADER_CG_CHANGE_NAME;
+	ChangeNamePacket.index = index;
+	strncpy(ChangeNamePacket.name, name, CHARACTER_NAME_MAX_LEN);
+
+	if (!Send(sizeof(TPacketCGChangeName), &ChangeNamePacket))
+	{
+		Tracen("Failed to SendChangeNamePacket");
+		return false;
+	}
+
+	return SendSequence();
+}
+
+bool CPythonNetworkStream::__RecvPlayerCreateSuccessPacket()
+{
+	TPacketGCPlayerCreateSuccess kCreateSuccessPacket;
+
+	if (!Recv(sizeof(kCreateSuccessPacket), &kCreateSuccessPacket))
+		return false;
+
+	if (kCreateSuccessPacket.bAccountCharacterSlot>=PLAYER_PER_ACCOUNT4)
+	{
+		TraceError("CPythonNetworkStream::RecvPlayerCreateSuccessPacket - OUT OF RANGE SLOT(%d) > PLATER_PER_ACCOUNT(%d)",
+			kCreateSuccessPacket.bAccountCharacterSlot, PLAYER_PER_ACCOUNT4);
+		return true;
+	}
+
+	m_akSimplePlayerInfo[kCreateSuccessPacket.bAccountCharacterSlot]=kCreateSuccessPacket.kSimplePlayerInfomation;
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_CREATE], "OnCreateSuccess", Py_BuildValue("()"));
+	return true;
+}
+
+bool CPythonNetworkStream::__RecvPlayerCreateFailurePacket()
+{
+	TPacketGCCreateFailure packet;
+
+	if (!Recv(sizeof(TPacketGCCreateFailure), &packet))
+		return false;
+
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_CREATE], "OnCreateFailure", Py_BuildValue("(i)", packet.bType));
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "OnCreateFailure", Py_BuildValue("(i)", packet.bType));
+	return true;
+}
+
+bool CPythonNetworkStream::__RecvPlayerDestroySuccessPacket()
+{
+	TPacketGCDestroyCharacterSuccess packet;
+	if (!Recv(sizeof(TPacketGCDestroyCharacterSuccess), &packet))
+		return false;
+
+	memset(&m_akSimplePlayerInfo[packet.account_index], 0, sizeof(m_akSimplePlayerInfo[packet.account_index]));
+	m_adwGuildID[packet.account_index] = 0;
+	m_astrGuildName[packet.account_index] = "";
+
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "OnDeleteSuccess", Py_BuildValue("(i)", packet.account_index));
+	return true;
+}
+
+bool CPythonNetworkStream::__RecvPlayerDestroyFailurePacket()
+{
+	TPacketGCBlank packet_blank;
+	if (!Recv(sizeof(TPacketGCBlank), &packet_blank))
+		return false;
+
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "OnDeleteFailure", Py_BuildValue("()"));
+	return true;
+}
+
+bool CPythonNetworkStream::__RecvChangeName()
+{
+	TPacketGCChangeName ChangeNamePacket;
+	if (!Recv(sizeof(TPacketGCChangeName), &ChangeNamePacket))
+		return false;
+
+	for (int i = 0; i < PLAYER_PER_ACCOUNT4; ++i)
+	{
+		if (ChangeNamePacket.pid == m_akSimplePlayerInfo[i].dwID)
+		{
+			m_akSimplePlayerInfo[i].bChangeName = FALSE;
+			strncpy(m_akSimplePlayerInfo[i].szName, ChangeNamePacket.name, CHARACTER_NAME_MAX_LEN);
+
+			PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "OnChangeName", Py_BuildValue("(is)", i, ChangeNamePacket.name));
+			return true;
+		}
+	}
+
+	PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "OnCreateFailure", Py_BuildValue("(i)", 100));
+	return true;
+}

extension/src/port/UserInterface/PythonPackModule.cpp

@@ -6,10 +6,6 @@
 DWORD g_adwEncryptKey[4];
 DWORD g_adwDecryptKey[4];
 
-// PORT: the login cipher's key builder happens to live in this unit, but it is CAccountConnector's —
-// AccountConnector.h and the class come with the login slice (docs/PORT-PLAN.md 批次 2V1). Kept verbatim
-// and compiled out until then; the two keys above stay, they are what the network stream reads.
-#if 0
 #include "AccountConnector.h"
 
 inline const BYTE* GetKey_20050304Myevan()
@@ -40,7 +36,6 @@ void CAccountConnector::__BuildClientKey_20050304Myevan()
 	tea_encrypt((DWORD *) g_adwDecryptKey, (const DWORD *) g_adwEncryptKey, (const DWORD *) (c_pszKey+37), 16);
 //	TEA_Encrypt((DWORD *) g_adwDecryptKey, (const DWORD *) g_adwEncryptKey, (const DWORD *) (c_pszKey+37), 16);
 }
-#endif
 // END_OF_CHINA_CRYPT_KEY
 
 PyObject * packExist(PyObject * poSelf, PyObject * poArgs)

extension/src/port/UserInterface/StdAfx.h

@@ -44,3 +44,4 @@ enum
 // Listed here as 40250 lists them; only the ported ones are defined.
 void initpack();
 void initapp();
+void initnet();

extension/src/port/UserInterface/Test.h

@@ -0,0 +1,3 @@
+#pragma once
+
+extern bool __IS_TEST_SERVER_MODE__;

extension/src/port/UserInterface/WiseLogicXTrap.h

@@ -0,0 +1,8 @@
+#pragma once
+
+bool XTrap_Init();
+bool XTrap_CheckInit();
+void XTrap_PollEvent();
+void XTrap_ValidateCheckStream( LPVOID PacketBufferIn, LPVOID PacketBufferOut );
+void XTrap_SetUserInfo(LPCSTR szUserID, LPCSTR szServerName, LPCSTR szCharacterName, LPCSTR szCharacterClass, SOCKET hSocket);
+

extension/src/port/common/shim/sdk/Python-2.7/grammar.h

@@ -7,3 +7,8 @@
 // alone under the port header gate.
 #include <Python.h>
 #include <grammar.h>
+// CPython's bitset.h (pulled in by grammar.h) does `#define BYTE char`; the copy under 40250's
+// extern/include/Python-2.7 has that line removed, so BYTE stays the Win32 unsigned char in every
+// file that includes ScriptLib/StdAfx.h. bitset.h's own macros only use sizeof(BYTE), which is 1
+// either way.
+#undef BYTE

extension/src/port/common/shim/win32/windows.h

@@ -28,3 +28,6 @@
 #define VK_HOME 0x24
 #define VK_END 0x23
 #define VK_DELETE 0x2E
+
+// winuser.h functions the platform layer implements (platform/ScriptLib/PythonBoot.cpp).
+void PostQuitMessage(int nExitCode);

extension/tests/port_packet_test.cpp

@@ -0,0 +1,77 @@
+// 批次 2V1: the ported 40250 UserInterface/Packet.h against the classic wire layouts in net/classic/wire_classic.h,
+// which the mtnet backend checked 1:1 against the 40250 server on 192.168.21.203. Win32 `long` is 32 bits and
+// Packet.h now says LONG; a 64-bit long, or a missing #pragma pack(1), shows up here as a size mismatch.
+// Covers the packets the login/select/loading phases send and read. The two headers cannot share a translation unit
+// (Packet.h's macros such as SKILL_MAX_NUM collide with wire_classic.h's constants), so the wire sizes come from
+// port_packet_test_wire.cpp.
+#include "UserInterface/StdAfx.h"
+#include "UserInterface/Packet.h"
+
+#include <cstdio>
+#include <cstddef>
+
+struct WireSize { const char* name; std::size_t size; };
+extern const WireSize kWireSizes[];
+
+static const WireSize kPortSizes[] = {
+	// HandShake phase
+	{"TPacketGCHandshake", sizeof(TPacketGCHandshake)},
+	{"TPacketGCPhase", sizeof(TPacketGCPhase)},
+	{"TPacketGCBindUDP", sizeof(TPacketGCBindUDP)},
+	{"TPacketKeyAgreement", sizeof(TPacketKeyAgreement)},
+	{"TPacketKeyAgreementCompleted", sizeof(TPacketKeyAgreementCompleted)},
+	{"TPacketGCPing", sizeof(TPacketGCPing)},
+	{"TPacketCGPong", sizeof(TPacketCGPong)},
+	// Login phase (and the auth server, CAccountConnector)
+	{"TPacketCGLogin", sizeof(TPacketCGLogin)},
+	{"TPacketCGLogin2", sizeof(TPacketCGLogin2)},
+	{"TPacketCGLogin3", sizeof(TPacketCGLogin3)},
+	{"TPacketGCLoginKey", sizeof(TPacketGCLoginKey)},
+	{"TPacketGCAuthSuccess", sizeof(TPacketGCAuthSuccess)},
+	{"TSimplePlayerInformation", sizeof(TSimplePlayerInformation)},
+	{"TPacketGCLoginSuccess3", sizeof(TPacketGCLoginSuccess3)},
+	{"TPacketGCLoginSuccess4", sizeof(TPacketGCLoginSuccess4)},
+	{"TPacketGCLoginFailure", sizeof(TPacketGCLoginFailure)},
+	{"TPacketGCEmpire", sizeof(TPacketGCEmpire)},
+	{"TPacketCGEmpire", sizeof(TPacketCGEmpire)},
+	// Select phase
+	{"TPacketCGSelectCharacter", sizeof(TPacketCGSelectCharacter)},
+	{"TPacketCGCreateCharacter", sizeof(TPacketCGCreateCharacter)},
+	{"TPacketCGDestroyCharacter", sizeof(TPacketCGDestroyCharacter)},
+	{"TPacketCGChangeName", sizeof(TPacketCGChangeName)},
+	{"TPacketGCPlayerCreateSuccess", sizeof(TPacketGCPlayerCreateSuccess)},
+	{"TPacketGCCreateFailure", sizeof(TPacketGCCreateFailure)},
+	{"TPacketGCDestroyCharacterSuccess", sizeof(TPacketGCDestroyCharacterSuccess)},
+	{"TPacketGCChangeName", sizeof(TPacketGCChangeName)},
+	// Loading phase
+	{"TPacketGCMainCharacter", sizeof(TPacketGCMainCharacter)},
+	{"TPacketGCMainCharacter2_EMPIRE", sizeof(TPacketGCMainCharacter2_EMPIRE)},
+	{"TPacketGCMainCharacter3_BGM", sizeof(TPacketGCMainCharacter3_BGM)},
+	{"TPacketGCMainCharacter4_BGM_VOL", sizeof(TPacketGCMainCharacter4_BGM_VOL)},
+	{"TPacketGCPoints", sizeof(TPacketGCPoints)},
+	{"TPacketGCPointChange", sizeof(TPacketGCPointChange)},
+	{"TPacketGCItemSet2", sizeof(TPacketGCItemSet2)},
+	{"TPacketGCQuickSlotAdd", sizeof(TPacketGCQuickSlotAdd)},
+	{"TPacketGCCharacterUpdate", sizeof(TPacketGCCharacterUpdate)},
+	{"TPacketCGClientVersion2", sizeof(TPacketCGClientVersion2)},
+	{"TPacketCGEnterFrontGame", sizeof(TPacketCGEnterFrontGame)},
+	{nullptr, 0},
+};
+
+int main()
+{
+	int failures = 0;
+	for (int i = 0; kPortSizes[i].name; ++i)
+	{
+		if (kPortSizes[i].size != kWireSizes[i].size)
+		{
+			std::fprintf(stderr, "%s is %zu bytes, %s is %zu\n", kPortSizes[i].name, kPortSizes[i].size,
+				kWireSizes[i].name, kWireSizes[i].size);
+			++failures;
+		}
+	}
+	if (failures)
+		return 1;
+	std::printf("port_packet_test: ok\n");
+	return 0;
+}

extension/tests/port_packet_test_wire.cpp

@@ -0,0 +1,49 @@
+// The classic wire sizes for port_packet_test.cpp, in the same order as its kPortSizes.
+#include "../src/net/classic/wire_classic.h"
+
+#include <cstddef>
+
+struct WireSize { const char* name; std::size_t size; };
+
+namespace w = mtnet::classic;
+
+extern const WireSize kWireSizes[] = {
+	{"Handshake", sizeof(w::Handshake)},
+	{"Phase_", sizeof(w::Phase_)},
+	{"BindUDP", sizeof(w::BindUDP)},
+	{"KeyAgreement", sizeof(w::KeyAgreement)},
+	{"KeyAgreementCompleted", sizeof(w::KeyAgreementCompleted)},
+	{"Blank", sizeof(w::Blank)},
+	{"Blank", sizeof(w::Blank)},
+	{"CGLogin", sizeof(w::CGLogin)},
+	{"CGLogin2", sizeof(w::CGLogin2)},
+	{"CGLogin3", sizeof(w::CGLogin3)},
+	{"GCLoginKey", sizeof(w::GCLoginKey)},
+	{"GCAuthSuccess", sizeof(w::GCAuthSuccess)},
+	{"SimplePlayer", sizeof(w::SimplePlayer)},
+	{"GCLoginSuccess3", sizeof(w::GCLoginSuccess3)},
+	{"GCLoginSuccess", sizeof(w::GCLoginSuccess)},
+	{"GCLoginFailure", sizeof(w::GCLoginFailure)},
+	{"GCEmpire", sizeof(w::GCEmpire)},
+	{"CGEmpire", sizeof(w::CGEmpire)},
+	{"CGPlayerSelect", sizeof(w::CGPlayerSelect)},
+	{"CGPlayerCreate", sizeof(w::CGPlayerCreate)},
+	{"CGPlayerDelete", sizeof(w::CGPlayerDelete)},
+	{"CGChangeName", sizeof(w::CGChangeName)},
+	{"GCPlayerCreateSuccess", sizeof(w::GCPlayerCreateSuccess)},
+	{"GCPlayerCreateFailure", sizeof(w::GCPlayerCreateFailure)},
+	{"GCPlayerDeleteSuccess", sizeof(w::GCPlayerDeleteSuccess)},
+	{"GCChangeName", sizeof(w::GCChangeName)},
+	{"GCMainCharacterOld", sizeof(w::GCMainCharacterOld)},
+	{"GCMainCharacter", sizeof(w::GCMainCharacter)},
+	{"GCMainCharacter3BGM", sizeof(w::GCMainCharacter3BGM)},
+	{"GCMainCharacter4BGM", sizeof(w::GCMainCharacter4BGM)},
+	{"GCPoints", sizeof(w::GCPoints)},
+	{"GCPointChange", sizeof(w::GCPointChange)},
+	{"GCItemSet", sizeof(w::GCItemSet)},
+	{"GCQuickSlotAdd", sizeof(w::GCQuickSlotAdd)},
+	{"GCCharacterUpdate", sizeof(w::GCCharacterUpdate)},
+	{"CGClientVersion2", sizeof(w::CGClientVersion2)},
+	{"CGEnterGame", sizeof(w::CGEnterGame)},
+	{nullptr, 0},
+};