Tr0n/client
1
0
Fork 0
forked from metin2/client
Code Pull Requests Activity
33f19f9ff6
client/UserInterface/PythonEventManager.cpp

1212 lines
32 KiB
C++
Raw Normal View History

Initial commit based on the 40250 Test Client
2022-11-20 23:11:54 +02:00
#include "StdAfx.h"
#include "PythonEventManager.h"
#include "PythonNetworkStream.h"
#include "PythonNonPlayer.h"
#include "AbstractApplication.h"
#include "../gamelib/ItemData.h"
#include "../gamelib/ItemManager.h"
#include "../eterPack/EterPackManager.h"
#include "PythonMiniMap.h"
const long c_lNormal_Waiting_Time = 10;
const int c_fLine_Temp = 16;
void ShowArgument(script::TArgList & rArgumentList)
{
for (script::TArgList::iterator itor=rArgumentList.begin(); itor!=rArgumentList.end(); ++itor)
{
const std::string & rName = (*itor).strName;
Tracen(rName.c_str());
}
}
const std::string& GetArgumentString(const char * c_szName, script::TArgList & rArgumentList)
{
for (script::TArgList::iterator itor = rArgumentList.begin(); itor != rArgumentList.end(); ++itor)
{
const std::string & rName = (*itor).strName;
if (0 == rName.compare(c_szName))
return (*itor).strValue;
}
static std::string strEmptyValue = "";
return strEmptyValue;
}
const char * GetArgument(const char * c_szName, script::TArgList & rArgumentList)
{
return GetArgumentString(c_szName, rArgumentList).c_str();
}
void GetCameraSettingFromArgList(script::TArgList & rArgList, IAbstractApplication::SCameraSetting * pCameraSetting)
{
int ix = atoi(GetArgument("x", rArgList));
int iy = atoi(GetArgument("y", rArgList));
int iz = atoi(GetArgument("z", rArgList));
int iUpDir = atoi(GetArgument("up", rArgList));
int iViewDir = atoi(GetArgument("view", rArgList));
int iCrossDir = atoi(GetArgument("cross", rArgList));
int iDistance = atoi(GetArgument("distance", rArgList));
int iRot = atoi(GetArgument("rot", rArgList));
int iPitch = atoi(GetArgument("pitch", rArgList));
ZeroMemory(pCameraSetting, sizeof(IAbstractApplication::SCameraSetting));
pCameraSetting->v3CenterPosition.x = float(ix);
pCameraSetting->v3CenterPosition.y = float(iy);
pCameraSetting->v3CenterPosition.z = float(iz);
pCameraSetting->kCmrPos.m_fUpDir = float(iUpDir);
pCameraSetting->kCmrPos.m_fViewDir = float(iViewDir);
pCameraSetting->kCmrPos.m_fCrossDir = float(iCrossDir);
pCameraSetting->fZoom = float(iDistance);
pCameraSetting->fRotation = float(iRot);
pCameraSetting->fPitch = float(iPitch);
}
void CPythonEventManager::__InitEventSet(TEventSet& rEventSet)
{
rEventSet.ix = 0;
rEventSet.iy = 0;
rEventSet.iWidth = 0;
rEventSet.iyLocal = 0;
rEventSet.isLock = false;
rEventSet.lLastDelayTime = 0;
rEventSet.iCurrentLetter = 0;
rEventSet.CurrentColor = D3DXCOLOR(1, 1, 1, 1);
rEventSet.strCurrentLine = "";
rEventSet.pCurrentTextLine = NULL;
rEventSet.ScriptTextLineList.clear();
rEventSet.isConfirmWait = FALSE;
rEventSet.pConfirmTimeTextLine = NULL;
rEventSet.iConfirmEndTime = 0;
rEventSet.DiffuseColor = D3DXCOLOR(1, 1, 1, 1);
rEventSet.lWaitingTime = c_lNormal_Waiting_Time;
rEventSet.iRestrictedCharacterCount = 30;
rEventSet.iVisibleStartLine = 0;
rEventSet.iVisibleLineCount = BOX_VISIBLE_LINE_COUNT;
rEventSet.iAdjustLine = 0;
rEventSet.isTextCenterMode = false;
rEventSet.isWaitFlag = false;
__InsertLine(rEventSet);
}
int CPythonEventManager::RegisterEventSet(const char * c_szFileName)
{
CMappedFile File;
LPCVOID pMap;
if (!CEterPackManager::Instance().Get(File, c_szFileName, &pMap))
return -1;
std::string strEventString;
strEventString.resize(File.Size()+1);
File.Read(&strEventString[0], File.Size());
TEventSet * pEventSet = m_EventSetPool.Alloc();
if (!pEventSet)
return -1;
if (!pEventSet->ScriptGroup.Create(strEventString))
{
__ClearEventSetp(pEventSet);
return -1;
}
strncpy(pEventSet->szFileName, c_szFileName, 32);
pEventSet->pCurrentTextLine = NULL;
pEventSet->poEventHandler = NULL;
__InitEventSet(*pEventSet);
int iEmptySlotIndex = GetEmptyEventSetSlot();
m_EventSetVector[iEmptySlotIndex] = pEventSet;
return iEmptySlotIndex;
}
int CPythonEventManager::RegisterEventSetFromString(const std::string& strScript)
{
TEventSet* pEventSet = m_EventSetPool.Alloc();
if (!pEventSet)
return -1;
// SCRIPT_PARSING_FAILURE_CLEAR_BUG <20><>ũ<EFBFBD><C5A9>Ʈ <20>Ľ<EFBFBD> <20><><EFBFBD>н<EFBFBD> __ClearEventSetp <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20>߻<EFBFBD>
pEventSet->pCurrentTextLine = NULL;
// END_OF_SCRIPT_PARSING_FAILURE_CLEAR_BUG
if (!pEventSet->ScriptGroup.Create(strScript))
{
__ClearEventSetp(pEventSet);
return -1;
}
pEventSet->szFileName[0] = 0;
pEventSet->poEventHandler = NULL;
__InitEventSet(*pEventSet);
// NOTE : <20><><EFBFBD><EFBFBD> <20>ܼ<EFBFBD><DCBC><EFBFBD> <20><>ũ<EFBFBD><C5A9>Ʈ <20>̺<EFBFBD>Ʈ <20><><EFBFBD><EFBFBD> Ŀ<>ǵ<EFBFBD><C7B5><EFBFBD><EFBFBD><EFBFBD> <20>ٽ<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
script::TCmd ScriptCommand;
int pEventPosition;
int iEventType;
if (pEventSet->ScriptGroup.ReadCmd(ScriptCommand))
{
if (GetScriptEventIndex(ScriptCommand.name.c_str(), &pEventPosition, &iEventType))
{
if (EVENT_TYPE_RUN_CINEMA == iEventType)
{
std::string strFileName = GetArgument("value", ScriptCommand.argList);
__ClearEventSetp(pEventSet);
return RegisterEventSet(strFileName.c_str());
}
}
}
int iEmptySlotIndex = GetEmptyEventSetSlot();
m_EventSetVector[iEmptySlotIndex] = pEventSet;
return iEmptySlotIndex;
}
void CPythonEventManager::ClearEventSeti(int iIndex)
{
if (!CheckEventSetIndex(iIndex))
return;
__ClearEventSetp(m_EventSetVector[iIndex]);
m_EventSetVector[iIndex] = NULL;
}
void CPythonEventManager::__ClearEventSetp(TEventSet * pEventSet)
{
if (!pEventSet)
return;
for (TScriptTextLineList::iterator itor = pEventSet->ScriptTextLineList.begin(); itor != pEventSet->ScriptTextLineList.end(); ++itor)
{
TTextLine & rkLine = *itor;
rkLine.pInstance->Destroy();
m_ScriptTextLinePool.Free(rkLine.pInstance);
}
pEventSet->ScriptTextLineList.clear();
if (pEventSet->pCurrentTextLine)
{
pEventSet->pCurrentTextLine->Destroy();
m_ScriptTextLinePool.Free(pEventSet->pCurrentTextLine);
}
pEventSet->pCurrentTextLine = NULL;
pEventSet->strCurrentLine = "";
pEventSet->iCurrentLetter = 0;
m_EventSetPool.Free(pEventSet);
}
DWORD CPythonEventManager::GetEmptyEventSetSlot()
{
for (DWORD i = 0; i < m_EventSetVector.size(); ++i)
{
if (NULL == m_EventSetVector[i])
{
return i;
}
}
m_EventSetVector.push_back(NULL);
return m_EventSetVector.size()-1;
}
void CPythonEventManager::SetRestrictedCount(int iIndex, int iCount)
{
if (!CheckEventSetIndex(iIndex))
return;
TEventSet * pEventSet = m_EventSetVector[iIndex];
if (!pEventSet)
{
TraceError("CPythonEventManager::SetRestrictedCount m_EventSetVector[iIndex=%d]==NULL", iIndex);
return;
}
pEventSet->iRestrictedCharacterCount = iCount;
}
void CPythonEventManager::SetEventHandler(int iIndex, PyObject * poEventHandler)
{
if (!CheckEventSetIndex(iIndex))
return;
TEventSet * pEventSet = m_EventSetVector[iIndex];
if (!pEventSet)
{
TraceError("CPythonEventManager::SetEventHandler m_EventSetVector[iIndex=%d]==NULL", iIndex);
return;
}
pEventSet->poEventHandler = poEventHandler;
}
int CPythonEventManager::GetEventSetLocalYPosition(int iIndex)
{
if (!CheckEventSetIndex(iIndex))
return 0;
TEventSet * pEventSet = m_EventSetVector[iIndex];
if (!pEventSet)
return 0;
return pEventSet->iyLocal;
}
void CPythonEventManager::AddEventSetLocalYPosition(int iIndex, int iAddValue)
{
if (!CheckEventSetIndex(iIndex))
return;
TEventSet * pEventSet = m_EventSetVector[iIndex];
if (!pEventSet)
return;
pEventSet->iyLocal += iAddValue;
}
void CPythonEventManager::InsertText(int iIndex, const char * c_szText,int iX_pos)
{
if (!CheckEventSetIndex(iIndex))
return;
TEventSet * pEventSet = m_EventSetVector[iIndex];
if (!pEventSet)
return;
pEventSet->strCurrentLine = c_szText;
if (pEventSet->pCurrentTextLine)
{
pEventSet->pCurrentTextLine->SetValue(c_szText);
if (iX_pos == 0)
{
pEventSet->pCurrentTextLine->SetHorizonalAlign(CGraphicTextInstance::HORIZONTAL_ALIGN_CENTER);
}
}
pEventSet->pCurrentTextLine->Update();
__InsertLine(*pEventSet, FALSE, iX_pos);
}
void CPythonEventManager::UpdateEventSet(int iIndex, int ix, int iy)
{
if (!CheckEventSetIndex(iIndex))
return;
TEventSet * pEventSet = m_EventSetVector[iIndex];
if (!pEventSet)
return;
pEventSet->ix = ix;
pEventSet->iy = iy;
RefreshLinePosition(pEventSet);
if (pEventSet->isConfirmWait)
{
int iLeftTime = max(0, pEventSet->iConfirmEndTime - timeGetTime()/1000);
pEventSet->pConfirmTimeTextLine->SetValue(_getf(m_strLeftTimeString.c_str(), iLeftTime));
}
if (pEventSet->isWaitFlag)
return;
///////////////////////////////////////////////////////////////////////////////////////////////
// Process EventSet
long lElapsedTime = CTimer::Instance().GetElapsedMilliecond();
pEventSet->lLastDelayTime = max(0, pEventSet->lLastDelayTime - lElapsedTime);
while (lElapsedTime > 0)
{
pEventSet->lLastDelayTime -= lElapsedTime;
if (pEventSet->lLastDelayTime <= 0)
{
lElapsedTime = -pEventSet->lLastDelayTime;
if (lElapsedTime <= 0)
break;
ProcessEventSet(pEventSet);
if (pEventSet->lLastDelayTime < 0)
{
pEventSet->lLastDelayTime = 0;
break;
}
}
else
break;
}
}
void CPythonEventManager::SetEventSetWidth(int iIndex, int iWidth)
{
if (!CheckEventSetIndex(iIndex))
return;
TEventSet * pEventSet = m_EventSetVector[iIndex];
if (!pEventSet)
return;
pEventSet->iWidth = iWidth;
}
void CPythonEventManager::ProcessEventSet(TEventSet * pEventSet)
{
if (pEventSet->isLock)
return;
script::TCmd ScriptCommand;
IAbstractApplication& rApp=IAbstractApplication::GetSingleton();
if (!pEventSet->ScriptGroup.GetCmd(ScriptCommand))
{
pEventSet->isLock = true;
return;
}
int pEventPosition;
int iEventType;
if (!GetScriptEventIndex(ScriptCommand.name.c_str(), &pEventPosition, &iEventType))
return;
switch (iEventType)
{
case EVENT_TYPE_LETTER:
{
const std::string& c_rstValue = GetArgumentString("value", ScriptCommand.argList);
pEventSet->strCurrentLine.append(c_rstValue);
pEventSet->pCurrentTextLine->SetValueString(pEventSet->strCurrentLine);
pEventSet->pCurrentTextLine->SetColor(pEventSet->CurrentColor.r,pEventSet->CurrentColor.g,pEventSet->CurrentColor.b);
pEventSet->iCurrentLetter+=c_rstValue.length();
if (pEventSet->iCurrentLetter >= pEventSet->iRestrictedCharacterCount)
{
__InsertLine(*pEventSet);
}
pEventSet->lLastDelayTime = pEventSet->lWaitingTime;
break;
}
case EVENT_TYPE_DELAY:
{
if (EVENT_POSITION_START == pEventPosition)
pEventSet->lWaitingTime = atoi(GetArgument("value", ScriptCommand.argList));
else
pEventSet->lWaitingTime = c_lNormal_Waiting_Time;
break;
}
case EVENT_TYPE_COLOR:
{
if (EVENT_POSITION_START == pEventPosition)
{
pEventSet->CurrentColor.r = (float)atof(GetArgument("r", ScriptCommand.argList));
pEventSet->CurrentColor.g = (float)atof(GetArgument("g", ScriptCommand.argList));
pEventSet->CurrentColor.b = (float)atof(GetArgument("b", ScriptCommand.argList));
pEventSet->CurrentColor.a = 1.0f;
}
else
{
pEventSet->CurrentColor.r = 1.0f;
pEventSet->CurrentColor.g = 1.0f;
pEventSet->CurrentColor.a = 1.0f;
pEventSet->CurrentColor.b = 1.0f;
}
break;
}
case EVENT_TYPE_COLOR256:
{
if (EVENT_POSITION_START == pEventPosition)
{
pEventSet->CurrentColor.r = float(atof(GetArgument("r", ScriptCommand.argList)) / 255.0f);
pEventSet->CurrentColor.g = float(atof(GetArgument("g", ScriptCommand.argList)) / 255.0f);
pEventSet->CurrentColor.b = float(atof(GetArgument("b", ScriptCommand.argList)) / 255.0f);
pEventSet->CurrentColor.a = 1.0f;
}
else
{
pEventSet->CurrentColor.r = 1.0f;
pEventSet->CurrentColor.g = 1.0f;
pEventSet->CurrentColor.a = 1.0f;
pEventSet->CurrentColor.b = 1.0f;
}
break;
}
case EVENT_TYPE_ENTER:
{
__InsertLine(*pEventSet);
break;
}
case EVENT_TYPE_WAIT:
{
//ijƽ<C4B3><C6BD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EEBFA1> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>/EVENT_TYPE_WAIT <20><><EFBFBD><EFBFBD><EFBFBD>ؼ<EFBFBD> <20>׽<EFBFBD>Ʈ <20>ʿ<EFBFBD>.
pEventSet->iyLocal = 0;
pEventSet->isLock = true;
break;
}
case EVENT_TYPE_NEXT:
{
MakeNextButton(pEventSet, BUTTON_TYPE_NEXT);
pEventSet->iAdjustLine += 2;
break;
}
case EVENT_TYPE_DONE:
{
MakeNextButton(pEventSet, BUTTON_TYPE_DONE);
PyCallClassMemberFunc(pEventSet->poEventHandler, "DoneEvent", Py_BuildValue("()"));
pEventSet->iAdjustLine += 2;
break;
}
case EVENT_TYPE_CLEAR:
{
ClearLine(pEventSet);
break;
}
case EVENT_TYPE_QUESTION:
{
MakeQuestion(pEventSet, ScriptCommand.argList);
break;
}
case EVENT_TYPE_LEFT_IMAGE:
{
PyCallClassMemberFunc(pEventSet->poEventHandler, "OnLeftImage", Py_BuildValue("(s)", GetArgument("src", ScriptCommand.argList)));
break;
}
case EVENT_TYPE_TOP_IMAGE:
{
PyCallClassMemberFunc(pEventSet->poEventHandler, "OnTopImage", Py_BuildValue("(s)", GetArgument("src", ScriptCommand.argList)));
break;
}
case EVENT_TYPE_BACKGROUND_IMAGE:
{
PyCallClassMemberFunc(pEventSet->poEventHandler, "OnBackgroundImage", Py_BuildValue("(s)",GetArgument("src", ScriptCommand.argList)));
break;
}
case EVENT_TYPE_IMAGE:
{
int x = atoi(GetArgument("x", ScriptCommand.argList));
int y = atoi(GetArgument("y", ScriptCommand.argList));
const char * src = GetArgument("src", ScriptCommand.argList);
PyCallClassMemberFunc(pEventSet->poEventHandler, "OnImage", Py_BuildValue("(iis)", x, y, src));
break;
}
case EVENT_TYPE_INSERT_IMAGE:
{
const std::string & imageFile = GetArgumentString("image_name", ScriptCommand.argList);
const char * title = GetArgument("title", ScriptCommand.argList);
const char * desc = GetArgument("desc", ScriptCommand.argList);
int index = atoi(GetArgument("index", ScriptCommand.argList));
int total = atoi(GetArgument("total", ScriptCommand.argList));
if (imageFile.empty())
{
const char * imageType = GetArgument("image_type", ScriptCommand.argList);
int iItemIndex = atoi(GetArgument("idx", ScriptCommand.argList));
PyCallClassMemberFunc(pEventSet->poEventHandler, "OnInsertItemIcon", Py_BuildValue("(sissii)", imageType, iItemIndex, title, desc, index, total));
}
else
{
PyCallClassMemberFunc(pEventSet->poEventHandler, "OnInsertImage", Py_BuildValue("(ssssii)", imageFile.c_str(), title, title, desc, index, total));
}
pEventSet->iAdjustLine += 2;
break;
}
case EVENT_TYPE_ADD_MAP_SIGNAL:
{
float x, y;
x = (float)atof(GetArgument("x",ScriptCommand.argList));
y = (float)atof(GetArgument("y",ScriptCommand.argList));
CPythonMiniMap::Instance().AddSignalPoint(x,y);
CPythonMiniMap::Instance().OpenAtlasWindow();
break;
}
case EVENT_TYPE_CLEAR_MAP_SIGNAL:
{
CPythonMiniMap::Instance().ClearAllSignalPoint();
break;
}
// HIDE_QUEST_LETTER
case EVENT_TYPE_QUEST_BUTTON_CLOSE:
{
PyCallClassMemberFunc(m_poInterface, "BINARY_ClearQuest",
Py_BuildValue("(i)", atoi(GetArgument("idx", ScriptCommand.argList))));
break;
}
// END_OF_HIDE_QUEST_LETTER
case EVENT_TYPE_QUEST_BUTTON:
{
const std::string& c_rstType = GetArgumentString("icon_type", ScriptCommand.argList);
const std::string& c_rstFile = GetArgumentString("icon_name", ScriptCommand.argList);
int idx = atoi(GetArgument("idx", ScriptCommand.argList));
const char * name = GetArgument("name", ScriptCommand.argList);
// <20><><EFBFBD><EFBFBD>Ʈ UI <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>Ǹ<EFBFBD> <20>ذ<EFBFBD> <20>ǹǷ<C7B9> <20>ϴ<EFBFBD> <20><>ȥ<EFBFBD><C8A5><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> by chrislee
if (!strcmp(name, "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><>ȥ<EFBFBD><C8A5>?....")) {
PyCallClassMemberFunc(m_poInterface, "BINARY_RecvQuest", Py_BuildValue("(isss)", idx, name, "highlight", ""));
}
else {
if (c_rstFile.empty())
{
PyCallClassMemberFunc(m_poInterface, "RecvQuest", Py_BuildValue("(is)", idx, name));
}
else
{
PyCallClassMemberFunc(m_poInterface, "BINARY_RecvQuest",
Py_BuildValue("(isss)", idx, name, c_rstType.c_str(), c_rstFile.c_str()));
}
}
break;
}
case EVENT_TYPE_SET_MESSAGE_POSITION:
{
break;
}
case EVENT_TYPE_ADJUST_MESSAGE_POSITION:
{
break;
}
case EVENT_TYPE_SET_CENTER_MAP_POSITION:
{
CPythonMiniMap::Instance().SetAtlasCenterPosition(atoi(GetArgument("x", ScriptCommand.argList)),atoi(GetArgument("y", ScriptCommand.argList)));
break;
}
case EVENT_TYPE_SLEEP:
pEventSet->lLastDelayTime = atoi(GetArgument("value", ScriptCommand.argList));
break;
case EVENT_TYPE_SET_CAMERA:
{
IAbstractApplication::SCameraSetting CameraSetting;
GetCameraSettingFromArgList(ScriptCommand.argList, &CameraSetting);
rApp.SetEventCamera(CameraSetting);
break;
}
case EVENT_TYPE_BLEND_CAMERA:
{
IAbstractApplication::SCameraSetting CameraSetting;
GetCameraSettingFromArgList(ScriptCommand.argList, &CameraSetting);
float fBlendTime = atoi(GetArgument("blendtime", ScriptCommand.argList));
rApp.BlendEventCamera(CameraSetting, fBlendTime);
break;
}
case EVENT_TYPE_RESTORE_CAMERA:
{
rApp.SetDefaultCamera();
break;
}
case EVENT_TYPE_FADE_OUT:
{
float fSpeed = (float)atof(GetArgument("speed", ScriptCommand.argList));
PyCallClassMemberFunc(pEventSet->poEventHandler, "FadeOut", Py_BuildValue("(f)", fSpeed));
pEventSet->isWaitFlag = true;
break;
}
case EVENT_TYPE_FADE_IN:
{
PyCallClassMemberFunc(pEventSet->poEventHandler, "FadeIn", Py_BuildValue("(f)", atof(GetArgument("speed", ScriptCommand.argList))));
pEventSet->isWaitFlag = true;
break;
}
case EVENT_TYPE_WHITE_OUT:
{
PyCallClassMemberFunc(pEventSet->poEventHandler, "WhiteOut", Py_BuildValue("(f)", atof(GetArgument("speed", ScriptCommand.argList))));
pEventSet->isWaitFlag = true;
break;
}
case EVENT_TYPE_WHITE_IN:
{
PyCallClassMemberFunc(pEventSet->poEventHandler, "WhiteIn", Py_BuildValue("(f)", atof(GetArgument("speed", ScriptCommand.argList))));
pEventSet->isWaitFlag = true;
break;
}
case EVENT_TYPE_CLEAR_TEXT:
{
ClearLine(pEventSet);
break;
}
case EVENT_TYPE_TEXT_HORIZONTAL_ALIGN_CENTER:
{
pEventSet->isTextCenterMode = true;
if (pEventSet->pCurrentTextLine)
pEventSet->pCurrentTextLine->SetHorizonalAlign(CGraphicTextInstance::HORIZONTAL_ALIGN_CENTER);
break;
}
case EVENT_TYPE_TITLE_IMAGE:
{
PyCallClassMemberFunc(pEventSet->poEventHandler, "OnTitleImage", Py_BuildValue("(s)", GetArgument("src", ScriptCommand.argList)));
break;
}
case EVENT_TYPE_DUNGEON_RESULT:
{
int killstone_count = atoi(GetArgument("killstone_count", ScriptCommand.argList));
int killmob_count = atoi(GetArgument("killmob_count", ScriptCommand.argList));
int find_hidden = atoi(GetArgument("find_hidden", ScriptCommand.argList));
int hidden_total = atoi(GetArgument("hidden_total", ScriptCommand.argList));
int use_potion = atoi(GetArgument("use_potion", ScriptCommand.argList));
int is_revived = atoi(GetArgument("is_revived", ScriptCommand.argList));
int killallmob = atoi(GetArgument("killallmob", ScriptCommand.argList));
int total_time = atoi(GetArgument("total_time", ScriptCommand.argList));
int bonus_exp = atoi(GetArgument("bonus_exp", ScriptCommand.argList));
PyCallClassMemberFunc(m_poInterface, "ShowDungeonResult",
Py_BuildValue("(iiiiiiiii)",
killstone_count,
killmob_count,
find_hidden,
hidden_total,
use_potion,
is_revived,
killallmob,
total_time,
bonus_exp));
break;
}
case EVENT_TYPE_ITEM_NAME:
{
int iIndex = atoi(GetArgument("value", ScriptCommand.argList));
CItemData * pItemData;
if (CItemManager::Instance().GetItemDataPointer(iIndex, &pItemData))
{
pEventSet->strCurrentLine.append(pItemData->GetName());
pEventSet->pCurrentTextLine->SetValue(pEventSet->strCurrentLine.c_str());
pEventSet->pCurrentTextLine->SetColor(1.0f, 0.2f, 0.2f);
pEventSet->iCurrentLetter+= strlen(pItemData->GetName());
if (pEventSet->iCurrentLetter >= pEventSet->iRestrictedCharacterCount)
__InsertLine(*pEventSet);
pEventSet->lLastDelayTime = pEventSet->lWaitingTime;
}
break;
}
case EVENT_TYPE_MONSTER_NAME:
{
int iIndex = atoi(GetArgument("value", ScriptCommand.argList));
const char * c_szName;
CPythonNonPlayer& rkNonPlayer=CPythonNonPlayer::Instance();
if (rkNonPlayer.GetName(iIndex, &c_szName))
{
pEventSet->strCurrentLine.append(c_szName);
pEventSet->pCurrentTextLine->SetValue(pEventSet->strCurrentLine.c_str());
pEventSet->iCurrentLetter+= strlen(c_szName);
if (pEventSet->iCurrentLetter >= pEventSet->iRestrictedCharacterCount)
__InsertLine(*pEventSet);
pEventSet->lLastDelayTime = pEventSet->lWaitingTime;
}
break;
}
case EVENT_TYPE_WINDOW_SIZE:
{
int iWidth = atoi(GetArgument("width", ScriptCommand.argList));
int iHeight = atoi(GetArgument("height", ScriptCommand.argList));
PyCallClassMemberFunc(pEventSet->poEventHandler, "OnSize", Py_BuildValue("(ii)", iWidth, iHeight));
break;
}
case EVENT_TYPE_INPUT:
{
__InsertLine(*pEventSet);
PyCallClassMemberFunc(pEventSet->poEventHandler, "OnInput", Py_BuildValue("()"));
break;
}
case EVENT_TYPE_CONFIRM_WAIT:
{
int iTimeOut = atoi(GetArgument("timeout", ScriptCommand.argList));
pEventSet->isConfirmWait = TRUE;
pEventSet->pConfirmTimeTextLine = pEventSet->pCurrentTextLine;
pEventSet->iConfirmEndTime = timeGetTime()/1000 + iTimeOut;
__InsertLine(*pEventSet, TRUE);
MakeNextButton(pEventSet, BUTTON_TYPE_CANCEL);
break;
}
case EVENT_TYPE_END_CONFIRM_WAIT:
{
for (DWORD i = 0; i < m_EventSetVector.size(); ++i)
{
if (NULL == m_EventSetVector[i])
continue;
TEventSet * pSet = m_EventSetVector[i];
if (!pSet->isConfirmWait)
continue;
pSet->isConfirmWait = FALSE;
pSet->pConfirmTimeTextLine = NULL;
pSet->iConfirmEndTime = 0;
PyCallClassMemberFunc(pSet->poEventHandler, "CloseSelf", Py_BuildValue("()"));
}
break;
}
case EVENT_TYPE_SELECT_ITEM:
{
PyCallClassMemberFunc(m_poInterface, "BINARY_OpenSelectItemWindow", Py_BuildValue("()"));
break;
}
}
}
void CPythonEventManager::RenderEventSet(int iIndex)
{
if (!CheckEventSetIndex(iIndex))
return;
TEventSet * pEventSet = m_EventSetVector[iIndex];
if (!pEventSet)
return;
int iCount = 0;
for (TScriptTextLineList::iterator itor = pEventSet->ScriptTextLineList.begin(); itor != pEventSet->ScriptTextLineList.end(); ++itor, ++iCount)
{
if (iCount < pEventSet->iVisibleStartLine)
continue;
if (iCount >= pEventSet->iVisibleStartLine + pEventSet->iVisibleLineCount)
continue;
TTextLine & rkLine = *itor;
CGraphicTextInstance * pInstance = rkLine.pInstance;
pInstance->Update();
pInstance->Render();
}
if (iCount >= pEventSet->iVisibleStartLine)
if (iCount < pEventSet->iVisibleStartLine + pEventSet->iVisibleLineCount)
{
pEventSet->pCurrentTextLine->Update();
pEventSet->pCurrentTextLine->Render();
}
}
void CPythonEventManager::Skip(int iIndex)
{
if (!CheckEventSetIndex(iIndex))
return;
TEventSet * pEventSet = m_EventSetVector[iIndex];
if (true == pEventSet->isLock)
{
pEventSet->lLastDelayTime = 0;
pEventSet->isLock = false;
}
else
{
pEventSet->lLastDelayTime = -1000;
}
}
bool CPythonEventManager::IsWait(int iIndex)
{
if (!CheckEventSetIndex(iIndex))
return false;
TEventSet * pEventSet = m_EventSetVector[iIndex];
if (!pEventSet)
{
return false;
}
return pEventSet->isLock;
}
void CPythonEventManager::EndEventProcess(int iIndex)
{
if (!CheckEventSetIndex(iIndex))
return;
TEventSet * pEventSet = m_EventSetVector[iIndex];
if (!pEventSet)
{
return;
}
pEventSet->isWaitFlag = false;
}
void CPythonEventManager::MakeNextButton(TEventSet * pEventSet, int iButtonType)
{
__AddSpace(*pEventSet, c_fLine_Temp+5);
PyCallClassMemberFunc(pEventSet->poEventHandler, "MakeNextButton", Py_BuildValue("(i)", iButtonType));
}
void CPythonEventManager::MakeQuestion(TEventSet * pEventSet, script::TArgList & rArgumentList)
{
if (rArgumentList.empty())
return;
PyCallClassMemberFunc(pEventSet->poEventHandler, "MakeQuestion", Py_BuildValue("(i)", rArgumentList.size()));
pEventSet->nAnswer = rArgumentList.size();
int iIndex = 0;
for (script::TArgList::iterator itor=rArgumentList.begin(); itor!=rArgumentList.end(); ++itor)
{
script::TArg & rArgument = *itor;
PyCallClassMemberFunc(pEventSet->poEventHandler, "AppendQuestion", Py_BuildValue("(si)", rArgument.strValue.c_str(), iIndex));
++iIndex;
}
}
void CPythonEventManager::SelectAnswer(int iIndex, int iAnswer)
{
if (!CheckEventSetIndex(iIndex))
return;
//TEventSet * pEventSet = m_EventSetVector[iIndex];
CPythonNetworkStream::Instance().SendScriptAnswerPacket(iAnswer);
}
void CPythonEventManager::SetVisibleStartLine(int iIndex, int iStartLine)
{
if (!CheckEventSetIndex(iIndex))
return;
TEventSet * pEventSet = m_EventSetVector[iIndex];
if (DWORD(iStartLine) > pEventSet->ScriptTextLineList.size())
return;
pEventSet->iVisibleStartLine = iStartLine;
}
void CPythonEventManager::SetVisibleLineCount(int iIndex, int iLineCount)
{
if (!CheckEventSetIndex(iIndex))
return;
TEventSet * pEventSet = m_EventSetVector[iIndex];
pEventSet->iVisibleLineCount = iLineCount;
}
int CPythonEventManager::GetVisibleStartLine(int iIndex)
{
if (!CheckEventSetIndex(iIndex))
return 0;
TEventSet * pEventSet = m_EventSetVector[iIndex];
return pEventSet->iVisibleStartLine;
}
int CPythonEventManager::GetLineCount(int iIndex)
{
if (!CheckEventSetIndex(iIndex))
return 0;
TEventSet * pEventSet = m_EventSetVector[iIndex];
return pEventSet->ScriptTextLineList.size()+pEventSet->iAdjustLine;
}
void CPythonEventManager::ClearLine(TEventSet * pEventSet)
{
if (!pEventSet)
return;
for (TScriptTextLineList::iterator itor = pEventSet->ScriptTextLineList.begin(); itor != pEventSet->ScriptTextLineList.end(); ++itor)
{
TTextLine & rkLine = *itor;
CGraphicTextInstance * pInstance = rkLine.pInstance;
pInstance->Destroy();
pInstance->Update();
}
pEventSet->pCurrentTextLine->Destroy();
pEventSet->pCurrentTextLine->Update();
// clear
pEventSet->pCurrentTextLine = NULL;
pEventSet->ScriptTextLineList.clear();
__InsertLine(*pEventSet);
}
void CPythonEventManager::__InsertLine(TEventSet& rEventSet, BOOL isCenter, int iX_pos)
{
if (rEventSet.pCurrentTextLine)
{
TTextLine kLine;
if (CGraphicTextInstance::HORIZONTAL_ALIGN_CENTER == rEventSet.pCurrentTextLine->GetHorizontalAlign())
{
kLine.ixLocal = rEventSet.iWidth/2;
kLine.iyLocal = rEventSet.iyLocal;
}
else
{
int textWidth;
int textHeight;
rEventSet.pCurrentTextLine->GetTextSize(&textWidth,&textHeight);
if (GetDefaultCodePage() == CP_1256)
{
kLine.ixLocal = rEventSet.iWidth;
if (iX_pos != 0)
{
kLine.ixLocal -= iX_pos - 20;
kLine.ixLocal += textWidth / 2;
}
}
else
{
kLine.ixLocal = 0;
if (iX_pos != 0)
{
kLine.ixLocal += (iX_pos - 20);
kLine.ixLocal -= textWidth / 2;
}
}
kLine.iyLocal = rEventSet.iyLocal;
}
kLine.pInstance = rEventSet.pCurrentTextLine;
rEventSet.ScriptTextLineList.push_back(kLine);
__AddSpace(rEventSet, c_fLine_Temp);
}
// DEFAULT_FONT
//CGraphicText * pText = (CGraphicText*)CResourceManager::Instance().GetTypeResourcePointer(g_strDefaultFontName.c_str());
CGraphicText* pkDefaultFont = static_cast<CGraphicText*>(DefaultFont_GetResource());
if (!pkDefaultFont)
{
TraceError("CPythonEventManager::InsertLine - CANNOT_FIND_DEFAULT_FONT");
return;
}
rEventSet.pCurrentTextLine = m_ScriptTextLinePool.Alloc();
if (!rEventSet.pCurrentTextLine)
{
TraceError("CPythonEventManager::InsertLine - OUT_OF_TEXT_LINE");
return;
}
rEventSet.pCurrentTextLine->SetTextPointer(pkDefaultFont);
// END_OF_DEFAULT_FONT
rEventSet.pCurrentTextLine->SetColor(1.0f, 1.0f, 1.0f);
rEventSet.pCurrentTextLine->SetValue("");
if (rEventSet.isTextCenterMode || isCenter)
{
rEventSet.pCurrentTextLine->SetHorizonalAlign(CGraphicTextInstance::HORIZONTAL_ALIGN_CENTER);
rEventSet.pCurrentTextLine->SetPosition(rEventSet.ix+rEventSet.iWidth/2, rEventSet.iy + rEventSet.iyLocal);
}
else
{
if (GetDefaultCodePage() == CP_1256)
{
rEventSet.pCurrentTextLine->SetHorizonalAlign(CGraphicTextInstance::HORIZONTAL_ALIGN_LEFT);
rEventSet.pCurrentTextLine->SetPosition(rEventSet.ix + rEventSet.iWidth, rEventSet.iy + rEventSet.iyLocal);
}
else
{
rEventSet.pCurrentTextLine->SetHorizonalAlign(CGraphicTextInstance::HORIZONTAL_ALIGN_LEFT);
rEventSet.pCurrentTextLine->SetPosition(rEventSet.ix, rEventSet.iy + rEventSet.iyLocal);
}
}
rEventSet.iCurrentLetter = 0;
rEventSet.strCurrentLine = "";
}
void CPythonEventManager::RefreshLinePosition(TEventSet * pEventSet)
{
//int iCount = 0;
for (TScriptTextLineList::iterator itor = pEventSet->ScriptTextLineList.begin(); itor != pEventSet->ScriptTextLineList.end(); ++itor)
{
TTextLine & rkLine = *itor;
CGraphicTextInstance * pInstance = rkLine.pInstance;
pInstance->SetPosition(pEventSet->ix + rkLine.ixLocal, pEventSet->iy + rkLine.iyLocal);
}
int ixTextPos;
if (CGraphicTextInstance::HORIZONTAL_ALIGN_CENTER == pEventSet->pCurrentTextLine->GetHorizontalAlign())
{
ixTextPos = pEventSet->ix+pEventSet->iWidth/2;
}
else
{
if (GetDefaultCodePage() == CP_1256)
ixTextPos = pEventSet->ix+pEventSet->iWidth;
else
ixTextPos = pEventSet->ix;
}
pEventSet->pCurrentTextLine->SetPosition(ixTextPos, pEventSet->iy + pEventSet->iyLocal);
}
void CPythonEventManager::__AddSpace(TEventSet& rEventSet, int iSpace)
{
rEventSet.iyLocal += iSpace;
}
bool CPythonEventManager::GetScriptEventIndex(const char * c_szName, int * pEventPosition, int * pEventType)
{
const char * c_szEventName;
if ('/' == c_szName[0])
{
*pEventPosition = EVENT_POSITION_END;
c_szEventName = &c_szName[1];
}
else
{
*pEventPosition = EVENT_POSITION_START;
c_szEventName = &c_szName[0];
}
std::map<std::string,int>::iterator it = EventTypeMap.find(c_szEventName);
if (it == EventTypeMap.end())
{
Tracef(" !! PARSING ERROR - Strange Command : %s\n", c_szEventName);
return false;
}
*pEventType = it->second;
return true;
}
bool CPythonEventManager::CheckEventSetIndex(int iIndex)
{
if (iIndex < 0)
return false;
if ((DWORD) iIndex >= m_EventSetVector.size())
return false;
return true;
}
void CPythonEventManager::Destroy()
{
m_EventSetVector.clear();
m_EventSetPool.Clear();
m_ScriptTextLinePool.Clear();
}
void CPythonEventManager::SetInterfaceWindow(PyObject * poInterface)
{
m_poInterface = poInterface;
}
void CPythonEventManager::SetLeftTimeString(const char * c_szString)
{
m_strLeftTimeString = c_szString;
}
CPythonEventManager::CPythonEventManager()
: m_poInterface(0), m_strLeftTimeString("<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20>ð<EFBFBD> : %d<><64>")
{
EventTypeMap["LETTER"]=EVENT_TYPE_LETTER;
EventTypeMap["COLOR"]=EVENT_TYPE_COLOR;
EventTypeMap["DELAY"]=EVENT_TYPE_DELAY;
EventTypeMap["ENTER"]=EVENT_TYPE_ENTER;
EventTypeMap["WAIT"]=EVENT_TYPE_WAIT;
EventTypeMap["CLEAR"]=EVENT_TYPE_CLEAR;
EventTypeMap["QUESTION"]=EVENT_TYPE_QUESTION;
EventTypeMap["NEXT"]=EVENT_TYPE_NEXT;
EventTypeMap["DONE"]=EVENT_TYPE_DONE;
EventTypeMap["LEFTIMAGE"]=EVENT_TYPE_LEFT_IMAGE;
EventTypeMap["TOPIMAGE"]=EVENT_TYPE_TOP_IMAGE;
EventTypeMap["BGIMAGE"]=EVENT_TYPE_BACKGROUND_IMAGE;
EventTypeMap["IMAGE"]=EVENT_TYPE_IMAGE;
EventTypeMap["ADDMAPSIGNAL"]=EVENT_TYPE_ADD_MAP_SIGNAL;
EventTypeMap["CLEARMAPSIGNAL"]=EVENT_TYPE_CLEAR_MAP_SIGNAL;
EventTypeMap["SETMSGPOS"]=EVENT_TYPE_SET_MESSAGE_POSITION;
EventTypeMap["ADJMSGPOS"]=EVENT_TYPE_ADJUST_MESSAGE_POSITION;
EventTypeMap["SETCMAPPOS"]=EVENT_TYPE_SET_CENTER_MAP_POSITION;
EventTypeMap["QUESTBUTTON"]=EVENT_TYPE_QUEST_BUTTON;
// HIDE_QUEST_LETTER
EventTypeMap["QUESTBUTTON_CLOSE"]=EVENT_TYPE_QUEST_BUTTON_CLOSE;
// END_OF_HIDE_QUEST_LETTER
EventTypeMap["SLEEP"]=EVENT_TYPE_SLEEP;
EventTypeMap["SET_CAMERA"]=EVENT_TYPE_SET_CAMERA;
EventTypeMap["BLEND_CAMERA"]=EVENT_TYPE_BLEND_CAMERA;
EventTypeMap["RESTORE_CAMERA"]=EVENT_TYPE_RESTORE_CAMERA;
EventTypeMap["FADE_OUT"]=EVENT_TYPE_FADE_OUT;
EventTypeMap["FADE_IN"]=EVENT_TYPE_FADE_IN;
EventTypeMap["WHITE_OUT"]=EVENT_TYPE_WHITE_OUT;
EventTypeMap["WHITE_IN"]=EVENT_TYPE_WHITE_IN;
EventTypeMap["CLEAR_TEXT"]=EVENT_TYPE_CLEAR_TEXT;
EventTypeMap["TEXT_HORIZONTAL_ALIGN_CENTER"]=EVENT_TYPE_TEXT_HORIZONTAL_ALIGN_CENTER;
EventTypeMap["TITLE_IMAGE"]=EVENT_TYPE_TITLE_IMAGE;
EventTypeMap["RUN_CINEMA"]=EVENT_TYPE_RUN_CINEMA;
EventTypeMap["DUNGEON_RESULT"]=EVENT_TYPE_DUNGEON_RESULT;
EventTypeMap["ITEM"]=EVENT_TYPE_ITEM_NAME;
EventTypeMap["MOB"]=EVENT_TYPE_MONSTER_NAME;
EventTypeMap["COLOR256"]=EVENT_TYPE_COLOR256;
EventTypeMap["WINDOW_SIZE"]=EVENT_TYPE_WINDOW_SIZE;
EventTypeMap["INPUT"]=EVENT_TYPE_INPUT;
EventTypeMap["CONFIRM_WAIT"]=EVENT_TYPE_CONFIRM_WAIT;
EventTypeMap["END_CONFIRM_WAIT"]=EVENT_TYPE_END_CONFIRM_WAIT;
EventTypeMap["INSERT_IMAGE"]=EVENT_TYPE_INSERT_IMAGE;
EventTypeMap["SELECT_ITEM"]=EVENT_TYPE_SELECT_ITEM;
}
CPythonEventManager::~CPythonEventManager()
{
}
Copy Permalink