void VMVupManager::StartTesting(VMVup* _curVUP, __int64 _startTime)
{
VMVup* pVup = _curVUP;
D_CHECK(pVup);
__int64 nowms = _startTime;
UDP_PACK pack;
pack.m_uiType = EPT_M2C_StartTesting;
pack.m_unValue.m_StartTestingParam.m_uiBurstTime = nowms;
#ifndef USE_UDT_LIB
m_pSendSocket->SetAddress(pVup->GetIPAddress(), pVup->GetPort());
m_pSendSocket->SendTo((const Char*)&pack, sizeof(UDP_PACK));
#else
s32 iRet = UDT::sendmsg(pVup->GetClientSocket(), (const Char*)&pack, sizeof(UDP_PACK));
if(iRet == UDT::ERROR)
{
LOG_INFO("[ERROR] sendmsg failed: %s\n", UDT::getlasterror().getErrorMessage());
return;
}
else
{
if(iRet != sizeof(UDP_PACK))
{
LOG_INFO("[ERROR] send start testing to %d(%s:%d) failed\n", _curVUP->GetUniqueID(), _curVUP->GetIPAddress(), _curVUP->GetPort());
}
else
{
LOG_INFO("send start testing to %d(%s:%d) successfully\n", _curVUP->GetUniqueID(), _curVUP->GetIPAddress(), _curVUP->GetPort());
}
return;
}
#endif
}
//----------------------------------------------------------------------------------------------------------------
void VMVupManager::AddClientSocket(UDTSOCKET _pNewSocket)
{
D_CHECK(_pNewSocket != UDT::ERROR);
std::vector<UDTSOCKET>& pClientArray = m_pClientSockets.RetrieveContrainer();
pClientArray.push_back(_pNewSocket);
m_pClientSockets.ReleaseContrainer();
}
void WinDxRenderer::SetLight(u32 p_uiIdx, const Light& p_Light)
{
D_CHECK(m_poMainD3DDevice);
D3DLIGHT9 l_Light;
memset(&l_Light, 0, sizeof(l_Light));
switch(p_Light.m_uiType)
{
case E_LightType_Spot:
l_Light.Type = D3DLIGHT_SPOT;
break;
case E_LightType_Point:
l_Light.Type = D3DLIGHT_POINT;
break;
}
l_Light.Ambient = WinDxMapping::MappingColor(p_Light.m_Ambient);
l_Light.Diffuse = WinDxMapping::MappingColor(p_Light.m_Diffuse);
l_Light.Specular = WinDxMapping::MappingColor(p_Light.m_Specular);
l_Light.Position = D3DXVECTOR3(p_Light.m_vPosition.x, p_Light.m_vPosition.y, p_Light.m_vPosition.z);
l_Light.Direction = D3DXVECTOR3(p_Light.m_vDirection.x, p_Light.m_vDirection.y, p_Light.m_vDirection.z);
l_Light.Range = p_Light.m_fRange;
l_Light.Falloff = p_Light.m_fFalloff;
l_Light.Attenuation0= p_Light.m_fAttenuation[0];
l_Light.Attenuation1= p_Light.m_fAttenuation[1];
l_Light.Attenuation2= p_Light.m_fAttenuation[2];
l_Light.Theta = p_Light.m_fTheta;
l_Light.Phi = p_Light.m_fPhi;
m_poMainD3DDevice->SetLight(p_uiIdx, &l_Light);
m_poMainD3DDevice->LightEnable(p_uiIdx, true);
}
void FEEditorCanvas::Export(File* _pFile, u32 pitchType, u32 teamState, u32 position)
{
D_CHECK(_pFile->IsValid());
ElementPairMapIterator it = m_Elements.begin();
while(it != m_Elements.end())
{
std::stringstream ss;
ss << "FormationStaticDatabase.AddFormationPoint(";
if(pitchType == FormationEditor::EPitchType_Normal)
ss << "EFormationPitchType.EPitchType_Normal,";
else
ss << "EFormationPitchType.EPitchType_Large,";
if(teamState == FormationEditor::ETeamState_Attack)
ss << "EFormationTeamState.ETeamState_Attack,";
else
ss << "EFormationTeamState.ETeamState_Defend,";
ss << position << ",";
ElementPair* ePair = (*it).second;
Vec3 refPos = ePair->m_RefElement->GetPosition();
Vec3 formationPos = ePair->m_FormationElement->GetPosition();
ss << "Vector3(" << refPos.x << "," << refPos.y << "," << refPos.z << "),";
ss << "Vector3(" << formationPos.x << "," << formationPos.y << "," << formationPos.z << "));\r\n";
_pFile->Write(ss.str().c_str(), ss.str().length());
++it;
}
}
void FEPlayer::Deserialize(TiXmlDocument* _poXmlDoc, TiXmlElement* _poParent)
{
TiXmlElement* poElement = _poParent->FirstChildElement("Player");
if(poElement)
{
int isMovable, isDeletable;
poElement->QueryIntAttribute("is_movable", &isMovable);
poElement->QueryIntAttribute("is_deletable", &isDeletable);
if(isMovable)
AddFlags(EFEFlag_Movable);
else
RemoveFlags(EFEFlag_Movable);
if(isDeletable)
AddFlags(EFEFlag_Deletable);
else
RemoveFlags(EFEFlag_Deletable);
TiXmlElement* poPosElement = poElement->FirstChildElement("Position");
D_CHECK(poPosElement);
double x, y;
poPosElement->QueryDoubleAttribute("x", &x);
poPosElement->QueryDoubleAttribute("y", &y);
SetPosition(Vec3(x, y, 0.f));
SetColor(GetColor(m_id));
}
}
Bool FormationEditor::StopRealGame()
{
D_CHECK(IsInRealGame());
m_RealGameCanvas->Stop();
m_Mode = EEditorMode_Edit;
m_SimulatedRefCanvas = NULL;
return true;
}
Bool WinDxRenderer::BeginFrame()
{
D_CHECK(m_poMainD3DDevice);
//Clear(D_Color(200, 200, 200), E_ClearFlagTarget | E_ClearFlagZBuffer);
//m_poMainD3DDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
return SUCCEEDED(m_poMainD3DDevice->BeginScene());
}
void WinDxRenderer::Clear(const D_Color& p_Color, u32 p_uiClearFlag)
{
D_CHECK(m_poMainD3DDevice);
if(FAILED(m_poMainD3DDevice->Clear(0, NULL,
WinDxMapping::MappingClearFlag(p_uiClearFlag),
WinDxMapping::MappingColor(p_Color),
1.f, 0)))
D_FatalError("Clear Failed");
}
void WinDxRenderer::SetProjectionMatrix(const Mat4 &p_ProjectionMatrix)
{
D_CHECK(m_poMainD3DDevice);
D3DXMATRIX l_ProjectionMatrix = WinDxMapping::MappingMat4(p_ProjectionMatrix);
HRESULT hr;
if(FAILED( hr = m_poMainD3DDevice->SetTransform(D3DTS_PROJECTION, &l_ProjectionMatrix) ))
D_FatalError("Cannot set Projection Matrix");
}
void WinDxRenderer::SetViewMatrix(const Mat4 &p_ViewMat)
{
D_CHECK(m_poMainD3DDevice);
D3DXMATRIX l_ViewMat = WinDxMapping::MappingMat4(p_ViewMat);
HRESULT hr;
if(FAILED( hr = m_poMainD3DDevice->SetTransform(D3DTS_VIEW, &l_ViewMat) ))
D_FatalError("Cannot set View Matrix");
}
u32 WorkingRunner::Run()
{
VMThreadSafeContainer<std::vector<UDTSOCKET>>& clientSocketContainer = m_pMan->GetClientSocket();
std::vector<UDTSOCKET>* rfds = NULL, *efds = NULL;
rfds = new std::vector<UDTSOCKET>;
efds = new std::vector<UDTSOCKET>;
while(!m_bRequestStop)
{
std::vector<UDTSOCKET>& clientSocket = clientSocketContainer.RetrieveContrainer();
s32 iRet = UDT::selectEx(clientSocket, rfds, NULL, efds, 0);
clientSocketContainer.ReleaseContrainer();
if(iRet == UDT::ERROR)
{
LOG_INFO("selectEx failed: %s\n", UDT::getlasterror().getErrorMessage());
return 1;
}
else if(iRet == 0)
{
::Sleep(10);
}
else if(iRet > 0)
{
//Handle rfds
UDP_PACKWrapper recvPacket;
std::vector<UDTSOCKET>::const_iterator itRead = rfds->begin();
for(itRead = rfds->begin(); itRead != rfds->end(); ++itRead)
{
UDTSOCKET readSocket = *itRead;
D_CHECK(readSocket != UDT::INVALID_SOCK);
s32 iRecv = UDT::recvmsg(readSocket, (char*)&recvPacket.m_InnerData, sizeof(UDP_PACK));
if(iRecv == UDT::ERROR)
{
LOG_INFO("recvmsg failed(%d): %s\n", readSocket, UDT::getlasterror().getErrorMessage());
continue;
}
recvPacket.m_ClientSocket = readSocket;
m_pUDPPackBuffer->InsertUDPData(recvPacket);
}
//Handle efds
std::vector<UDTSOCKET>::const_iterator itExpect = efds->begin();
for(itExpect = efds->begin(); itExpect != efds->end(); ++itExpect)
{
UDTSOCKET expectSocket = *itExpect;
recvPacket.m_ClientSocket = expectSocket;
recvPacket.m_InnerData.m_uiType = EPT_C2M_LostConnection;
m_pUDPPackBuffer->InsertUDPData(recvPacket);
//m_pMan->LostConnection(expectSocket);
}
}
}
//TJQ: crash if clean up these vector, don't know why
//delete rfds;
//delete efds;
return 0;
}
//#pragma optimize("", off)
void VMVupManager::_UpdateRDVPoint()
{
RDVPointListIterator it = m_poRDVList.begin();
while(it != m_poRDVList.end())
{
RDVPointInfo& info = (*it).second;
D_CHECK(info.m_RunningInfo.IsValid());
f32 fNow = GameEngine::GetGameEngine()->GetClockMod()->GetTotalElapsedSeconds();
if(info.m_RunningInfo.m_ClientList.size() >= info.m_uiExpectedNum ||
fNow - info.m_RunningInfo.m_fStartTime >= (f32)info.m_uiTimeOut)
{
//Default value
s32 iDelayOfStartTime = 5000;
s32 iIntervalOfEachGroup = 0;
s32 iMaxGroupNum = 1;
s32 iRunningID = info.m_RunningInfo.m_uiCurrentRunningID;
RDVPointParameterListIterator itRDVPointParam = m_poRDVParam.find(Protocal::GetRDVPointID(Protocal::GetRDVPointMajor(iRunningID), 0));
if(itRDVPointParam != m_poRDVParam.end())
{
RDVPointParameter& param = (*itRDVPointParam).second;
iDelayOfStartTime = param.m_iDelayOfStartTime;
iIntervalOfEachGroup = param.m_iIntervalOfEachGroup;
iMaxGroupNum = param.m_iGroupNum;
}
struct __timeb64 timebuffer;
_ftime64(&timebuffer);
__int64 curTime = timebuffer.time * 1000 + timebuffer.millitm;
for(s32 i = 0; i < info.m_RunningInfo.m_ClientList.size(); ++i)
{
VMVup* pVup = FindVup(info.m_RunningInfo.m_ClientList[i]);
if(!pVup)
continue;
if(pVup->GetGroup() >= 0)
{
StartTesting(pVup, curTime + iDelayOfStartTime + pVup->GetGroup() * iIntervalOfEachGroup);
}
}
for(s32 i = 0; i < iMaxGroupNum; ++i)
{
__int64 nowms = curTime + iDelayOfStartTime + i * iIntervalOfEachGroup;
__int64 nows = nowms / 1000;
char timeline[26];
ctime_s(timeline, 26, &(nows));
LOG_INFO("RDVPoint(%d,%d)..Group(%d)..Time of starting test: %.19s.%03hu\n",
Protocal::GetRDVPointMajor(iRunningID), Protocal::GetRDVPointMinor(iRunningID), i, timeline, nowms % 1000);
}
VMSummary::GetPtr()->RemoveRDVPoint(Protocal::GetRDVPointMajor(iRunningID), Protocal::GetRDVPointMinor(iRunningID));
it = m_poRDVList.erase(it);
}
else
{
++it;
}
}
}
bool FormationEditor::StopSimulation()
{
D_CHECK(IsSimulating());
m_SimulatedCanvas->Stop();
m_Mode = EEditorMode_Edit;
m_SimulatedRefCanvas = NULL;
return true;
}
ClockModule::ClockModule()
:m_uiFrameElapsedTicks(0)
,m_uiTotalElapsedTicks(0)
,m_fFrameElapsedSeconds(0.f)
,m_fTotalElapsedSeconds(0.f)
,m_uiCurrentTicks(0)
,m_iStartFrameTicks(0)
,m_iRateLock(-1)
{
m_poTick = CallCreator<Tick>(E_CreatorType_Tick);
D_CHECK(m_poTick);
m_uiLastTicks = m_poTick->GetTick();
}
void WinDxRenderer::InitRender(u32 p_uiWidth, u32 p_uiHeight, const Char* p_strTitle, Bool p_bIsWindowed, void* p_poOuter)
{
WinDxRenderWindow *l_poMainWindow = new WinDxRenderWindow;
D_CHECK(l_poMainWindow);
l_poMainWindow->InitWindow(p_uiWidth, p_uiHeight, p_strTitle, p_bIsWindowed, p_poOuter);
m_poMainWindow = l_poMainWindow;
m_poMainD3DDevice = l_poMainWindow->GetDevice()->GetD3DDevice();
m_poMainHwnd = l_poMainWindow->GetHWND();
m_qRotationFromGUI = Quat::IDENTITY;
m_vTranslationFromGUI = Vec3::ZERO;
m_fZoomFromGUI = 1.f;
}
void FEEditorCanvas::Delete()
{
if(m_SelectedElement)
{
if(m_SelectedElement->HasFlags(EFEFlag_Deletable))
{
ElementPairMapIterator it = m_Elements.find(m_SelectedElement->GetID());
D_CHECK(it != m_Elements.end())
ElementPair* pPair = (*it).second;
delete pPair->m_RefElement;
delete pPair->m_FormationElement;
delete pPair;
m_Elements.erase(it);
m_SelectedElement = NULL;
}
}
}
void WinDxRenderer::SetWorldMatrix(const Mat4 &p_WorldMat)
{
D_CHECK(m_poMainD3DDevice);
/*Mat4 mRotFromGUI;
mRotFromGUI.Rotation(m_qRotationFromGUI);
Mat4 mTrans = p_WorldMat;
Vec3 v = m_vTranslationFromGUI;
mTrans.Translation(v.x, v.y, v.z);
mTrans = mTrans * mRotFromGUI;*/
D3DXMATRIX l_WorldMat = WinDxMapping::MappingMat4(p_WorldMat);
HRESULT hr;
if(FAILED( hr = m_poMainD3DDevice->SetTransform(D3DTS_WORLD, &l_WorldMat) ))
D_FatalError("Cannot set World Matrix");
}
int main(int argc, char* argv[])
#endif
{
#if PLATFORM_TYPE == PLATFORM_WIN32
::SetPriorityClass(::GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
#endif
TsiULibSettings libSettings;
InitLibSettings(&libSettings);
#if PLATFORM_TYPE == PLATFORM_WIN32
libSettings.SetupCreator(new T_Creator<WinPanic>, E_CreatorType_Panic);
libSettings.SetupCreator(new T_Creator<WinTick>, E_CreatorType_Tick);
libSettings.SetupCreator(new T_Creator<WinGDIRenderWindow>, E_CreatorType_RenderWindow);
libSettings.SetupCreator(new T_Creator<WinGDIRenderer>, E_CreatorType_Renderer);
libSettings.SetupCreator(new T_Creator<WinRenderGUIWindowMsg>, E_CreatorType_RenderWindowMsg);
libSettings.SetupCreator(new T_Creator<WinInputManager>, E_CreatorType_Input);
libSettings.SetupCreator(new T_Creator<DefaultFile>, E_CreatorType_File);
#endif
libSettings.DefineMacro(E_LS_Has_GUI);
#ifndef USE_UDT_LIB
libSettings.DefineMacro(E_LS_Has_Network);
#endif
g_poEngine = new GameEngine(1140, 800, "VUP Manager (Ver.Beta 0.8.1)", false);
D_CHECK(g_poEngine);
if(!g_poEngine->Init())
D_FatalError("Init Scene Error");
g_poEngine->MainLoop();
if(!g_poEngine->UnInit())
D_FatalError("UnInit Scene Error");
D_SafeDelete(g_poEngine);
UninitLibSettings(&libSettings);
return 0;
}
void FormationEditor::Export(File* pFile)
{
D_CHECK(pFile->IsValid());
Char start[] = "do\r\n";
pFile->Write(start, strlen(start));
for(s32 i = 0; i < EPitchType_Num; ++i)
{
for(s32 j = 0; j < ETeamState_Num; ++j)
{
for(s32 k = 0; k < kMaxPositionCount; ++k)
{
m_Canvases[i][j][k]->Export(pFile, i, j, k);
}
}
}
Char end[] = "end\r\n";
pFile->Write(end, strlen(end));
}
int main(int argc, char* argv[])
#endif
{
#if PLATFORM_TYPE == PLATFORM_WIN32
::SetPriorityClass(::GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
#endif
TsiULibSettings libSettings;
InitLibSettings(&libSettings);
#if PLATFORM_TYPE == PLATFORM_WIN32
libSettings.SetupCreator(new T_Creator<WinPanic>, E_CreatorType_Panic);
libSettings.SetupCreator(new T_Creator<WinTick>, E_CreatorType_Tick);
libSettings.SetupCreator(new T_Creator<WinGDIRenderWindow>, E_CreatorType_RenderWindow);
libSettings.SetupCreator(new T_Creator<WinGDIRenderer>, E_CreatorType_Renderer);
libSettings.SetupCreator(new T_Creator<WinRenderGUIWindowMsg>, E_CreatorType_RenderWindowMsg);
libSettings.SetupCreator(new T_Creator<WinInputManager>, E_CreatorType_Input);
libSettings.SetupCreator(new T_Creator<DefaultFile>, E_CreatorType_File);
#endif
libSettings.DefineMacro(E_LS_Has_GDI);
libSettings.DefineMacro(E_LS_Has_GUI);
g_poEngine = new MyEngine(g_WindowWidth, g_WindowHeight, "SoccerDebugger(SSO version) V2.5", g_bIsAlwaysOnTop);
D_CHECK(g_poEngine);
if(!g_poEngine->Init())
D_FatalError("Init Scene Error");
g_poEngine->MainLoop();
if(!g_poEngine->UnInit())
D_FatalError("UnInit Scene Error");
D_SafeDelete(g_poEngine);
UninitLibSettings(&libSettings);
return 0;
}
Bool FormationEditor::StartRealGame(const RealGameInfo& rgInfo)
{
D_CHECK(IsEditor());
m_Mode = EEditorMode_RealGame;
m_RealGameCanvas->Setup(rgInfo);
int nextIdx = 0;
for(int i = 0; i < 10; ++i)
{
if(rgInfo.m_Player[i].m_HasValidData)
{
if(rgInfo.m_Player[i].m_Team == kHOME_TEAM)
{
m_RefPlayerPositionInTB[nextIdx++] = rgInfo.m_Player[i].m_Pos;
}
}
}
for(int i = 0; i < 10; ++i)
{
if(rgInfo.m_Player[i].m_HasValidData)
{
if(rgInfo.m_Player[i].m_Team == kAWAY_TEAM)
{
m_RefPlayerPositionInTB[nextIdx++] = rgInfo.m_Player[i].m_Pos;
}
}
}
if(!rgInfo.m_IsLargePitch)
{
CoordinateInfo::sLength = kPithLenghNormal;
CoordinateInfo::sWidth = kPitchWidthNormal;
}
else
{
CoordinateInfo::sLength = kPithLenghLarge;
CoordinateInfo::sWidth = kPitchWidthLarge;
}
return true;
}
Bool Thread::Start()
{
if(HasStarted())
{
D_Output("Thread has started\n");
return false;
}
else
{
_Free();
#if PLATFORM_TYPE == PLATFORM_WIN32
DWORD threadId;
m_pThreadID = ::CreateThread(0, 0, ThreadProc, this, 0, &threadId);
if(m_pThreadID == NULL)
{
D_CHECK(0);
return false;
}
::SetThreadPriority(m_pThreadID, sThreadPriorities[m_ePriority]);
#endif
}
return true;
}
unsigned long __stdcall Thread::ThreadProc(void* ptr)
{
D_CHECK(ptr);
Thread* pThread = static_cast<Thread*>(ptr);
return pThread->_Run();
}
void VMVupManager::Create()
{
if(!_InitParameter())
{
LOG_INFO("read configuration file failed\n");
return;
}
else
{
LOG_INFO("read configuration successfully\n");
}
//Init recving packet pool
m_pUDPPackBuffer = new MemPool<UDP_PACKWrapper>();
m_pUDPPackBuffer->SetMaxSize(1000);
//Init watched value
//m_WatchedInfo.Init();
#ifndef USE_UDT_LIB
//Init network
m_pRecvSocket = new WinSocket;
s32 iRet = m_pRecvSocket->Create(E_NETWORK_PROTO_UDP, false);
D_CHECK(!iRet);
iRet = m_pRecvSocket->SetAddress(NULL, m_uiServerPort);
D_CHECK(!iRet);
iRet = m_pRecvSocket->Bind();
D_CHECK(!iRet);
m_pSendSocket = new WinSocket;
iRet = m_pSendSocket->Create(E_NETWORK_PROTO_UDP, false);
D_CHECK(!iRet);
//iRet = m_pSendSocket->SetAddress(NULL, 52346);
//D_CHECK(!iRet);
//Init recv thread
m_pRecvThread = new Thread(new RecvUDPRunner(m_pRecvSocket, m_pUDPPackBuffer));
Bool bRet = m_pRecvThread->Start();
D_CHECK(bRet);
Refresh();
#else
m_ListeningThread = new Thread(new ListeningRunner(this, m_uiServerPort));
Bool bRet = m_ListeningThread->Start();
D_CHECK(bRet);
m_WorkingThread = new Thread(new WorkingRunner(this, m_pUDPPackBuffer));
bRet = m_WorkingThread->Start();
D_CHECK(bRet);
m_TransferLoggerThread = new Thread(new TransferLogger(m_uiServerTransferLogPort));
bRet = m_TransferLoggerThread->Start();
D_CHECK(bRet);
#endif
GameEngine::GetGameEngine()->GetEventMod()->RegisterHandler(
(EventType_t)(E_ET_AgentLeave),
new MEventHandler<VMVupManager>(this, &VMVupManager::onAgentLeave));
GameEngine::GetGameEngine()->GetEventMod()->RegisterHandler(
(EventType_t)(E_ET_VUPInfoUpdate),
new MEventHandler<VMVupManager>(this, &VMVupManager::onVUPInfoChange));
}
bool FormationEditor::StartSimulation(const FESimulatedCanvas::SimulatedSettings& setup)
{
D_CHECK(IsEditor());
if(!setup.m_AwayPlayerPosition.Size() && !setup.m_HomePlayerPosition.Size())
return false;
std::string fullPath = setup.m_RootDir + "\\Media\\scripts\\ai\\formationsimulation.lua";
File* pLuaFile = FileManager::Get().OpenFile(fullPath.c_str(), E_FOM_Write | E_FOM_Text);
if(!pLuaFile)
return false;
std::stringstream ss;
ss << "DefaultMatchSetup()" << "\r\n";
ss << "package.path = \"scripts:/?.lua\"" << "\r\n";
ss << "require \"MiniGameSharedFunctions\"" << "\r\n";
ss << "MatchSetup['Init'] = function(newGame)" << "\r\n";
ss << "\tgameId = newGame.CreateGame();" << "\r\n";
if(setup.m_PitchType == EPitchType_Normal)
ss << "\tnewGame.AddPitch(\"Street_SH_Night_01\");" << "\r\n";
else
ss << "\tnewGame.AddPitch(\"stadium_BJ_60_40\");" << "\r\n";
ss << "\tnewGame.AddBall(\"CommonObjects\");" << "\r\n";
for(int i = 0; i < setup.m_HomePlayerPosition.Size(); ++i)
{
m_RefPlayerPositionInTB[i] = setup.m_HomePlayerPosition[i];
ss << "\tMatchSetup.player" << i + 1 << " = newGame.AddPlayer('SM_M_Vs_Red', ETeam.ETeam_HOME);" << "\r\n";
}
for(int i = 0; i < setup.m_AwayPlayerPosition.Size(); ++i)
{
m_RefPlayerPositionInTB[i + setup.m_HomePlayerPosition.Size()] = setup.m_AwayPlayerPosition[i];
ss << "\tMatchSetup.player" << i + 1 + setup.m_HomePlayerPosition.Size()
<< " = newGame.AddPlayer('SM_M_Vs_Blue', ETeam.ETeam_AWAY);" << "\r\n";
}
ss << "\tnewGame.SetHasNoHumanPlayer(ETeam.ETeam_HOME);" << "\r\n";
ss << "\tnewGame.SetHasNoHumanPlayer(ETeam.ETeam_AWAY);" << "\r\n";
ss << "\tnewGame.SetHasNoGoalkeeper(ETeam.ETeam_HOME);" << "\r\n";
ss << "\tnewGame.SetHasNoGoalkeeper(ETeam.ETeam_AWAY);" << "\r\n";
ss << "\tnewGame.RunGame(gameId)" << "\r\n";
ss << "end" << "\r\n";
ss << "MatchSetup['Setup'] = function(newGame)" << "\r\n";
ss << "\tnewGame.SetInputMode(InputMode.Normal);" << "\r\n";
for(int i = 0; i < setup.m_HomePlayerPosition.Size(); ++i)
{
ss << "\tGameLogic.ClearPlayerAI( MatchSetup.player" << i + 1 << " )" << "\r\n";
ss << "\tGameLogic.AddBehaviourModule(MatchSetup.player" << i + 1
<< ", EBehaviourModule.EBehaviourModule_IDLE);" << "\r\n";
ss << "\tGameLogic.AddBehaviourModule(MatchSetup.player" << i + 1
<< ", EBehaviourModule.EBehaviourModule_NEWAI_ATTACK_BASICFORMATION);" << "\r\n";
ss << "\tGameLogic.AddBehaviourModule(MatchSetup.player" << i + 1
<< ", EBehaviourModule.EBehaviourModule_NEWAI_DEFEND_BASICFORMATION);" << "\r\n";
}
for(int i = 0; i < setup.m_AwayPlayerPosition.Size(); ++i)
{
ss << "\tGameLogic.ClearPlayerAI( MatchSetup.player" << i + 1 + setup.m_HomePlayerPosition.Size() << " )" << "\r\n";
ss << "\tGameLogic.AddBehaviourModule(MatchSetup.player" << i + 1 + setup.m_HomePlayerPosition.Size()
<< ", EBehaviourModule.EBehaviourModule_IDLE);" << "\r\n";
ss << "\tGameLogic.AddBehaviourModule(MatchSetup.player" << i + 1 + setup.m_HomePlayerPosition.Size()
<< ", EBehaviourModule.EBehaviourModule_NEWAI_ATTACK_BASICFORMATION);" << "\r\n";
ss << "\tGameLogic.AddBehaviourModule(MatchSetup.player" << i + 1 + setup.m_HomePlayerPosition.Size()
<< ", EBehaviourModule.EBehaviourModule_NEWAI_DEFEND_BASICFORMATION);" << "\r\n";
}
ss << "\tSequenceManager.PlaySequence( \"Camera.Side\" );" << "\r\n";
ss << "\tSequenceManager.PlaySequence( \"Game.SinglePlayer\");" << "\r\n";
ss << "end" << "\r\n";
ss << "MatchSetup['Reset'] = function(newGame)" << "\r\n";
ss << "\tGameLogic.ReinitializeBallAtEx( -5.5, 0, 0 );" << "\r\n";
ss << "\tGameLogic.ReinitializeBallState(ERequestBallState.ERequestBallState_FREE, MatchSetup.player1);" << "\r\n";
ss << "end" << "\r\n";
Bool isOk = pLuaFile->Write(ss.str().c_str(), ss.str().length());
if(!isOk)
{
FileManager::Get().CloseFile(pLuaFile);
return false;
}
std::stringstream ss2;
std::string fullPathStartupFile = setup.m_RootDir + "\\Media\\scripts\\ui_configuration.lua";
File* pStartupFile = FileManager::Get().OpenFile(fullPathStartupFile.c_str(), E_FOM_Write | E_FOM_Text);
if(!pStartupFile)
return false;
ss2 << "do" << "\r\n";
ss2 << "\tGameControl.skip_menu = true;" << "\r\n";
ss2 << "\tGameControl.set_startup_by_lua (\"Media/Scripts/ai/formationsimulation.lua\", GameType.GameType_MINIGAME);" << "\r\n";
ss2 << "end" << "\r\n";
isOk = pStartupFile->Write(ss2.str().c_str(), ss2.str().length());
if(!isOk)
{
FileManager::Get().CloseFile(pStartupFile);
FileManager::Get().CloseFile(pLuaFile);
return false;
}
FileManager::Get().CloseFile(pStartupFile);
FileManager::Get().CloseFile(pLuaFile);
if(setup.m_PitchType == EPitchType_Normal)
{
CoordinateInfo::sLength = kPithLenghNormal;
CoordinateInfo::sWidth = kPitchWidthNormal;
}
else
{
CoordinateInfo::sLength = kPithLenghLarge;
CoordinateInfo::sWidth = kPitchWidthLarge;
}
m_IsHomeAttacking = (setup.m_TeamState == ETeamState_Attack);
m_Mode = EEditorMode_Simulation;
m_SimulatedCanvas->Setup(setup);
return true;
}
void WinDxRenderer::EndFrame()
{
D_CHECK(m_poMainD3DDevice);
m_poMainD3DDevice->EndScene();
}
void WinDxRenderer::Flip()
{
D_CHECK(m_poMainD3DDevice);
m_poMainD3DDevice->Present(NULL, NULL, NULL, NULL);
}
void TArithRRNode::markAllocated(fint* use_count, fint* def_count) {
U_CHECK(_src); D_CHECK(_dest);
U_CHECK(oper);
}
//#pragma optimize("", off)
void VMVupManager::_HandleUdpPack()
{
s32 iSize = m_pUDPPackBuffer->GetSize();
if(iSize != 0)
{
UDP_PACKWrapper *poPacArray = new UDP_PACKWrapper[iSize];
m_pUDPPackBuffer->GetUDPData(poPacArray, iSize);
for(s32 i = 0; i < iSize; ++i)
{
UDP_PACKWrapper *poPackWrapper = poPacArray + i;
UDP_PACK* poPack = &(poPackWrapper->m_InnerData);
switch(poPack->m_uiType)
{
case EPT_C2M_LostConnection:
{
LostConnection(poPackWrapper->m_ClientSocket);
}
break;
case EPT_C2M_ClientRegister:
{
#ifndef USE_UDT_LIB
Char cmd[VMCommand::kMaxCommandLength];
sprintf(cmd, "addvup %d %s %d", poPack->m_unValue.m_ClientRegisterParam.m_uiPassPort,
poPackWrapper->m_SrcIPAddress.c_str(),
poPack->m_unValue.m_ClientRegisterParam.m_uiPort);
VMCommandCenter::GetPtr()->ExecuteFromString(cmd);
sprintf(cmd, "updatevup %d -rs %d -tp %d", poPack->m_unValue.m_ClientRegisterParam.m_uiPassPort,
poPack->m_unValue.m_ClientRegisterParam.m_uiStatus,
poPack->m_unValue.m_ClientRegisterParam.m_uiTestPhase);
VMCommandCenter::GetPtr()->ExecuteFromString(cmd);
UDP_PACK pack;
pack.m_uiType = EPT_M2C_ClientRegisterACK;
m_pSendSocket->SetAddress(poPackWrapper->m_SrcIPAddress.c_str(), poPack->m_unValue.m_ClientRegisterParam.m_uiPort);
m_pSendSocket->SendTo((const Char*)&pack, sizeof(UDP_PACK));
#else
UDTSOCKET curSocket = poPackWrapper->m_ClientSocket;
VMVup* pVup = FindVupBySocket(curSocket);
if(pVup)
{
pVup->SetUniqueID(poPack->m_unValue.m_ClientRegisterParam.m_uiPassPort);
pVup->SetStatus(poPack->m_unValue.m_ClientRegisterParam.m_uiStatus);
pVup->SetTestPhase(poPack->m_unValue.m_ClientRegisterParam.m_uiTestPhase);
LOG_INFO("get registered info from: %d(%s:%d)\n", pVup->GetUniqueID(), pVup->GetIPAddress(), pVup->GetPort());
Bool isOk = AddVup(pVup);
UDP_PACK pack;
pack.m_uiType = EPT_M2C_ClientRegisterACK;
if(isOk)
{
pack.m_unValue.m_RegisterAckParam.m_uiHasSuccessed = true;
s32 iRet = UDT::sendmsg(pVup->GetClientSocket(), (const Char*)&pack, sizeof(UDP_PACK));
if(iRet == UDT::ERROR)
{
LOG_INFO("[ERROR] sendmsg failed: %s\n", UDT::getlasterror().getErrorMessage());
}
}
else
{
pack.m_unValue.m_RegisterAckParam.m_uiHasSuccessed = false;
s32 iRet = UDT::sendmsg(pVup->GetClientSocket(), (const Char*)&pack, sizeof(UDP_PACK));
if(iRet == UDT::ERROR)
{
LOG_INFO("[ERROR] sendmsg failed: %s\n", UDT::getlasterror().getErrorMessage());
}
LOG_INFO("[ERROR] duplicate passport: %d\n", poPack->m_unValue.m_ClientRegisterParam.m_uiPassPort);
}
}
else
{
LOG_INFO("[ERROR] cannot find vup in client list and retry: %d\n", poPack->m_unValue.m_ClientRegisterParam.m_uiPassPort);
m_pUDPPackBuffer->InsertUDPData(*poPackWrapper);
}
#endif
}
break;
case EPT_C2M_ReportClientStatus:
{
Char cmd[VMCommand::kMaxCommandLength];
sprintf(cmd, "updatevup %d -rs %d", poPack->m_unValue.m_ReportClientStatusParam.m_uiPassPort,
poPack->m_unValue.m_ReportClientStatusParam.m_uiRunningStatus);
VMCommandCenter::GetPtr()->ExecuteFromString(cmd);
sprintf(cmd, "updatevup %d -tp %d", poPack->m_unValue.m_ReportClientStatusParam.m_uiPassPort,
poPack->m_unValue.m_ReportClientStatusParam.m_uiTestPhase);
VMCommandCenter::GetPtr()->ExecuteFromString(cmd);
//LOG_INFO("get status %s, %s\n", VMVup::kStatus[poPack->m_unValue.m_ReportClientStatusParam.m_uiRunningStatus].GetName(),
// VMVup::kTestPhase[poPack->m_unValue.m_ReportClientStatusParam.m_uiTestPhase].GetName());
}
break;
case EPT_C2M_ReachRDVPoint:
{
u16 uiRDVPoint = poPack->m_unValue.m_ReachRDVPointParam.m_uiRDVPointID;
RDVPointListIterator itRDVPoint = m_poRDVList.find(uiRDVPoint);
if(itRDVPoint == m_poRDVList.end())
{
LOG_INFO("[RDV Point] new rdv point: %d\n", uiRDVPoint);
RDVPointInfo info;
info.m_uiID = uiRDVPoint;
info.m_RunningInfo.m_bHasValidValue = true;
info.m_RunningInfo.m_uiCurrentRunningID = uiRDVPoint;
info.m_RunningInfo.m_fStartTime = GameEngine::GetGameEngine()->GetClockMod()->GetTotalElapsedSeconds();
info.m_RunningInfo.m_bIsGroupFull = false;
itRDVPoint = m_poRDVList.insert(std::pair<RDVPointID, RDVPointInfo>(uiRDVPoint, info)).first;
RDVPointInfo& pi = (*itRDVPoint).second;
RDVPointRunningInfo& runningInfo = (*itRDVPoint).second.m_RunningInfo;
RDVPointParameterListIterator itRDVPointParam = m_poRDVParam.find(Protocal::GetRDVPointID(Protocal::GetRDVPointMajor(uiRDVPoint), 0));
if(itRDVPointParam != m_poRDVParam.end())
{
const RDVPointParameter& param = (*itRDVPointParam).second;
runningInfo.m_GroupList.ReSize(param.m_iGroupNum);
for(s32 i = 0; i < runningInfo.m_GroupList.Size(); ++i)
{
runningInfo.m_GroupList[i] = 0;
}
pi.m_uiExpectedNum = param.m_uiExpectedNum;
pi.m_uiTimeOut = param.m_uiTimeOut;
}
else
{
runningInfo.m_GroupList.ReSize(1);
runningInfo.m_GroupList[0] = 0;
//TJQ: use default value
pi.m_uiExpectedNum = 9999;
pi.m_uiTimeOut = 10 * 60;
}
}
else
{
RDVPointInfo& pi = (*itRDVPoint).second;
D_CHECK(pi.m_RunningInfo.m_bHasValidValue);
D_CHECK(pi.m_RunningInfo.m_uiCurrentRunningID == uiRDVPoint);
//D_CHECK(pi.m_uiExpectedNum == poPack->m_unValue.m_ReachRDVPointParam.m_uiExpected);
//D_CHECK(pi.m_uiTimeOut == poPack->m_unValue.m_ReachRDVPointParam.m_uiTimeout);
}
RDVPointRunningInfo& runningInfo = (*itRDVPoint).second.m_RunningInfo;
RDVPointParameterListIterator itRDVPointParam = m_poRDVParam.find(Protocal::GetRDVPointID(Protocal::GetRDVPointMajor(uiRDVPoint), 0));
if(itRDVPointParam == m_poRDVParam.end())
{
//use default
VMVup* vup = FindVup(poPack->m_unValue.m_ReachRDVPointParam.m_uiPassPort);
if(vup)
{
vup->SetGroup(0);
vup->SetRDVPointID(uiRDVPoint);
runningInfo.m_GroupList[0]++;
LOG_INFO("[RDV Point] add vup %d to: R(%d, %d)G(0)[%d/-1]\n",
poPack->m_unValue.m_ReachRDVPointParam.m_uiPassPort,
Protocal::GetRDVPointMajor(uiRDVPoint),
Protocal::GetRDVPointMinor(uiRDVPoint),
runningInfo.m_GroupList[0]);
runningInfo.m_ClientList.push_back(poPack->m_unValue.m_ReachRDVPointParam.m_uiPassPort);
VMSummary::GroupUpdateParam guParam;
guParam.m_AddorRemove = true;
guParam.m_MaxNumberInGroup = -1;
guParam.m_MyGroup = 0;
guParam.m_VUPsPassport = poPack->m_unValue.m_ReachRDVPointParam.m_uiPassPort;
VMSummary::GetPtr()->UpdateGroupInfo(Protocal::GetRDVPointMajor(uiRDVPoint), Protocal::GetRDVPointMinor(uiRDVPoint), 1, guParam);
}
}
else
{
const RDVPointParameter& param = (*itRDVPointParam).second;
VMVup* vup = FindVup(poPack->m_unValue.m_ReachRDVPointParam.m_uiPassPort);
if(vup)
{
//Set RDV Point
vup->SetRDVPointID(uiRDVPoint);
//Set Group
Bool bShouldFindAEmptyGroup = true;
s32 iOriginalGroup = vup->GetGroup();
vup->SetGroup(-1);
if(!runningInfo.m_bIsGroupFull)
{
if(iOriginalGroup >= 0 && iOriginalGroup < runningInfo.m_GroupList.Size())
{
if(runningInfo.m_GroupList[iOriginalGroup] < param.m_iVUPNumInEachGroup)
{
runningInfo.m_GroupList[iOriginalGroup]++;
vup->SetGroup(iOriginalGroup);
bShouldFindAEmptyGroup = false;
}
}
if(bShouldFindAEmptyGroup)
{
s32 idx = 0;
for(idx = 0; idx < runningInfo.m_GroupList.Size(); ++idx)
{
if(runningInfo.m_GroupList[idx] < param.m_iVUPNumInEachGroup)
{
runningInfo.m_GroupList[idx]++;
vup->SetGroup(idx);
break;
}
}
if(idx == runningInfo.m_GroupList.Size())
{
runningInfo.m_bIsGroupFull = true;
}
}
}
if(vup->GetGroup() >= 0)
{
runningInfo.m_ClientList.push_back(poPack->m_unValue.m_ReachRDVPointParam.m_uiPassPort);
VMSummary::GroupUpdateParam guParam;
guParam.m_AddorRemove = true;
guParam.m_MaxNumberInGroup = param.m_iVUPNumInEachGroup;
guParam.m_MyGroup = vup->GetGroup();
guParam.m_VUPsPassport = poPack->m_unValue.m_ReachRDVPointParam.m_uiPassPort;
VMSummary::GetPtr()->UpdateGroupInfo(Protocal::GetRDVPointMajor(uiRDVPoint), Protocal::GetRDVPointMinor(uiRDVPoint), param.m_iGroupNum, guParam);
LOG_INFO("[RDV Point] add vup %d to: R(%d, %d)G(%d)[%d/%d]\n",
poPack->m_unValue.m_ReachRDVPointParam.m_uiPassPort,
Protocal::GetRDVPointMajor(uiRDVPoint),
Protocal::GetRDVPointMinor(uiRDVPoint),
vup->GetGroup(),
runningInfo.m_GroupList[vup->GetGroup()],
param.m_iVUPNumInEachGroup);
}
}
}
}
break;
}
}
delete[] poPacArray;
}
}
void AbstractArrayAtNode::markAllocated(fint* use_count, fint* def_count) {
U_CHECK(_src); D_CHECK(_dest); U_CHECK(arg);
if (error) D_CHECK(error);
use_count[Temp4]++; def_count[Temp4]++; // (potentially) uses Temp4
}
