void CPythonMiniMap::AddObserver(DWORD dwVID, float fSrcX, float fSrcY)
{
std::map<DWORD, SObserver>::iterator f=m_kMap_dwVID_kObserver.find(dwVID);
if (m_kMap_dwVID_kObserver.end()==f)
{
SObserver kObserver;
kObserver.dwSrcTime=ELTimer_GetMSec();
kObserver.dwDstTime=kObserver.dwSrcTime+1000;
kObserver.fSrcX=fSrcX;
kObserver.fSrcY=fSrcY;
kObserver.fDstX=fSrcX;
kObserver.fDstY=fSrcY;
kObserver.fCurX=fSrcX;
kObserver.fCurY=fSrcY;
m_kMap_dwVID_kObserver.insert(std::map<DWORD, SObserver>::value_type(dwVID, kObserver));
}
else
{
SObserver& rkObserver=f->second;
rkObserver.dwSrcTime=ELTimer_GetMSec();
rkObserver.dwDstTime=rkObserver.dwSrcTime+1000;
rkObserver.fSrcX=fSrcX;
rkObserver.fSrcY=fSrcY;
rkObserver.fDstX=fSrcX;
rkObserver.fDstY=fSrcY;
rkObserver.fCurX=fSrcX;
rkObserver.fCurY=fSrcY;
}
}
// 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 CPythonMiniMap::__RenderTargetMark(int ixCenter, int iyCenter)
{
int iNum = (ELTimer_GetMSec() / 80) % TARGET_MARK_IMAGE_COUNT;
CGraphicImageInstance & rInstance = m_TargetMarkGraphicImageInstances[iNum];
rInstance.SetPosition(ixCenter - rInstance.GetWidth()/2, iyCenter - rInstance.GetHeight()/2);
rInstance.Render();
}
void CPythonMiniMap::__RenderMiniWayPointMark(int ixCenter, int iyCenter)
{
int iNum = (ELTimer_GetMSec() / 67) % MINI_WAYPOINT_IMAGE_COUNT;
CGraphicImageInstance & rInstance = m_MiniWayPointGraphicImageInstances[iNum];
rInstance.SetPosition(ixCenter - rInstance.GetWidth()/2, iyCenter - rInstance.GetHeight()/2);
rInstance.Render();
}
CSoundData::CSoundData() :
m_assigned(false),
m_iRefCount(0),
m_dwPlayTime(0),
m_dwAccessTime(ELTimer_GetMSec()),
m_size(0),
m_data(NULL),
m_flag(0)
{
}
void CPythonPlayerEventHandler::OnMove(const SState& c_rkState)
{
DWORD dwCurTime=ELTimer_GetMSec();
m_dwNextWaitingNotifyTime=dwCurTime+100;
m_dwNextMovingNotifyTime=dwCurTime+300;
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendCharacterStatePacket(c_rkState.kPPosSelf, c_rkState.fAdvRotSelf, CInstanceBase::FUNC_MOVE, 0);
// Trace("move\n");
}
void 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);
}
LPVOID CSoundData::Get()
{
++m_iRefCount;
m_dwAccessTime = ELTimer_GetMSec();
if (!m_data)
ReadFromDisk();
if (m_flag & FLAG_DATA_SIZE)
return ((S32 *) m_data + 1);
else
return (m_data);
}
void CPythonMiniMap::MoveObserver(DWORD dwVID, float fDstX, float fDstY)
{
std::map<DWORD, SObserver>::iterator f=m_kMap_dwVID_kObserver.find(dwVID);
if (m_kMap_dwVID_kObserver.end()==f)
return;
SObserver& rkObserver=f->second;
rkObserver.dwSrcTime=ELTimer_GetMSec();
rkObserver.dwDstTime=rkObserver.dwSrcTime+1000;
rkObserver.fSrcX=rkObserver.fCurX;
rkObserver.fSrcY=rkObserver.fCurY;
rkObserver.fDstX=fDstX;
rkObserver.fDstY=fDstY;
}
void CActorInstance::ShakeProcess()
{
if (m_dwShakeTime)
{
D3DXVECTOR3 v3Pos(0.0f, 0.0f, 0.0f);
DWORD dwCurTime=ELTimer_GetMSec();
if (m_dwShakeTime<dwCurTime)
{
m_dwShakeTime=0;
}
else
{
int nShakeSize=10;
switch (rand()%2)
{
case 0:v3Pos.x+=rand()%nShakeSize;break;
case 1:v3Pos.x-=rand()%nShakeSize;break;
}
switch (rand()%2)
{
case 0:v3Pos.y+=rand()%nShakeSize;break;
case 1:v3Pos.y-=rand()%nShakeSize;break;
}
switch (rand()%2)
{
case 0:v3Pos.z+=rand()%nShakeSize;break;
case 1:v3Pos.z-=rand()%nShakeSize;break;
}
}
m_worldMatrix._41 += v3Pos.x;
m_worldMatrix._42 += v3Pos.y;
m_worldMatrix._43 += v3Pos.z;
}
}
// Set
void CPythonNetworkStream::SetOffLinePhase()
{
if ("OffLine" != m_strPhase)
m_phaseLeaveFunc.Run();
m_strPhase = "OffLine";
Tracen("");
Tracen("## Network - OffLine Phase ##");
Tracen("");
m_dwChangingPhaseTime = ELTimer_GetMSec();
m_phaseProcessFunc.Set(this, &CPythonNetworkStream::OffLinePhase);
m_phaseLeaveFunc.Set(this, &CPythonNetworkStream::__LeaveOfflinePhase);
SetGameOffline();
m_dwSelectedCharacterIndex = 0;
__DirectEnterMode_Initialize();
__BettingGuildWar_Initialize();
}
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;
}
void CPythonPlayerEventHandler::OnWaiting(const SState& c_rkState)
{
DWORD dwCurTime=ELTimer_GetMSec();
if (m_dwNextWaitingNotifyTime>dwCurTime)
return;
m_dwNextWaitingNotifyTime=dwCurTime+100;
const TPixelPosition& c_rkPPosCurWaiting=c_rkState.kPPosSelf;
float dx=m_kPPosPrevWaiting.x-c_rkPPosCurWaiting.x;
float dy=m_kPPosPrevWaiting.y-c_rkPPosCurWaiting.y;
float len=sqrt(dx*dx+dy*dy);
if (len<1.0f)
return;
m_kPPosPrevWaiting=c_rkPPosCurWaiting;
CPythonNetworkStream& rkNetStream=CPythonNetworkStream::Instance();
rkNetStream.SendCharacterStatePacket(c_rkState.kPPosSelf, c_rkState.fAdvRotSelf, CInstanceBase::FUNC_WAIT, 0);
//Trace("waiting\n");
}
void CSoundData::Release()
{
assert(m_iRefCount != 0);
--m_iRefCount;
m_dwAccessTime = ELTimer_GetMSec();
}
void CPythonMiniMap::Update(float fCenterX, float fCenterY)
{
CPythonBackground& rkBG=CPythonBackground::Instance();
if (!rkBG.IsMapOutdoor())
return;
// 미니맵 그림 갱신
if (m_fCenterX != fCenterX || m_fCenterY != fCenterY )
SetCenterPosition(fCenterX, fCenterY);
// 캐릭터 리스트 갱신
m_OtherPCPositionVector.clear();
m_PartyPCPositionVector.clear();
m_NPCPositionVector.clear();
m_MonsterPositionVector.clear();
m_WarpPositionVector.clear();
float fooCellScale = 1.0f / ((float) CTerrainImpl::CELLSCALE);
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
CInstanceBase* pkInstMain=rkChrMgr.GetMainInstancePtr();
if (!pkInstMain)
return;
CPythonCharacterManager::CharacterIterator i;
for(i = rkChrMgr.CharacterInstanceBegin(); i!=rkChrMgr.CharacterInstanceEnd(); ++i)
{
CInstanceBase* pkInstEach=*i;
TPixelPosition kInstancePosition;
pkInstEach->NEW_GetPixelPosition(&kInstancePosition);
float fDistanceFromCenterX = (kInstancePosition.x - m_fCenterX) * fooCellScale * m_fScale;
float fDistanceFromCenterY = (kInstancePosition.y - m_fCenterY) * fooCellScale * m_fScale;
if (fabs(fDistanceFromCenterX) >= m_fMiniMapRadius || fabs(fDistanceFromCenterY) >= m_fMiniMapRadius)
continue;
float fDistanceFromCenter = sqrtf(fDistanceFromCenterX * fDistanceFromCenterX + fDistanceFromCenterY * fDistanceFromCenterY );
if ( fDistanceFromCenter >= m_fMiniMapRadius )
continue;
TMarkPosition aMarkPosition;
if (pkInstEach->IsPC() && !pkInstEach->IsInvisibility())
{
if (pkInstEach == CPythonCharacterManager::Instance().GetMainInstancePtr())
continue;
aMarkPosition.m_fX = ( m_fWidth - (float)m_WhiteMark.GetWidth() ) / 2.0f + fDistanceFromCenterX + m_fScreenX;
aMarkPosition.m_fY = ( m_fHeight - (float)m_WhiteMark.GetHeight() ) / 2.0f + fDistanceFromCenterY + m_fScreenY;
aMarkPosition.m_eNameColor=pkInstEach->GetNameColorIndex();
if (aMarkPosition.m_eNameColor==CInstanceBase::NAMECOLOR_PARTY)
m_PartyPCPositionVector.push_back(aMarkPosition);
else
m_OtherPCPositionVector.push_back(aMarkPosition);
}
else if (pkInstEach->IsNPC())
{
aMarkPosition.m_fX = ( m_fWidth - (float)m_WhiteMark.GetWidth() ) / 2.0f + fDistanceFromCenterX + m_fScreenX;
aMarkPosition.m_fY = ( m_fHeight - (float)m_WhiteMark.GetHeight() ) / 2.0f + fDistanceFromCenterY + m_fScreenY;
m_NPCPositionVector.push_back(aMarkPosition);
}
else if (pkInstEach->IsEnemy())
{
aMarkPosition.m_fX = ( m_fWidth - (float)m_WhiteMark.GetWidth() ) / 2.0f + fDistanceFromCenterX + m_fScreenX;
aMarkPosition.m_fY = ( m_fHeight - (float)m_WhiteMark.GetHeight() ) / 2.0f + fDistanceFromCenterY + m_fScreenY;
m_MonsterPositionVector.push_back(aMarkPosition);
}
else if (pkInstEach->IsWarp())
{
aMarkPosition.m_fX = ( m_fWidth - (float)m_WhiteMark.GetWidth() ) / 2.0f + fDistanceFromCenterX + m_fScreenX;
aMarkPosition.m_fY = ( m_fHeight - (float)m_WhiteMark.GetHeight() ) / 2.0f + fDistanceFromCenterY + m_fScreenY;
m_WarpPositionVector.push_back(aMarkPosition);
}
}
{
DWORD dwCurTime=ELTimer_GetMSec();
std::map<DWORD, SObserver>::iterator i;
for (i=m_kMap_dwVID_kObserver.begin(); i!=m_kMap_dwVID_kObserver.end(); ++i)
{
SObserver& rkObserver=i->second;
float fPos=float(dwCurTime-rkObserver.dwSrcTime)/float(rkObserver.dwDstTime-rkObserver.dwSrcTime);
if (fPos<0.0f) fPos=0.0f;
else if (fPos>1.0f) fPos=1.0f;
rkObserver.fCurX=(rkObserver.fDstX-rkObserver.fSrcX)*fPos+rkObserver.fSrcX;
rkObserver.fCurY=(rkObserver.fDstY-rkObserver.fSrcY)*fPos+rkObserver.fSrcY;
TPixelPosition kInstancePosition;
kInstancePosition.x=rkObserver.fCurX;
kInstancePosition.y=rkObserver.fCurY;
kInstancePosition.z=0.0f;
float fDistanceFromCenterX = (kInstancePosition.x - m_fCenterX) * fooCellScale * m_fScale;
float fDistanceFromCenterY = (kInstancePosition.y - m_fCenterY) * fooCellScale * m_fScale;
if (fabs(fDistanceFromCenterX) >= m_fMiniMapRadius || fabs(fDistanceFromCenterY) >= m_fMiniMapRadius)
continue;
float fDistanceFromCenter = sqrtf(fDistanceFromCenterX * fDistanceFromCenterX + fDistanceFromCenterY * fDistanceFromCenterY );
if ( fDistanceFromCenter >= m_fMiniMapRadius )
continue;
TMarkPosition aMarkPosition;
aMarkPosition.m_fX = ( m_fWidth - (float)m_WhiteMark.GetWidth() ) / 2.0f + fDistanceFromCenterX + m_fScreenX;
aMarkPosition.m_fY = ( m_fHeight - (float)m_WhiteMark.GetHeight() ) / 2.0f + fDistanceFromCenterY + m_fScreenY;
aMarkPosition.m_eNameColor=CInstanceBase::NAMECOLOR_PARTY;
m_PartyPCPositionVector.push_back(aMarkPosition);
}
}
{
TAtlasMarkInfoVector::iterator itor = m_AtlasWayPointInfoVector.begin();
for (; itor != m_AtlasWayPointInfoVector.end(); ++itor)
{
TAtlasMarkInfo & rAtlasMarkInfo = *itor;
if (TYPE_TARGET != rAtlasMarkInfo.m_byType)
continue;
if (0 != rAtlasMarkInfo.m_dwChrVID)
{
CInstanceBase * pInstance = CPythonCharacterManager::Instance().GetInstancePtr(rAtlasMarkInfo.m_dwChrVID);
if (pInstance)
{
TPixelPosition kPixelPosition;
pInstance->NEW_GetPixelPosition(&kPixelPosition);
__UpdateWayPoint(&rAtlasMarkInfo, kPixelPosition.x, kPixelPosition.y);
}
}
const float c_fMiniMapWindowRadius = 55.0f;
float fDistanceFromCenterX = (rAtlasMarkInfo.m_fX - m_fCenterX) * fooCellScale * m_fScale;
float fDistanceFromCenterY = (rAtlasMarkInfo.m_fY - m_fCenterY) * fooCellScale * m_fScale;
float fDistanceFromCenter = sqrtf(fDistanceFromCenterX * fDistanceFromCenterX + fDistanceFromCenterY * fDistanceFromCenterY );
if (fDistanceFromCenter >= c_fMiniMapWindowRadius)
{
float fRadianX = acosf(fDistanceFromCenterX / fDistanceFromCenter);
float fRadianY = asinf(fDistanceFromCenterY / fDistanceFromCenter);
fDistanceFromCenterX = 55.0f * cosf(fRadianX);
fDistanceFromCenterY = 55.0f * sinf(fRadianY);
rAtlasMarkInfo.m_fMiniMapX = ( m_fWidth - (float)m_WhiteMark.GetWidth() ) / 2.0f + fDistanceFromCenterX + m_fScreenX + 2.0f;
rAtlasMarkInfo.m_fMiniMapY = ( m_fHeight - (float)m_WhiteMark.GetHeight() ) / 2.0f + fDistanceFromCenterY + m_fScreenY + 2.0f;
}
else
{
rAtlasMarkInfo.m_fMiniMapX = ( m_fWidth - (float)m_WhiteMark.GetWidth() ) / 2.0f + fDistanceFromCenterX + m_fScreenX;
rAtlasMarkInfo.m_fMiniMapY = ( m_fHeight - (float)m_WhiteMark.GetHeight() ) / 2.0f + fDistanceFromCenterY + m_fScreenY;
}
}
}
}
void CPythonMiniMap::RenderAtlas(float fScreenX, float fScreenY)
{
if (!m_bShowAtlas)
return;
if (m_fAtlasScreenX != fScreenX || m_fAtlasScreenY != fScreenY)
{
m_matWorldAtlas._41 = fScreenX;
m_matWorldAtlas._42 = fScreenY;
m_fAtlasScreenX = fScreenX;
m_fAtlasScreenY = fScreenY;
}
STATEMANAGER.SetTransform(D3DTS_WORLD, &m_matWorldAtlas);
STATEMANAGER.SaveTextureStageState(0, D3DTSS_MINFILTER, D3DTEXF_POINT);
STATEMANAGER.SaveTextureStageState(0, D3DTSS_MAGFILTER, D3DTEXF_POINT);
m_AtlasImageInstance.Render();
STATEMANAGER.SaveRenderState(D3DRS_TEXTUREFACTOR, 0xFFFFFFFF);
STATEMANAGER.SaveTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TFACTOR);
STATEMANAGER.SaveTextureStageState(0, D3DTSS_COLORARG2, D3DTA_TEXTURE);
STATEMANAGER.SaveTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
STATEMANAGER.SetRenderState(D3DRS_TEXTUREFACTOR, CInstanceBase::GetIndexedNameColor(CInstanceBase::NAMECOLOR_NPC));
m_AtlasMarkInfoVectorIterator = m_AtlasNPCInfoVector.begin();
while (m_AtlasMarkInfoVectorIterator != m_AtlasNPCInfoVector.end())
{
TAtlasMarkInfo & rAtlasMarkInfo = *m_AtlasMarkInfoVectorIterator;
m_WhiteMark.SetPosition(rAtlasMarkInfo.m_fScreenX, rAtlasMarkInfo.m_fScreenY);
m_WhiteMark.Render();
++m_AtlasMarkInfoVectorIterator;
}
STATEMANAGER.SetRenderState(D3DRS_TEXTUREFACTOR, CInstanceBase::GetIndexedNameColor(CInstanceBase::NAMECOLOR_WARP));
m_AtlasMarkInfoVectorIterator = m_AtlasWarpInfoVector.begin();
while (m_AtlasMarkInfoVectorIterator != m_AtlasWarpInfoVector.end())
{
TAtlasMarkInfo & rAtlasMarkInfo = *m_AtlasMarkInfoVectorIterator;
m_WhiteMark.SetPosition(rAtlasMarkInfo.m_fScreenX, rAtlasMarkInfo.m_fScreenY);
m_WhiteMark.Render();
++m_AtlasMarkInfoVectorIterator;
}
STATEMANAGER.SetTextureStageState(0, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
STATEMANAGER.SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
STATEMANAGER.SetRenderState(D3DRS_TEXTUREFACTOR, CInstanceBase::GetIndexedNameColor(CInstanceBase::NAMECOLOR_WAYPOINT));
m_AtlasMarkInfoVectorIterator = m_AtlasWayPointInfoVector.begin();
for (; m_AtlasMarkInfoVectorIterator != m_AtlasWayPointInfoVector.end(); ++m_AtlasMarkInfoVectorIterator)
{
TAtlasMarkInfo & rAtlasMarkInfo = *m_AtlasMarkInfoVectorIterator;
if (rAtlasMarkInfo.m_fScreenX <= 0.0f)
continue;
if (rAtlasMarkInfo.m_fScreenY <= 0.0f)
continue;
if (TYPE_TARGET == rAtlasMarkInfo.m_byType)
{
__RenderMiniWayPointMark(rAtlasMarkInfo.m_fScreenX, rAtlasMarkInfo.m_fScreenY);
}
else
{
__RenderWayPointMark(rAtlasMarkInfo.m_fScreenX, rAtlasMarkInfo.m_fScreenY);
}
}
STATEMANAGER.RestoreRenderState(D3DRS_TEXTUREFACTOR);
STATEMANAGER.RestoreTextureStageState(0, D3DTSS_COLORARG1);
STATEMANAGER.RestoreTextureStageState(0, D3DTSS_COLORARG2);
STATEMANAGER.RestoreTextureStageState(0, D3DTSS_COLOROP);
if ((ELTimer_GetMSec() / 500) % 2)
m_AtlasPlayerMark.Render();
STATEMANAGER.RestoreTextureStageState(0, D3DTSS_MINFILTER);
STATEMANAGER.RestoreTextureStageState(0, D3DTSS_MAGFILTER);
STATEMANAGER.SetTransform(D3DTS_WORLD, &m_matIdentity);
{
TGuildAreaInfoVectorIterator itor = m_GuildAreaInfoVector.begin();
for (; itor != m_GuildAreaInfoVector.end(); ++itor)
{
TGuildAreaInfo & rInfo = *itor;
m_GuildAreaFlagImageInstance.SetPosition(fScreenX+(rInfo.fsxRender+rInfo.fexRender)/2.0f - m_GuildAreaFlagImageInstance.GetWidth()/2,
fScreenY+(rInfo.fsyRender+rInfo.feyRender)/2.0f - m_GuildAreaFlagImageInstance.GetHeight()/2);
m_GuildAreaFlagImageInstance.Render();
// CScreen::RenderBar2d(fScreenX+rInfo.fsxRender,
// fScreenY+rInfo.fsyRender,
// fScreenX+rInfo.fexRender,
// fScreenY+rInfo.feyRender);
}
}
}
void CActorInstance::__Shake(DWORD dwDuration)
{
DWORD dwCurTime=ELTimer_GetMSec();
m_dwShakeTime=dwCurTime+dwDuration;
}
