2017 lines
51 KiB
C++
2017 lines
51 KiB
C++
#include "stdafx.h"
|
|
#include <network/XNetworkUtil.h>
|
|
#include "SBotManager.h"
|
|
#include "SGame.h"
|
|
#include "SGameVM.h"
|
|
#include "SGameInterface.h"
|
|
|
|
#include <WindowsX.h>
|
|
|
|
#include "KDeviceManager.h"
|
|
#include "KUIWnd.h"
|
|
|
|
#include "SGameViewPort.h"
|
|
#include "SShadowViewPort.h"
|
|
#include "SWaterViewPort.h"
|
|
|
|
#include "KRenderDeviceDX.h"
|
|
#include <kfile/KFileManager.h>
|
|
#include <kfile/KFiler.h>
|
|
#include "KUITextureManager.h"
|
|
#include "KTextCacheManager.h"
|
|
|
|
#include "SGameSound.h"
|
|
#include "SCobManager.h"
|
|
#include "SSpeedTreeManager.h"
|
|
#include "KPrimitiveSpriteMng.h"
|
|
|
|
#include "resource.h"
|
|
|
|
#include <toolkit/XEnv.h>
|
|
#include "KUIWndManager.h"
|
|
#include "SUITopConsoleWnd.h"
|
|
|
|
#include "SLog.h"
|
|
//#include "Util.h"
|
|
#include <toolkit/XStringUtil.h>
|
|
|
|
//Game Data
|
|
#include "SBasicStat.h"
|
|
#include "SStringDB.h"
|
|
#include "SSkillDB.h"
|
|
#include "SItemDB.h"
|
|
#include "SBanWordDB.h"
|
|
#include "SCombineDB.h"
|
|
#include "SDecomposeDB.h"
|
|
#include "SGameOption.h"
|
|
#include "SItemEffectResourceDB.h"
|
|
#include "SDefaultTextureResourceDB.h"
|
|
#include "SDefaultTextureIconResourceDB.h"
|
|
#include "SMonsterSpeciesDB.h"
|
|
#include "SMonsterAffiliationDB.h"
|
|
#include "SMonsterAffiliationDetailDB.h"
|
|
#include "SMixCategoryDB.h"
|
|
|
|
//Speed Tree
|
|
#include "SSpeedTreeConfig.h"
|
|
#include "KSeqSpeedTree.h"
|
|
#include "KSeqModel.h"
|
|
|
|
// SpeedGrass
|
|
#include "KSeqSpeedGrass.h"
|
|
#include "TerrainSpeedGrass.h"
|
|
|
|
#include <kfile/SFileRoot.h>
|
|
#include "SGameCursor.h"
|
|
|
|
#include "SGameManager.h"
|
|
|
|
#include <time.h>
|
|
|
|
#include "KCommandBuilder.h"
|
|
|
|
#include "SRenderFlag.h"
|
|
|
|
#include "SUIDefine.h"
|
|
|
|
#include "SDebug_Util.h"
|
|
|
|
#include "SGameMilesSoundMgr.h"
|
|
#include "SGameCircleShadowFX.h"
|
|
|
|
#ifdef _COUNTRY_ME_
|
|
#include "Localization/MiddleEast.h"
|
|
#include "Localization/MiddleEast/KPangoCairo.h" // TEST bintitle. 2010.07.20
|
|
#endif
|
|
|
|
/// 2010.11.10 - prodongi
|
|
#include "SGameLobbyDefine.h"
|
|
|
|
#ifdef CLOUD_LUA
|
|
#include "SGameCloud.h"
|
|
#endif
|
|
|
|
|
|
//JPG 라이브러리
|
|
//#include <il/il.h>
|
|
//#include <il/ilu.h>
|
|
|
|
extern HWND g_hWnd;
|
|
extern int g_DP_Count[3];
|
|
extern int g_UsedMeshEXPoolCount[3];
|
|
extern int g_Poly_Count;
|
|
extern int g_TexMem;
|
|
extern bool g_bActiveRender;
|
|
extern void MsgSplit( const char* szMsg, std::vector<std::string>& vecText, const wchar_t* lpDelimiter, bool bProcSpecialCharacter=false );
|
|
extern int GetCodePageFromLang( LANGID langid );
|
|
|
|
bool g_bCursorRender;
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
SBot::SBot( const char * pName, K3DRenderDeviceDX *pRenderDevice, SSoundManager * pSoundMng,
|
|
KTextureManager * pTextureMng, KNX3Manager * pNX3Mng, KViewportObject ** ppViewportList, int nViewportCount,
|
|
SGameMilesSoundMgr* pMSoundMgr )
|
|
{
|
|
m_pGameVM = new SGameVM;
|
|
m_pGameInterface = new SGameInterface;
|
|
m_pGameMng = new SGameManager( m_pGameVM, m_pGameInterface, pRenderDevice, pSoundMng, pTextureMng, pNX3Mng, ppViewportList, nViewportCount, pMSoundMgr );
|
|
|
|
m_pGameVM->SetGameManager( m_pGameMng );
|
|
m_pGameInterface->Initialize( m_pGameMng );
|
|
|
|
memset( szName, 0, sizeof(szName) );
|
|
strcpy( szName, pName );
|
|
|
|
m_pGameMng->Init();
|
|
m_pGameMng->GameSet();
|
|
|
|
m_nStep = BOT_SELECT;
|
|
|
|
m_bActiveSkip = FALSE;
|
|
m_bActiveRender = TRUE;
|
|
g_bActiveRender = true;
|
|
}
|
|
|
|
SBot::~SBot()
|
|
{
|
|
SAFE_DELETE( m_pGameMng );
|
|
SAFE_DELETE( m_pGameInterface );
|
|
SAFE_DELETE( m_pGameVM );
|
|
}
|
|
|
|
void SBot::onDeviceLost()
|
|
{
|
|
if( m_pGameInterface ) m_pGameInterface->onDeviceLost();
|
|
}
|
|
|
|
void SBot::ProcConsole( SGameMessage * pGameMsg )
|
|
{
|
|
//치트 처리
|
|
m_pGameMng->ProcConsole( pGameMsg );
|
|
}
|
|
|
|
LRESULT CALLBACK SBot::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
//포커스 잃어 버리면, Render 안되게...
|
|
switch( message )
|
|
{
|
|
case WM_ACTIVATE :
|
|
if( g_hWnd == hWnd && wParam != WA_INACTIVE )
|
|
{
|
|
g_bCursorRender = true;
|
|
}
|
|
else
|
|
{
|
|
g_bCursorRender = false;
|
|
}
|
|
break;
|
|
}
|
|
|
|
_CID( WINDOWMSG );
|
|
if( m_pGameInterface->PerformV( id_WINDOWMSG, message, (unsigned long)wParam, (unsigned long)lParam ) )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
return m_pGameMng->WndProc(hWnd, message, wParam, lParam);
|
|
}
|
|
|
|
void *SBot::Perform( KID id, KArg& msg )
|
|
{
|
|
return (void*)0;
|
|
}
|
|
|
|
//Build System
|
|
//테스트 시작
|
|
void SBot::DoTest()
|
|
{
|
|
|
|
}
|
|
|
|
//보고서 작성
|
|
void SBot::DoReport()
|
|
{
|
|
|
|
}
|
|
|
|
bool SBot::IsLoadGameActivated()
|
|
{
|
|
return m_pGameMng->IsLoadGameActivated();
|
|
}
|
|
|
|
void SBot::onHotkey( GameHotKeystrcut & HotKey )
|
|
{
|
|
if( m_pGameMng ) m_pGameMng->onHotkey( HotKey );
|
|
}
|
|
|
|
void SBot::Process( unsigned long uProcessBitVector )
|
|
{
|
|
if( GetKeyState( VK_NUMLOCK ) > 0 )
|
|
m_bActiveSkip = TRUE;
|
|
else
|
|
m_bActiveSkip = FALSE;
|
|
|
|
m_pGameMng->Process( uProcessBitVector );
|
|
}
|
|
|
|
SGame * SBot::GetActiveGame()
|
|
{
|
|
return m_pGameMng->GetActiveGame();
|
|
}
|
|
|
|
void SBot::Render( unsigned long uRenderBitVector )
|
|
{
|
|
if( m_bActiveSkip )
|
|
{
|
|
m_pGameMng->Render( uRenderBitVector );
|
|
}
|
|
else
|
|
{
|
|
if( m_bActiveRender == TRUE ) m_pGameMng->Render( uRenderBitVector );
|
|
}
|
|
}
|
|
|
|
void SBot::AfterRender( unsigned long uRenderBitVector )
|
|
{
|
|
m_pGameMng->AfterRender( uRenderBitVector );
|
|
}
|
|
|
|
void SBot::ProcSecurityMsg( GameSecurityMsg* pSecurityMsg )
|
|
{
|
|
m_pGameMng->ProcSecurityMsg( pSecurityMsg );
|
|
}
|
|
|
|
void SBot::InitializeScriptForGameUI()
|
|
{
|
|
if( m_pGameInterface )
|
|
m_pGameInterface->InitializeAddonScript();
|
|
}
|
|
|
|
bool SBot::GameGuardSendToServer( const GG_AUTH_DATA* pAuthdata )
|
|
{
|
|
return m_pGameMng->GameGuardSendToServer( pAuthdata );
|
|
}
|
|
|
|
bool SBot::GameGuardSendToServer( const PCSAuth3Data pAuthdata )
|
|
{
|
|
return m_pGameMng->GameGuardSendToServer( pAuthdata );
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// static SGameVM* m_pGameVM;
|
|
SBotManager* SBotManager::m_pBotThis = NULL;
|
|
|
|
SBotManager::SBotManager( HWND hWnd, HINSTANCE hInstance )
|
|
{
|
|
m_nSelectBot = -1;
|
|
|
|
for(int i = 0; i < 10; ++i)
|
|
m_pViewportList[i] = NULL;
|
|
m_nViewportCount = 0;
|
|
|
|
m_pUIWndManager = NULL;
|
|
m_pConsoleWnd = NULL;
|
|
m_pSystemInfoWnd = NULL;
|
|
m_bActConsole = false;
|
|
m_bActSystemInfo = false;
|
|
|
|
m_ulProcessBitVector = Game_ProcessAll;
|
|
m_ulRenderBitVector = Bot_RenderAll;
|
|
|
|
m_bUseHqWater = false;
|
|
|
|
m_pCursorMng = NULL;
|
|
m_pSoundMng = NULL;
|
|
|
|
m_pMSoundMgr = NULL;
|
|
|
|
m_bActiveRender = TRUE;
|
|
g_bActiveRender = true;
|
|
|
|
m_bCheckRender = true;
|
|
|
|
m_dwCheckTime = 0;
|
|
|
|
Init( hWnd, hInstance );
|
|
}
|
|
|
|
SBotManager::~SBotManager()
|
|
{
|
|
Destroy();
|
|
}
|
|
|
|
void SBotManager::BotTest()
|
|
{
|
|
char szName[32];
|
|
memset( szName, 0, sizeof(szName) );
|
|
//for( int i=0; 1>i; i++ )
|
|
//{
|
|
// XStringUtil::Format( szName, "bot%02d", i+1 );
|
|
// Bot_Add( szName );
|
|
//}
|
|
Bot_Add( "bot03" );
|
|
|
|
m_nSelectBot = 0;
|
|
}
|
|
|
|
void SBotManager::SetShowWater( bool bShowWater )
|
|
{
|
|
if( m_nViewportCount < 1 ) return;
|
|
|
|
m_pViewportList[0]->SetUseWater( bShowWater );
|
|
|
|
if( m_nViewportCount != 3 ) return;
|
|
m_pViewportList[2]->SetUseViewPort( bShowWater );
|
|
}
|
|
|
|
void SBotManager::Init( HWND hWnd, HINSTANCE hInstance )
|
|
{
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//Speed Tree
|
|
float afLight1[] =
|
|
{
|
|
//c_afLightPosition[0], c_afLightPosition[1], c_afLightPosition[2], // pos
|
|
5000000*0.33f, 5000000*0.66f, 5000000*0.66f,
|
|
c_afLightDiffuse[0], c_afLightDiffuse[1], c_afLightDiffuse[2], // diffuse
|
|
c_afLightAmbient[0], c_afLightAmbient[1], c_afLightAmbient[2], // ambient
|
|
c_afLightSpecular[0], c_afLightSpecular[1], c_afLightSpecular[2], // specular
|
|
0.f, // directional flag
|
|
0.0f, 0.0f, 0.0f // attenuation (constant, linear, quadratic)
|
|
};
|
|
|
|
m_fLastElapsedTime = 0.0f;
|
|
m_fElapsedTime = 0.0f;
|
|
m_fAccumTime = 0.0f;
|
|
m_fOldStrength = 0.2f; //나무 흔들림 설정
|
|
m_fWindStrength = 0.2f; //나무 흔들림 설정
|
|
|
|
// set light attributes and enable static light 0
|
|
CSpeedTreeRT::SetLightAttributes(0, afLight1);
|
|
CSpeedTreeRT::SetLightState(0, true);
|
|
CSpeedTreeRT::SetNumWindMatrices(c_nNumWindMatrices);
|
|
|
|
KSeqSpeedGrass::SetFadeDist( 400.0f );
|
|
KSeqSpeedGrass::SetFadeLength( 200.0f );
|
|
|
|
// Render Device 초기화
|
|
K3DRenderDeviceDX::CS cs;
|
|
|
|
if( ENV().IsExist( "16bit" ) )
|
|
cs.nBPP = 16;
|
|
else
|
|
cs.nBPP = 32;
|
|
|
|
//if(ENV().IsExist("perf_hud") )
|
|
// cs.bNVidiaPerfHud = true;
|
|
|
|
m_nScreenCount = 0;
|
|
//실행 옵션 관련
|
|
std::string strRes;
|
|
std::string strRenderMode; //하드웨어,소프트웨어
|
|
|
|
if( ENV().IsExist( "render" ) )
|
|
{
|
|
strRenderMode = ENV().GetString( "render" );
|
|
|
|
if( strstr( strRenderMode.c_str(), "hw_mode" ) )
|
|
cs.dwOption = 1;
|
|
else
|
|
cs.dwOption = 0;
|
|
}
|
|
else
|
|
{
|
|
//없으면, 기본으로 하드웨어 모드
|
|
strRenderMode = "hw_mode";
|
|
cs.dwOption = 1;
|
|
}
|
|
|
|
//기본 경로
|
|
if( ENV().IsExist( "res" ) )
|
|
{
|
|
strRes = ENV().GetString( "res" );
|
|
XStringUtil::Replace( strRes, "\\", "/" );
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
char szDir[_MAX_PATH]; memset( szDir, 0, sizeof(szDir) );
|
|
GetCurrentDirectory( _MAX_PATH, szDir );
|
|
strRes = szDir;
|
|
strRes += "\\";
|
|
}
|
|
|
|
//#define _WEB_DISP_MODE
|
|
|
|
#ifdef _WEB_DISP_MODE
|
|
cs.bFullScreen = false;
|
|
#else
|
|
//설정이 안되어 있으면
|
|
if( GetGameOption().GetWinMode() == -1 )
|
|
{
|
|
cs.bFullScreen = ENV().IsExist( "full" );
|
|
}
|
|
else
|
|
{
|
|
if( ENV().IsExist( "win" ) )
|
|
{
|
|
cs.bFullScreen = false;
|
|
}
|
|
else
|
|
{
|
|
//게임 옵션
|
|
cs.bFullScreen = GetGameOption().GetWinMode() == 0 ? true : false;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
KUIWnd::SetEnterChatMode ( GetGameOption().IsEnterChat() );
|
|
KUIWndManager::SetEnterChatMode( GetGameOption().IsEnterChat() );
|
|
|
|
cs.hWnd = hWnd;
|
|
cs.hFocusWnd = hWnd;
|
|
|
|
//지원 해상도 알아 내기///////////////////////////////////////////////////
|
|
K3DRenderDeviceDX * pDevice = new K3DRenderDeviceDX;
|
|
pDevice->SetSupportDispMode();
|
|
|
|
const D3DDISPLAYMODE & cur_disp_mode = pDevice->GetCurrentDispMode();
|
|
GetGameOption().SetCurrentRefreshRate( cur_disp_mode.RefreshRate );
|
|
|
|
const std::vector< D3DDISPLAYMODE > & cur_disp_list = pDevice->GetDispMode();
|
|
|
|
for( unsigned int i(0); cur_disp_list.size()>i; i++ )
|
|
{
|
|
UINT width = cur_disp_list[i].Width;
|
|
UINT height = cur_disp_list[i].Height;
|
|
UINT refreshrate = cur_disp_list[i].RefreshRate;
|
|
|
|
GetGameOption().AddDispMode( width, height, refreshrate );
|
|
}
|
|
|
|
SAFE_DELETE( pDevice );
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
KSize sizResolution;
|
|
int nWidth = GetGameOption().GetResolution_Width();
|
|
int nHeight = GetGameOption().GetResolution_Height();
|
|
sizResolution = KSize(nWidth, nHeight);
|
|
|
|
KUIWndManager::SetResolution( sizResolution );
|
|
|
|
RECT rect;
|
|
GetClientRect(hWnd, &rect);
|
|
|
|
::ShowCursor( FALSE );
|
|
|
|
int cx = GetSystemMetrics(SM_CXSCREEN);
|
|
int cy = GetSystemMetrics(SM_CYSCREEN);
|
|
if ( cs.bFullScreen )
|
|
{
|
|
cx = 1024, cy = 768;
|
|
// cx = RES_1280, cy = RES_1024;
|
|
}
|
|
float va = (float)cy / cx;
|
|
if ( va < .5f )
|
|
{
|
|
cx /= 2;
|
|
}
|
|
|
|
//cs.sizeScreen.width = cx;
|
|
//cs.sizeScreen.height = cy;
|
|
cs.sizeScreen.width = sizResolution.cx;
|
|
cs.sizeScreen.height = sizResolution.cy;
|
|
|
|
KDeviceManagerDX::Initialize( hWnd, hInstance, cs );
|
|
|
|
m_pGraphics = (K3DRenderDeviceDX *)KDeviceManagerDX::GetDeviceManager()->GetRenderDevice();
|
|
|
|
KSeqSpeedTree::SetRenderingDevice( m_pGraphics );
|
|
KSeqSpeedGrass::SetRenderDevice( m_pGraphics );
|
|
KUITextureManager::SetRenderDevice( m_pGraphics );
|
|
#ifdef _KUI_INVALIDATION
|
|
// { [sonador]
|
|
KUICachedTextureManager::SetRenderDevice( m_pGraphics );
|
|
// }
|
|
#endif
|
|
|
|
// Sound Device 초기화
|
|
|
|
//리소스 관련...
|
|
|
|
// Texture Manager 설정
|
|
m_pTextureManager = KTextureManager::GetManager();
|
|
m_pTextureManager->SetTextureSearchPolicy( KTextureManager::ORG_THEN_DDS ); // 게임에서는 무조건 확장자를 DDS로 바꿔 그것만 읽는다. - Tyburn
|
|
|
|
SGameOption& game_option = GetGameOption();
|
|
|
|
if( ENV().IsExist( "minimum_system" ) )
|
|
{
|
|
KNX3Manager::GetManager()->SetSystemRequirements( KNX3Manager::MINIMUM_SYSTEM );
|
|
game_option.SettingForMinimumSystem();
|
|
}
|
|
else if( ENV().IsExist( "maximum_system" ) )
|
|
{
|
|
KNX3Manager::GetManager()->SetSystemRequirements( KNX3Manager::MAXIMUM_SYSTEM );
|
|
game_option.SettingForMaximumSystem();
|
|
}
|
|
else
|
|
{
|
|
if( game_option.GetPresetOption() == 1 )
|
|
KNX3Manager::GetManager()->SetSystemRequirements( KNX3Manager::MINIMUM_SYSTEM_BY_USER_SELECT );
|
|
else
|
|
KNX3Manager::GetManager()->SetSystemRequirements( KNX3Manager::MIXED_SYSTEM );
|
|
}
|
|
|
|
//텍스쳐 품질 0 저품질, 1 기본
|
|
NX3LoadPack::SetTextureLevel( !game_option.GetResourceQuality() );
|
|
|
|
// NX3 Manager 관련
|
|
m_pNX3Mgr = KNX3Manager::GetManager();
|
|
|
|
// NX3 File Template 등록
|
|
{
|
|
KStream * pStream = KFileManager::Instance().CreateStreamFromResource( "NX3.tml" );
|
|
KFiler::RegisterTemplates( *pStream );
|
|
pStream->Seek( 0, KStream::seekSet );
|
|
KNX3Manager::GetManager()->GetMetaData().importTML( *pStream );
|
|
KFileManager::Instance().DeleteStream( pStream );
|
|
}
|
|
|
|
// NOB File Template 등록
|
|
{
|
|
KStream * pStream = KFileManager::Instance().CreateStreamFromResource( "NObj.tml" );
|
|
KFiler::RegisterTemplates( *pStream );
|
|
pStream->Seek( 0, KStream::seekSet );
|
|
COBManager::GetManager()->GetMetaData().importTML( *pStream );
|
|
KFileManager::Instance().DeleteStream( pStream );
|
|
}
|
|
|
|
//KSeqModel * pTest = new KSeqModel;
|
|
//pTest->Initialize( GetSafeTickCount() );
|
|
//pTest->AddAnimation( "card_start", "rcfx_login_asuracard01_start.nx3" );
|
|
|
|
//SAFE_DELETE( pTest );
|
|
|
|
//KNX3Manager::GetManager()->PrintList( "릴리즈_테스트.txt" );
|
|
|
|
m_pMSoundMgr = new SGameMilesSoundMgr;
|
|
if( m_pMSoundMgr->Initialize( hWnd ) )
|
|
{
|
|
m_pMSoundMgr->SetSfxVolume( (game_option.GetSFX_Volume()+1)*10 );
|
|
m_pMSoundMgr->SetBgmVolume( (game_option.GetBGM_Volume()+1)*10 );
|
|
m_pMSoundMgr->SetEnvVolume( (game_option.GetENVS_Volume()+1)*10 );
|
|
m_pMSoundMgr->SetMasterVolume( (game_option.GetMASTER_Volume()+1)*10 );
|
|
}
|
|
|
|
KViewportStruct vp;
|
|
// vp.Width = RES_1280;//1024;
|
|
// vp.Height = RES_1024;//768;
|
|
vp.Width = sizResolution.cx;
|
|
vp.Height = sizResolution.cy;
|
|
vp.X = vp.Y = 0;
|
|
vp.MinZ = 0;
|
|
vp.MaxZ = 1.0f;
|
|
SGameViewPort * pGameViewPort = new SGameViewPort();
|
|
pGameViewPort->Initilaize( m_pGraphics, vp, 5.f, 6000.f );
|
|
pGameViewPort->SetFillColor( KColor( 255, 255, 255, 0 ) );
|
|
// pGameViewPort->SetFillColor( KColor( 204, 222, 248, 255 ) );
|
|
pGameViewPort->SetSceneAmbient( KColor(0,0,0,255) );
|
|
|
|
//
|
|
{
|
|
//pGameViewPort->SetUseHDR( true );
|
|
pGameViewPort->InitHdr();
|
|
}
|
|
|
|
m_pViewportList[0] = pGameViewPort;
|
|
|
|
m_nViewportCount = 1;
|
|
|
|
|
|
//텍스쳐 스테이지 4개보다 작으면, 스페큘러 안됨
|
|
const D3DCAPS9 & rCaps = m_pGraphics->GetCaps();
|
|
if( rCaps.MaxSimultaneousTextures >= 4 )
|
|
{
|
|
//Lobby 가 끝나면 자동으로 불러짐.
|
|
InitViewportEx();
|
|
|
|
if( rCaps.PixelShaderVersion >= D3DPS_VERSION( 2, 0 ) )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
((SViewPort*) m_pViewportList[0])->SetRenderBumpMapMode(false); // 나중에 옵션으로 빼서 정리하자 by blackfish
|
|
}
|
|
}
|
|
else
|
|
{ //저 사양 그래픽 임.
|
|
m_pViewportList[0]->SetUseSpecular( false ); //Game
|
|
((SViewPort*) m_pViewportList[0])->SetRenderBumpMapMode(false); // 나중에 옵션으로 빼서 정리하자 by blackfish
|
|
}
|
|
|
|
//게임 컨텐츠 DB 미리 Load
|
|
GetStringDB();
|
|
GetItemReferenceDB();
|
|
GetItemDB();
|
|
GetDefaultItemDB();
|
|
GetCombineDB();
|
|
GetSkinColorTable();
|
|
GetItemEffectResourceDB();
|
|
GetDefaultTextureResourceDB();
|
|
GetDefaultTextureIconResourceDB();
|
|
GetMixCategoryDB();
|
|
GetDecomposeDB();
|
|
GetMonsterSpeciesDB();
|
|
GetMonsterAffiliationDB();
|
|
GetMonsterAffiliationDetailDB();
|
|
GetSummonRandomSkillDB();
|
|
|
|
GetGameOption().InitChattinSet();
|
|
|
|
/*// 국가별 정보파일 sfreer 2009.07.07
|
|
if(GetLocaleOption().LoadOptionFile("localeinfo.ini") == false)
|
|
{
|
|
MessageBox(NULL, "'localeinfo' File Not Found","error", MB_OK);
|
|
}*/
|
|
|
|
if( GetLocaleOption().GetValueInt("CODEPAGE", -1) >=0 )
|
|
{
|
|
KTextRender::SetDefaultCodePage( GetLocaleOption().GetValueInt("CODEPAGE", -1) );
|
|
#ifdef _COUNTRY_ME_
|
|
g_pGameOperationManager->SetDefaultCodePage( GetLocaleOption().GetValueInt("CODEPAGE", -1) );
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
//코드페이지가 설정되어 있지 않을경우 윈도우 시스템 코드페이지를
|
|
//KTextRender의 기본 코드페이지로 설정 한다.
|
|
//2009-10-05 : hunee
|
|
LANGID langId = GetSystemDefaultLangID();
|
|
int codePage = GetCodePageFromLang(langId);
|
|
|
|
KTextRender::SetDefaultCodePage(codePage);
|
|
}
|
|
|
|
|
|
// GetBanWordDB();
|
|
// GetFieldTypeMaterialDB();
|
|
|
|
GetAbuseDB();
|
|
// GetAnimationDB();
|
|
|
|
#ifdef CLOUD_LUA
|
|
GetCloudLayerSetDB();
|
|
GetCloudLayerDB();
|
|
GetCloudTypeInfoDB();
|
|
GetCloudPathDB();
|
|
GetCloudMoveDirDB();
|
|
GetCloudLayerGapDB();
|
|
GetCloudHeightRadomGapDB();
|
|
GetCloudDistributionDB();
|
|
GetCloudTxrGroupDB();
|
|
GetCloudSizeDB();
|
|
GetCloudThicknessGapDB();
|
|
GetCloudThicknessDB();
|
|
GetCloudKindDB();
|
|
#endif
|
|
|
|
|
|
// GetLog().OutputFile(); // 로그가 모두 완료 되면, 다시 넣자.
|
|
|
|
//Network Init
|
|
if( !XNetworkUtil::InitNetwork() ) return;
|
|
|
|
// UI관련 Init
|
|
#ifdef _COUNTRY_ME_
|
|
// UI관련 Init
|
|
KTextRender::InitTextRender( m_pGraphics, 1256, ENV().GetString( "default_font", "Tahoma" ).c_str() );
|
|
//KTextRender::InitTextRender( m_pGraphics, 1256, "Tahoma" );
|
|
KTextLayout::InitLayoutEngine(); // TEST bintitle. 2010.07.20 밑줄이 원본.
|
|
KTextLayout2::InitLayoutEngine( m_pGraphics );
|
|
#else
|
|
KTextRender::InitTextRender( m_pGraphics );
|
|
#endif
|
|
|
|
// KTextRender::AddFreeTypeFont( KTextRender::KDEFAULT_FONT_NAME, "font.ttf" );
|
|
KTextRender::AddFont( KTextRender::KDEFAULT_FONT_NAME, KTextRender::KDEFAULT_FONT_SIZE );
|
|
KTextRender::AddFont( S(6307)/*"돋움"*/, KTextRender::KDEFAULT_FONT_SIZE );
|
|
KUIWndManager::SetHandle( hWnd, hInstance );
|
|
|
|
//콘솔용 윈도우 Manager~
|
|
m_pUIWndManager = new KUIWndManager;
|
|
CreateConsoleWnd();
|
|
|
|
m_pCursorMng = new SGameCursorMng( m_pGraphics, m_pTextureManager );
|
|
|
|
//m_nExit = 1;
|
|
|
|
// 옵션 초기화
|
|
((SGameViewPort *)m_pViewportList[0])->SetBloomEffect( GetGameOption().GetGlowQuality() );
|
|
|
|
//텍스쳐 밉 바이어스
|
|
if( ENV().IsExist( "texqual" ) )
|
|
m_pTextureManager->SetMipMapBiasLevel( atoi( ENV().GetString( "texqual" ).c_str()) );
|
|
else
|
|
{
|
|
int nMipBias = 0;
|
|
switch( GetGameOption().GetTextureMipBias() )
|
|
{
|
|
case 0 : nMipBias = 2; break;
|
|
case 1 : nMipBias = 1; break;
|
|
case 2 : nMipBias = 0; break;
|
|
}
|
|
|
|
m_pTextureManager->SetMipMapBiasLevel( nMipBias );
|
|
}
|
|
m_pTextureManager->init();
|
|
BotTest();
|
|
}
|
|
|
|
int SBotManager::InitViewportEx()
|
|
{
|
|
/// 2012.04.06 안쓰인다 - prodongi
|
|
//((SGameViewPort *)m_pViewportList[0])->CreateOcclusionBuffers();
|
|
|
|
const D3DCAPS9 & rCaps = m_pGraphics->GetCaps();
|
|
//m_bUseHqWater = rCaps.TextureOpCaps & D3DTEXOPCAPS_BUMPENVMAP;
|
|
if( rCaps.MaxSimultaneousTextures < 4 )
|
|
{
|
|
//저 사양 그래픽 임.
|
|
m_bUseHqWater = false;
|
|
SetShowWater(m_bUseHqWater);
|
|
return m_nViewportCount;
|
|
}
|
|
|
|
if( m_nViewportCount != 1 ) return m_nViewportCount;
|
|
|
|
KViewportStruct vp;
|
|
|
|
//그림자용 ViewPort
|
|
vp.X = 0;
|
|
vp.Y = 0;
|
|
vp.Width = SIZE_RT_1024;
|
|
vp.Height = SIZE_RT_1024;
|
|
vp.MinZ = 0.f;
|
|
vp.MaxZ = 1.0f;
|
|
|
|
SShadowViewPort * pShadowViewport = new SShadowViewPort(true, false);
|
|
pShadowViewport->Initilaize( m_pGraphics, vp, 100.f, 8000.f );
|
|
pShadowViewport->SetFillColor( KColor( 255,255,255,255 ) );
|
|
KSize shadowviewsize( RECT_SHADOW_1024, RECT_SHADOW_1024 );
|
|
pShadowViewport->SetViewArea( KRect( KPoint(0, 0), shadowviewsize ) );
|
|
//pShadowViewport->SetGameViewport((SViewPort*) m_pViewportList[0]);
|
|
m_pViewportList[1] = pShadowViewport;
|
|
((SGameViewPort *)m_pViewportList[0])->SetShadowViewPort( pShadowViewport );
|
|
|
|
m_nViewportCount = 2;
|
|
|
|
// return m_nViewportCount;
|
|
|
|
m_bUseHqWater = rCaps.TextureOpCaps & D3DTEXOPCAPS_BUMPENVMAP;
|
|
//m_bUseHqWater = true; // 이거 키면 와이어 프리미티브가 안나와서 임시로 끔.. by blackfish
|
|
|
|
if(m_bUseHqWater)
|
|
{
|
|
//Water용 ViewPort
|
|
vp.X = 0;
|
|
vp.Y = 0;
|
|
vp.Width = SIZE_RT_1024;
|
|
vp.Height = SIZE_RT_1024;
|
|
vp.MinZ = 0.f;
|
|
vp.MaxZ = 1.0f;
|
|
|
|
SWaterViewPort * pWaterViewport = new SWaterViewPort;
|
|
pWaterViewport->Initilaize( m_pGraphics, vp, 5.f, 6000.f );
|
|
pWaterViewport->SetFillColor( KColor( 255,255,255,255 ) );
|
|
KSize waterviewsize( RECT_WATER_1024, RECT_WATER_1024 );
|
|
pWaterViewport->SetViewArea( KRect( KPoint(0, 0), waterviewsize ) );
|
|
//pWaterViewport->SetGameViewport((SViewPort*) m_pViewportList[0]);
|
|
m_pViewportList[2] = pWaterViewport;
|
|
((SGameViewPort *)m_pViewportList[0])->SetWaterViewPort( pWaterViewport );
|
|
pWaterViewport->SetUseViewPort( true );
|
|
|
|
m_nViewportCount = 3;
|
|
}
|
|
|
|
SetShowWater(m_bUseHqWater);
|
|
|
|
return m_nViewportCount;
|
|
}
|
|
|
|
void SBotManager::Destroy()
|
|
{
|
|
if( m_pMSoundMgr )
|
|
{
|
|
m_pMSoundMgr->StopMusic();
|
|
m_pMSoundMgr->StopBgm();
|
|
}
|
|
|
|
SCircleShadowCommonInfo::GetInstance().Destroy();
|
|
|
|
SAFE_DELETE( m_pCursorMng );
|
|
|
|
SAFE_DELETE( m_pConsoleWnd );
|
|
SAFE_DELETE( m_pSystemInfoWnd );
|
|
|
|
SAFE_DELETE( m_pUIWndManager );
|
|
|
|
SAFE_DELETE_VECTOR( m_BotList );
|
|
|
|
for(int i = 0; i < 10; ++i)
|
|
SAFE_DELETE( m_pViewportList[i] );
|
|
m_nViewportCount = 0;
|
|
|
|
KTextRender::DestroyAll();
|
|
#ifdef _COUNTRY_ME_
|
|
KTextLayout2::DestroyLayoutEngine();
|
|
/// 2010.10.20 빠진것 같음 - prodongi
|
|
KTextLayout::DestroyLayoutEngine();
|
|
#endif
|
|
XNetworkUtil::DeInitNetwork();
|
|
|
|
_oprint( "Thread Loading Count : %d\n", KNX3Manager::GetManager()->GetThreadLoadingCount() );
|
|
|
|
while( KNX3Manager::GetManager()->GetThreadLoadingCount() )
|
|
{
|
|
Sleep(1);
|
|
}
|
|
|
|
// Release 하는 순서 중요 (KTextureManager를 맨 나중에 Release 하자)
|
|
KNX3Manager::GetManager()->ClearUnreferencedResource(); //여기서 모든 NX3Set 은 삭제 되야 한다.
|
|
|
|
KTextCacheManager::GetInstance()->DestroyAll();
|
|
|
|
KPrimitiveSpriteMng::GetManager()->Clear();
|
|
KPrimitiveSpriteMng::ReleaseManager();
|
|
|
|
KSpriteManager::ReleaseManager();
|
|
COBManager::ReleaseManager();
|
|
SpeedTreeManager::ReleaseManager();
|
|
|
|
KNX3Manager::ReleaseManager();
|
|
|
|
KUITextureManager::ReleaseManager();
|
|
KTextureManager::ReleaseManager();
|
|
|
|
//Device 삭제.
|
|
KDeviceManager *pDM = KDeviceManagerDX::GetDeviceManager();
|
|
if( pDM ) pDM->Clear();
|
|
|
|
SAFE_DELETE( m_pSoundMng );
|
|
SAFE_DELETE( m_pMSoundMgr );
|
|
}
|
|
|
|
void SBotManager::onHotkey( GameHotKeystrcut & HotKey )
|
|
{
|
|
static DWORD dwLastSnapShow;
|
|
|
|
/// 2010.11.10 - prodongi
|
|
if (g_UserInfo.isMonkeyTail())
|
|
{
|
|
extern bool g_bDebugMode;
|
|
|
|
if( g_bDebugMode && !m_bCheckRender && HotKey.Virtual_Key == VK_ESCAPE )
|
|
{
|
|
m_bCheckRender = true;
|
|
return;
|
|
}
|
|
|
|
if( g_bDebugMode && !HotKey.bUp && ( GetKeyState( VK_SCROLL ) & 0x01 ) && HotKey.Virtual_Key == VK_OEM_PLUS )
|
|
{
|
|
m_bActConsole = !m_bActConsole;
|
|
|
|
if(m_bActConsole)
|
|
{
|
|
m_pConsoleWnd->SetShow( true );
|
|
m_pUIWndManager->AddWnd(m_pConsoleWnd);
|
|
}
|
|
else
|
|
{
|
|
m_pConsoleWnd->SetShow( false );
|
|
m_pUIWndManager->RemoveWnd(m_pConsoleWnd);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if( g_bDebugMode && !HotKey.bUp && ( GetKeyState( VK_SCROLL ) & 0x01 ) && HotKey.Virtual_Key == VK_OEM_2 ) // '/'
|
|
{
|
|
m_bActSystemInfo = !m_bActSystemInfo;
|
|
|
|
if(m_bActSystemInfo)
|
|
{
|
|
m_pSystemInfoWnd->SetShow( true );
|
|
m_pUIWndManager->AddWnd(m_pSystemInfoWnd);
|
|
}
|
|
else
|
|
{
|
|
m_pSystemInfoWnd->SetShow( false );
|
|
m_pUIWndManager->RemoveWnd(m_pSystemInfoWnd);
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//스샷
|
|
if(!HotKey.bUp && (GetKeyState(VK_SCROLL) ) && HotKey.Virtual_Key == VK_OEM_2)
|
|
{
|
|
if( dwLastSnapShow + 3000 < GetSafeTickCount() )
|
|
{
|
|
HWND hWnd=g_hWnd;
|
|
RECT rcWnd;
|
|
GetClientRect(hWnd, &rcWnd);
|
|
ClientToScreen(hWnd, ((LPPOINT)&rcWnd));
|
|
ClientToScreen(hWnd, ((LPPOINT)&rcWnd)+1);
|
|
SaveScreenBMP( rcWnd, false );
|
|
|
|
dwLastSnapShow = GetSafeTickCount();
|
|
}
|
|
}
|
|
|
|
if (HotKey.Virtual_Key == VK_SNAPSHOT)
|
|
{
|
|
if (dwLastSnapShow + 3000 < GetSafeTickCount())
|
|
{
|
|
HWND hWnd = g_hWnd;
|
|
RECT rcWnd;
|
|
GetClientRect(hWnd, &rcWnd);
|
|
ClientToScreen(hWnd, ((LPPOINT)&rcWnd));
|
|
ClientToScreen(hWnd, ((LPPOINT)&rcWnd) + 1);
|
|
SaveScreenBMP(rcWnd, false);
|
|
|
|
dwLastSnapShow = GetSafeTickCount();
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
if( m_nSelectBot >= 0 )
|
|
{
|
|
m_BotList[m_nSelectBot]->onHotkey( HotKey );
|
|
}
|
|
}
|
|
|
|
bool SBotManager::IsLoadGameActivated()
|
|
{
|
|
if( m_nSelectBot >= 0 )
|
|
{
|
|
return m_BotList[m_nSelectBot]->IsLoadGameActivated();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void SBotManager::Bot_Add( const char * pName )
|
|
{
|
|
_oprint( "Bot_Add\n" );
|
|
|
|
SBot * pBot = new SBot( pName, m_pGraphics, m_pSoundMng, m_pTextureManager, m_pNX3Mgr, m_pViewportList, m_nViewportCount, m_pMSoundMgr );
|
|
|
|
m_BotList.push_back(pBot);
|
|
}
|
|
|
|
void SBotManager::Bot_Del( const char * pName )
|
|
{
|
|
_oprint( "Bot_Del\n" );
|
|
}
|
|
|
|
void SBotManager::Bot_Del_all()
|
|
{
|
|
_oprint( "Bot_Del_all\n" );
|
|
}
|
|
|
|
void SBotManager::Bot_List()
|
|
{
|
|
_oprint( "Bot_List\n" );
|
|
}
|
|
|
|
void SBotManager::Bot_Select( const char * pName )
|
|
{
|
|
_oprint( "Bot_Select\n" );
|
|
}
|
|
|
|
void SBotManager::LogSave()
|
|
{
|
|
|
|
}
|
|
|
|
LRESULT CALLBACK SBotManager::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
//포커스 잃어 버리면, Render 안되게...
|
|
switch( message )
|
|
{
|
|
case WM_ACTIVATE :
|
|
if( g_hWnd == hWnd )
|
|
{
|
|
if( LOWORD(wParam) == WA_INACTIVE )
|
|
{
|
|
// 2010.08.12 - prodongi
|
|
//#ifndef _DEV
|
|
// m_bActiveRender = FALSE;
|
|
//#endif
|
|
g_bActiveRender = false;
|
|
|
|
if( GetGameOption().GetWinMode() == 0 )
|
|
{
|
|
// 2010.09.24 디버깅 때문에 - prodongi
|
|
//#ifndef _DEBUG
|
|
#if !defined(_DEBUG) && !defined(_DEV)
|
|
::ShowWindow( g_hWnd, SW_MINIMIZE );
|
|
#endif
|
|
}
|
|
}
|
|
else/* if( LOWORD(wParam) == WA_ACTIVE ) || (LOWORD(wParam) == WA_CLICKACTIVE) ) */
|
|
{
|
|
m_bActiveRender = TRUE;
|
|
g_bActiveRender = true;
|
|
|
|
::ShowWindow( g_hWnd, SW_SHOW );
|
|
|
|
::SetFocus( g_hWnd );
|
|
}
|
|
|
|
if( m_pBotThis && m_pBotThis->m_nSelectBot >= 0/* && m_nExit*/ )
|
|
m_pBotThis->m_BotList[m_pBotThis->m_nSelectBot]->SetActiveRender( m_bActiveRender );
|
|
}
|
|
break;
|
|
case WM_SIZE:
|
|
if( g_hWnd == hWnd )
|
|
{
|
|
if( GetGameOption().GetWinMode() == 1 )
|
|
{
|
|
if( wParam == SIZE_MINIMIZED )
|
|
{
|
|
m_bActiveRender = FALSE;
|
|
g_bActiveRender = false;
|
|
|
|
if( m_pBotThis && m_pBotThis->m_nSelectBot >= 0/* && m_nExit*/ )
|
|
m_pBotThis->m_BotList[m_pBotThis->m_nSelectBot]->SetActiveRender( m_bActiveRender );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
if( WM_SYSKEYDOWN == message || WM_SYSKEYUP == message ) // #2.3.1.29
|
|
return 1;
|
|
|
|
// 이거 풀면 종료 메시지박스 제대로 안될것임 ...
|
|
//if( WM_CLOSE == message )
|
|
//{
|
|
// m_nExit = 0; //이후 처리는 하지 않음.
|
|
// _oprint( "WM_CLOSE 왔다\n" );
|
|
//}
|
|
|
|
//콘솔 우선 처리
|
|
if( m_pUIWndManager/* && m_nExit*/ )
|
|
{
|
|
if( m_bActConsole/* && m_nExit*/ )
|
|
{
|
|
_CID( WINDOWMSG );
|
|
if( m_pUIWndManager->PerformV( id_WINDOWMSG, message, (unsigned long)wParam, (unsigned long)lParam ) )
|
|
return 1; //뭔가 처리가 됐음.
|
|
}
|
|
}
|
|
|
|
////Cursor & IME
|
|
{
|
|
//Basic Cusor NULL
|
|
switch( message )
|
|
{
|
|
case WM_SETCURSOR :
|
|
{
|
|
::SetCursor( NULL );
|
|
m_pCursorMng->ShowCursor( TRUE );
|
|
}
|
|
return TRUE;
|
|
break;
|
|
case WM_MOUSEMOVE :
|
|
{
|
|
if( m_pGraphics->GetCaps().CursorCaps & D3DCURSORCAPS_LOWRES )
|
|
{
|
|
//소프트웨어 커서일 경우에만 써야 되는 듯...
|
|
POINT pt;
|
|
pt.x = GET_X_LPARAM(lParam);
|
|
pt.y = GET_Y_LPARAM(lParam);
|
|
ClientToScreen( g_hWnd, &pt );
|
|
if( m_pCursorMng ) m_pCursorMng->SetCursorPos( pt.x, pt.y );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( m_pBotThis && m_pBotThis->m_nSelectBot >= 0/* && m_nExit*/ )
|
|
{
|
|
//선택된 Bot만 컨트롤이 가능하다.
|
|
return m_pBotThis->m_BotList[m_pBotThis->m_nSelectBot]->WndProc(hWnd, message, wParam, lParam);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void *SBotManager::Perform( KID id, KArg& msg )
|
|
{
|
|
if( m_pUIWndManager ) m_pUIWndManager->Perform( id, msg );
|
|
|
|
return (void*)0;
|
|
}
|
|
|
|
void SBotManager::Process( DWORD dwSetTime )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
if (dwSetTime > 0)
|
|
{
|
|
dwTime = dwSetTime;
|
|
}
|
|
else
|
|
{
|
|
if( m_bActiveRender == FALSE )
|
|
{
|
|
if( m_dwCheckTime == 0 )
|
|
m_dwCheckTime = dwTime;
|
|
|
|
if( (dwTime - m_dwCheckTime) < 200 )
|
|
{
|
|
Sleep(100);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
m_dwCheckTime = dwTime;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_fTime = dwTime * 0.001;
|
|
|
|
if( m_fLastElapsedTime == 0.f )
|
|
m_fLastElapsedTime = m_fTime;
|
|
m_fElapsedTime = (double) (m_fTime - m_fLastElapsedTime);
|
|
m_fLastElapsedTime = m_fTime;
|
|
m_fAccumTime += m_fElapsedTime;
|
|
|
|
if( GetGameOption().IsTreeRender() )
|
|
{
|
|
CSpeedTreeRT::SetTime( m_fAccumTime );
|
|
SetupWindMatrices( m_fAccumTime );
|
|
}
|
|
|
|
if( GetGameOption().IsGrassRender() )
|
|
{
|
|
KSeqSpeedGrass::SetAccumTime( m_fAccumTime );
|
|
}
|
|
|
|
if( m_pCursorMng ) m_pCursorMng->Process( dwTime );
|
|
|
|
if( m_pUIWndManager ) m_pUIWndManager->Process( dwTime );
|
|
|
|
for( unsigned int i(0); m_BotList.size()>i; i++ )
|
|
{
|
|
DWORD dwBotTime = GetSafeTickCount();
|
|
|
|
m_BotList[i]->Process( m_ulProcessBitVector );
|
|
|
|
if( GetSafeTickCount() - dwBotTime > 200 )
|
|
{
|
|
_oprint( "CAUTION: Process(%s) : %d\n", m_BotList[i]->GetName(), GetSafeTickCount() - dwTime );
|
|
}
|
|
}
|
|
}
|
|
|
|
SBot* SBotManager::GetCurBot()
|
|
{
|
|
if( m_nSelectBot >= 0 )
|
|
return m_BotList[m_nSelectBot];
|
|
|
|
return NULL;
|
|
}
|
|
|
|
extern VARIANT_BOOL g_IsShowWebBrowser;
|
|
extern bool g_IsShowWebBrowserChanged;
|
|
|
|
void SBotManager::Render( unsigned long uRenderBitVector )
|
|
{
|
|
if( m_bActiveRender == FALSE ) return;
|
|
|
|
if( m_bCheckRender == false ) return;
|
|
|
|
//gmpbigsun( 20130329 ) : 웹브라우저가 활성화 상태라면 DialogBoxMode 항상 ON ( 투명처럼 보이는 문제 )
|
|
//if ( g_IsShowWebBrowserChanged )
|
|
//{
|
|
// //소프트웨어 커서 생기면 삭제 해야 함.
|
|
// if( m_pGraphics->GetCaps().CursorCaps & D3DCURSORCAPS_LOWRES ||
|
|
// m_pGraphics->GetCaps().CursorCaps == 0 )
|
|
// {
|
|
// m_pGraphics->GetD3DDevice()->SetDialogBoxMode( TRUE );
|
|
// }
|
|
// else
|
|
// {
|
|
// m_pGraphics->GetD3DDevice()->SetDialogBoxMode( g_IsShowWebBrowser ); // 웹브라우저를 띄우는 경우 페이지 플리핑을 끈다. - by Tyburn
|
|
// }
|
|
// g_IsShowWebBrowserChanged = false;
|
|
//}
|
|
|
|
if( g_IsShowWebBrowser )
|
|
m_pGraphics->GetD3DDevice()->SetDialogBoxMode( TRUE );
|
|
|
|
g_DP_Count[0] = 0;
|
|
g_DP_Count[1] = 0;
|
|
g_DP_Count[2] = 0;
|
|
|
|
g_UsedMeshEXPoolCount[0] = 0;
|
|
g_UsedMeshEXPoolCount[1] = 0;
|
|
g_UsedMeshEXPoolCount[2] = 0;
|
|
|
|
g_Poly_Count = 0;
|
|
|
|
if( m_pCursorMng ) m_pCursorMng->Render();
|
|
|
|
if( m_ulRenderBitVector & Bot_RenderActBot )
|
|
{
|
|
if( m_nSelectBot >= 0 )
|
|
{
|
|
m_BotList[m_nSelectBot]->Render( m_ulRenderBitVector );
|
|
}
|
|
}
|
|
|
|
if( uRenderBitVector & Bot_RenderConsole )
|
|
{
|
|
//콘솔을 나중에 Render
|
|
if( m_pUIWndManager ) m_pUIWndManager->Render( m_pViewportList[0] ) ;
|
|
}
|
|
|
|
|
|
{
|
|
m_pGraphics->BeginScene();
|
|
}
|
|
|
|
g_Poly_Count = 0;
|
|
|
|
START_ONE_FRAME();
|
|
if( m_ulRenderBitVector & Bot_RenderViewShadow )
|
|
{
|
|
if(m_pViewportList[1])
|
|
{
|
|
g_UsedMeshEXPoolCount[1] = m_pViewportList[1]->GetUsedMeshEXPoolCount();
|
|
m_pViewportList[1]->Render(false);
|
|
g_DP_Count[0] = m_pGraphics->GetDPCount();
|
|
g_Poly_Count += m_pGraphics->GetPolyCount();
|
|
}
|
|
}
|
|
|
|
if( m_ulRenderBitVector & Bot_RenderViewWater )
|
|
{
|
|
if( m_pViewportList[2] && m_pViewportList[0]->GetUseWater() && m_pViewportList[0]->IsRenderWater() )
|
|
{
|
|
g_UsedMeshEXPoolCount[2] = m_pViewportList[2]->GetUsedMeshEXPoolCount();
|
|
m_pViewportList[2]->Render(false);
|
|
g_DP_Count[1] = m_pGraphics->GetDPCount();
|
|
g_Poly_Count += m_pGraphics->GetPolyCount();
|
|
}
|
|
}
|
|
|
|
if( m_ulRenderBitVector & Bot_RenderViewGame )
|
|
{
|
|
g_UsedMeshEXPoolCount[0] = m_pViewportList[0]->GetUsedMeshEXPoolCount();
|
|
m_pViewportList[0]->Render();
|
|
|
|
if(m_pViewportList[1]) m_pViewportList[1]->ClearRegisteredList();
|
|
if(m_pViewportList[2]) m_pViewportList[2]->ClearRegisteredList();
|
|
}
|
|
END_ONE_FRAME();
|
|
|
|
g_DP_Count[2] = m_pGraphics->GetDPCount();
|
|
g_Poly_Count += m_pGraphics->GetPolyCount();
|
|
|
|
#ifdef DEBUG
|
|
g_TexMem = m_pGraphics->GetD3DDevice()->GetAvailableTextureMem();
|
|
#endif
|
|
|
|
{
|
|
m_pGraphics->EndScene();
|
|
}
|
|
{
|
|
if( m_pGraphics )
|
|
{
|
|
HRESULT hr = m_pGraphics->Render();
|
|
|
|
if( hr == D3DERR_DEVICELOST )
|
|
{
|
|
SGameCursorMng::OnDeviceLost();
|
|
KUITextureManager::GetManager()->DeviceLost();
|
|
|
|
KPrimitiveSpriteMng::GetManager()->DeviceLost();
|
|
|
|
if( m_nSelectBot >= 0 )
|
|
m_BotList[m_nSelectBot]->onDeviceLost();
|
|
}
|
|
}
|
|
}
|
|
|
|
if( m_ulRenderBitVector & Bot_RenderActBot )
|
|
{
|
|
if( m_nSelectBot >= 0 )
|
|
{
|
|
m_BotList[m_nSelectBot]->AfterRender( m_ulRenderBitVector );
|
|
}
|
|
}
|
|
}
|
|
|
|
bool ilSaveImageBGRA(const DWORD* c_pdwSrc, UINT uPitch, UINT uWidth, UINT uHeight, const char* c_szFileName, bool bJPG = true)
|
|
{
|
|
ilInit();
|
|
ilEnable(IL_FILE_OVERWRITE);
|
|
|
|
if( bJPG )
|
|
ilSetInteger(IL_JPG_QUALITY, 85);
|
|
|
|
ILuint uHandle;
|
|
ilGenImages(1, &uHandle);
|
|
ilBindImage(uHandle);
|
|
|
|
bool isSucceeded=false;
|
|
if (ilTexImage(uWidth, uHeight, 1, 4, IL_BGRA, IL_UNSIGNED_BYTE, NULL))
|
|
{
|
|
DWORD* pdwDst=(DWORD*)ilGetData();
|
|
|
|
if( pdwDst == NULL ) return false;
|
|
|
|
for (UINT i=0; i<uHeight; ++i)
|
|
{
|
|
memcpy(pdwDst, c_pdwSrc, uWidth*sizeof(DWORD));
|
|
|
|
if( !bJPG ) //알파 0xFF
|
|
{
|
|
for (UINT w=0; w<uWidth; ++w)
|
|
pdwDst[w] |= 0xFF000000;
|
|
}
|
|
|
|
c_pdwSrc+=uPitch;
|
|
pdwDst+=uWidth;
|
|
}
|
|
|
|
iluFlipImage();
|
|
|
|
if (ilSaveImage((ILstring) c_szFileName))
|
|
isSucceeded=true;
|
|
}
|
|
|
|
ilDeleteImages(1, &uHandle);
|
|
|
|
return isSucceeded;
|
|
}
|
|
|
|
bool ilSaveAsType( char* c_szFileName, char* c_szSaveAsFileName )
|
|
{
|
|
ilInit();
|
|
ilEnable(IL_FILE_OVERWRITE);
|
|
|
|
ILuint uHandle;
|
|
ilGenImages(1, &uHandle);
|
|
|
|
ILboolean success;
|
|
success = ilLoadImage( c_szFileName );
|
|
if( success )
|
|
{
|
|
//Image Type
|
|
//IL_BMP //IL_CHEAD //IL_JPG //IL_PCX //IL_PNG
|
|
//IL_PNM //IL_RAW //IL_SGI //IL_TGA //IL_JASC_PAL
|
|
|
|
success = ilSave( IL_TGA, c_szSaveAsFileName );
|
|
if( !success )
|
|
{
|
|
_oprint( "Error ilSaveAsType : %s\n", iluErrorString( ilGetError() ) );
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_oprint( "Error ilSaveAsType : %s\n", iluErrorString( ilGetError() ) );
|
|
return false;
|
|
}
|
|
|
|
ilDeleteImages(1, &uHandle);
|
|
|
|
DWORD dwAttrs;
|
|
dwAttrs = GetFileAttributes(c_szSaveAsFileName);
|
|
if (!(dwAttrs & FILE_ATTRIBUTE_HIDDEN))
|
|
SetFileAttributes(c_szSaveAsFileName, dwAttrs | FILE_ATTRIBUTE_HIDDEN);
|
|
|
|
return true;
|
|
}
|
|
|
|
void SBotManager::SaveScreenBMP( const RECT& c_rcWnd, bool bMovieMode )
|
|
{
|
|
|
|
//Calculate the filename to use
|
|
char dir[_MAX_PATH];
|
|
char filename[_MAX_FNAME];
|
|
|
|
std::string strDirName, strOutName, strOutBMPName;
|
|
|
|
GetCurrentDirectory( _MAX_PATH, dir );
|
|
|
|
std::string strDefName;
|
|
|
|
SYSTEMTIME st;
|
|
GetLocalTime(&st);
|
|
|
|
/// 2011.10.14 달력 약어 - prodongi
|
|
std::string strMonth;
|
|
switch (st.wMonth)
|
|
{
|
|
case 1: strMonth = "Jan"; break;
|
|
case 2: strMonth = "Feb"; break;
|
|
case 3: strMonth = "Mar"; break;
|
|
case 4: strMonth = "Apr"; break;
|
|
case 5: strMonth = "May"; break;
|
|
case 6: strMonth = "Jun"; break;
|
|
case 7: strMonth = "Jul"; break;
|
|
case 8: strMonth = "Aug"; break;
|
|
case 9: strMonth = "Sep"; break;
|
|
case 10: strMonth = "Oct"; break;
|
|
case 11: strMonth = "Nov"; break;
|
|
case 12: strMonth = "Dec"; break;
|
|
};
|
|
|
|
/// 2011.10.14 파일명에 시스템 시간 적용 - prodongi
|
|
std::string strTime;
|
|
XStringUtil::Format(strTime, "_%04u%s%02u_%02u-%02u-%02u", st.wYear, strMonth.c_str(), st.wDay, st.wHour, st.wMinute, st.wSecond);
|
|
|
|
if( bMovieMode ) strDefName = "rappelz_movie";
|
|
else strDefName = "rappelz_screen";
|
|
strDefName += strTime;
|
|
strDefName += "_%08d";
|
|
if( bMovieMode ) strDefName += ".TGA";
|
|
else strDefName += ".JPG";
|
|
|
|
/*
|
|
std::string strDefName;
|
|
if( bMovieMode )
|
|
strDefName = "rappelz_movie_%08d.TGA";
|
|
else
|
|
strDefName = "rappelz_screen%08d.JPG";
|
|
*/
|
|
|
|
strOutName = dir;
|
|
strOutName += "\\";
|
|
strDirName = strOutName;
|
|
while ( true )
|
|
{
|
|
sprintf(filename, strDefName.c_str(), m_nScreenCount);
|
|
strOutName = strDirName;
|
|
strOutName += filename;
|
|
|
|
SFileRoot file( strOutName.c_str(), SFileRoot::OPEN_READ );
|
|
if( file.IsVaild() )
|
|
m_nScreenCount++;
|
|
else
|
|
break;
|
|
}
|
|
|
|
strOutBMPName = strOutName;
|
|
|
|
HRESULT hr;
|
|
|
|
//Get the size of the front buffer
|
|
D3DDISPLAYMODE mode;
|
|
|
|
hr=m_pGraphics->GetD3DDevice()->GetDisplayMode(0, &mode);
|
|
if(FAILED(hr))
|
|
{
|
|
_oprint("Unable to get front buffer size\n");
|
|
return;
|
|
}
|
|
|
|
//비디오 메모리 영역 넘어간 윈도우는 스샷 만들지 않음.
|
|
if( c_rcWnd.left < 0 ||
|
|
c_rcWnd.right > mode.Width ||
|
|
c_rcWnd.top < 0 ||
|
|
c_rcWnd.bottom > mode.Height )
|
|
return;
|
|
|
|
//Create an image surface the same size as the window
|
|
LPDIRECT3DSURFACE9 surface=NULL;
|
|
hr=m_pGraphics->GetD3DDevice()->CreateOffscreenPlainSurface(mode.Width, mode.Height, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &surface, NULL);
|
|
if(FAILED(hr))
|
|
{
|
|
_oprint("Unable to create surface to hold screenshot");
|
|
return;
|
|
}
|
|
|
|
//Copy the front buffer onto the surface
|
|
hr=m_pGraphics->GetD3DDevice()->GetFrontBufferData(0, surface);
|
|
if(FAILED(hr))
|
|
{
|
|
_oprint("Unable to read front buffer");
|
|
if(surface)
|
|
surface->Release();
|
|
surface=NULL;
|
|
return;
|
|
}
|
|
|
|
|
|
bool isSucceeded=false;
|
|
D3DLOCKED_RECT kD3DLockRect;
|
|
if (SUCCEEDED(surface->LockRect(&kD3DLockRect, NULL, 0)))
|
|
{
|
|
const DWORD* c_pdwBase=(const DWORD*)kD3DLockRect.pBits;
|
|
UINT uPitch=kD3DLockRect.Pitch/sizeof(DWORD);
|
|
UINT uWidth=c_rcWnd.right-c_rcWnd.left;
|
|
UINT uHeight=c_rcWnd.bottom-c_rcWnd.top;
|
|
|
|
if( uWidth > GetGameOption().GetResolution_Width() ||
|
|
uHeight > GetGameOption().GetResolution_Height() )
|
|
{
|
|
if(surface)
|
|
surface->Release();
|
|
surface=NULL;
|
|
return;
|
|
}
|
|
|
|
isSucceeded=ilSaveImageBGRA(
|
|
c_pdwBase+c_rcWnd.top*uPitch+c_rcWnd.left,
|
|
uPitch,
|
|
uWidth,
|
|
uHeight,
|
|
strOutBMPName.c_str(), !bMovieMode);
|
|
|
|
surface->UnlockRect();
|
|
}
|
|
|
|
//Release the surface
|
|
if(surface)
|
|
surface->Release();
|
|
surface=NULL;
|
|
}
|
|
|
|
void SBotManager::SetWindStrength(float fWindStrength)
|
|
{
|
|
m_fWindStrength = fWindStrength;
|
|
}
|
|
|
|
void SBotManager::SetupWindMatrices(float fTimeInSecs)
|
|
{
|
|
// matrix computational data
|
|
static float afMatrixTimes[c_nNumWindMatrices] = { 0.0f };
|
|
static float afFrequencies[c_nNumWindMatrices][2] =
|
|
{
|
|
{ 0.15f, 0.17f },
|
|
{ 0.25f, 0.15f },
|
|
{ 0.19f, 0.05f },
|
|
{ 0.15f, 0.22f }
|
|
};
|
|
|
|
// compute time since last call
|
|
static float fTimeOfLastCall = 0.0f;
|
|
float fTimeSinceLastCall = fTimeInSecs - fTimeOfLastCall;
|
|
fTimeOfLastCall = fTimeInSecs;
|
|
|
|
// wind strength
|
|
m_fOldStrength = m_fWindStrength;
|
|
|
|
// increment matrix times
|
|
int i;
|
|
for (i = 0; i < c_nNumWindMatrices; ++i)
|
|
afMatrixTimes[i] += fTimeSinceLastCall;
|
|
|
|
// compute maximum branch throw
|
|
float fBaseAngle = m_fWindStrength * 35.0f;
|
|
|
|
// build rotation matrices
|
|
for (i = 0; i < c_nNumWindMatrices; ++i)
|
|
{
|
|
// adjust time to prevent "jumping"
|
|
if (m_fWindStrength != 0.0f)
|
|
afMatrixTimes[i] = (afMatrixTimes[i] * m_fOldStrength) / m_fWindStrength;
|
|
|
|
// compute percentages for each axis
|
|
float fBaseFreq = m_fWindStrength * 20.0f;
|
|
float fXPercent = sinf(fBaseFreq * afFrequencies[i % c_nNumWindMatrices][0] * afMatrixTimes[i]);
|
|
float fYPercent = cosf(fBaseFreq * afFrequencies[i % c_nNumWindMatrices][1] * afMatrixTimes[i]);
|
|
|
|
// build compound rotation matrix (rotate on 'x' then on 'y')
|
|
const float c_fDeg2Rad = 57.2957795f;
|
|
float fSinX = sinf(fBaseAngle * fXPercent / c_fDeg2Rad);
|
|
float fSinY = sinf(fBaseAngle * fYPercent / c_fDeg2Rad);
|
|
float fCosX = cosf(fBaseAngle * fXPercent / c_fDeg2Rad);
|
|
float fCosY = cosf(fBaseAngle * fYPercent / c_fDeg2Rad);
|
|
|
|
float afMatrix[16] = { 0.0f };
|
|
afMatrix[0] = fCosY;
|
|
afMatrix[2] = -fSinY;
|
|
afMatrix[4] = fSinX * fSinY;
|
|
afMatrix[5] = fCosX;
|
|
afMatrix[6] = fSinX * fCosY;
|
|
afMatrix[8] = fSinY * fCosX;
|
|
afMatrix[9] = -fSinX;
|
|
afMatrix[10] = fCosX * fCosY;
|
|
afMatrix[15] = 1.0f;
|
|
|
|
#ifdef WRAPPER_USE_CPU_WIND
|
|
CSpeedTreeRT::SetWindMatrix(i, afMatrix);
|
|
#endif
|
|
#ifdef WRAPPER_USE_GPU_WIND
|
|
// graphics API specific
|
|
//UploadWindMatrix(c_nVertexShader_WindMatrices + i * 4, afMatrix);
|
|
m_pGraphics->GetD3DDevice()->SetVertexShaderConstantF(c_nVertexShader_WindMatrices + i * 4, afMatrix, 4);
|
|
#endif
|
|
}
|
|
|
|
// track wind strength
|
|
m_fOldStrength = m_fWindStrength;
|
|
}
|
|
|
|
KUIGenWnd* SBotManager::CreateConsoleWnd()
|
|
{
|
|
const KPoint c_ptWnd = KPoint( 0, 0 ); //위치
|
|
const KSize c_sizWnd = KSize ( 1024, 268 ); //크기
|
|
|
|
const KPoint c_ptInfoWnd = KPoint( 0, 268 ); //위치
|
|
const KSize c_sizInfoWnd = KSize ( 300, 200 ); //크기
|
|
|
|
m_pConsoleWnd = new SUITopConsoleWnd();
|
|
m_pConsoleWnd->Create( KUIWND_CREATE_ARG( "genwnd", "top_console", "system_console", KRect( c_ptWnd, c_sizWnd ), KSTYLE_NOSTATUSBAR | KSTYLE_NOMINIMIZE | KSTYLE_NOCLOSE, KFLAG_GET_PASS_MESSAGE, 0, "frame", c_szDEF_SPR_NAME, m_pUIWndManager ) );
|
|
m_pConsoleWnd->CreateControls( m_pUIWndManager );
|
|
#ifdef _KUI_INVALIDATION
|
|
m_pConsoleWnd->ActivateImageCache( false );
|
|
#endif
|
|
|
|
//System Info
|
|
m_pSystemInfoWnd = new SUITopSystemInfoWnd();
|
|
m_pSystemInfoWnd->Create( KUIWND_CREATE_ARG( "genwnd", "system_info", "system_info", KRect( c_ptInfoWnd, c_sizInfoWnd ), KSTYLE_NOSTATUSBAR | KSTYLE_NOMINIMIZE | KSTYLE_NOCLOSE, KFLAG_GET_PASS_MESSAGE, 0, "frame", c_szDEF_SPR_NAME, m_pUIWndManager ) );
|
|
m_pSystemInfoWnd->CreateControls( m_pUIWndManager );
|
|
|
|
return m_pConsoleWnd;
|
|
}
|
|
|
|
void SBotManager::GetTimeStr( std::string & strName, const char * pPreFileName )
|
|
{
|
|
struct tm *newtime;
|
|
time_t _time;
|
|
|
|
time( &_time ); /* Get time as long integer. */
|
|
newtime = localtime( &_time ); /* Convert to local time. */
|
|
|
|
XStringUtil::Format( strName, "%s_%.24s.txt", pPreFileName, asctime( newtime ) );
|
|
|
|
XStringUtil::Replace( strName, ":", "_" );
|
|
XStringUtil::Replace( strName, " ", "_" );
|
|
}
|
|
|
|
void SBotManager::ProcConsole( SGameMessage* pGameMsg )
|
|
{
|
|
if( pGameMsg->nType != MSG_CONSOLE_BUILDER ) return;
|
|
|
|
SMSG_CONSOLE_BUILDER* pMsg = static_cast<SMSG_CONSOLE_BUILDER*>(pGameMsg);
|
|
|
|
if( pMsg->m_bOut )
|
|
{
|
|
if( m_pConsoleWnd == NULL ) return;
|
|
|
|
std::string strOutput;
|
|
strOutput = "><br>";
|
|
|
|
std::vector<std::string> vecKeyList;
|
|
MsgSplit( pMsg->m_strKey.c_str(), vecKeyList, L"." );
|
|
if( ::_stricmp(vecKeyList[0].c_str(), "history") == 0 || ::_stricmp(vecKeyList[0].c_str(), "list") == 0 || ::_stricmp(vecKeyList[0].c_str(), "help") == 0 )
|
|
{
|
|
if( pMsg->m_nValueCount == 0 ) strOutput += "============ empty list ===============<br>";
|
|
else
|
|
{
|
|
strOutput += "============ ";
|
|
strOutput += pMsg->m_strKey;
|
|
strOutput += " ===============<br>";
|
|
|
|
for( int i = 0; i < pMsg->m_nValueCount; i++ )
|
|
{
|
|
strOutput += pMsg->m_vecValueList[i];
|
|
strOutput += "<br>";
|
|
}
|
|
strOutput += "============ end list ===============<br>";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( pMsg->m_nValueCount == 0 ) strOutput += "invalid command<br>";
|
|
else // get, ?
|
|
{
|
|
strOutput += pMsg->m_strKey;
|
|
|
|
for( int i = 0; i < pMsg->m_nValueCount+1; i++ )
|
|
{
|
|
if( i == pMsg->m_nValueCount )
|
|
{
|
|
strOutput += ";<br>";
|
|
break;
|
|
}
|
|
|
|
if( i == 0 ) strOutput += " ";
|
|
if( i > 0 ) strOutput += ";";
|
|
strOutput += pMsg->m_vecValueList[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
strOutput += "><br>";
|
|
m_pConsoleWnd->AddChatText( strOutput.c_str() );
|
|
|
|
vecKeyList.clear();
|
|
return;
|
|
}
|
|
|
|
bool bResult = false;
|
|
// option.
|
|
if( pMsg->m_nCommandType == SMSG_CONSOLE_BUILDER::TYPE_OPTION ) bResult = ProcOptionConsole( pGameMsg );
|
|
// lua.
|
|
else if( pMsg->m_nCommandType == SMSG_CONSOLE_BUILDER::TYPE_LUA ) bResult = ProcLuaConsole( pGameMsg );
|
|
// debug.
|
|
else if( pMsg->m_nCommandType == SMSG_CONSOLE_BUILDER::TYPE_DEBUG ) bResult = ProcDebugConsole( pGameMsg );
|
|
// game.
|
|
else if( pMsg->m_nCommandType == SMSG_CONSOLE_BUILDER::TYPE_GAME ) bResult = ProcGameConsole( pGameMsg );
|
|
|
|
//게임 치트
|
|
if( m_nSelectBot >= 0 && !bResult ) m_BotList[m_nSelectBot]->ProcConsole( pGameMsg );
|
|
}
|
|
bool SBotManager::ProcGameConsole( SGameMessage* pGameMsg )
|
|
{
|
|
SMSG_CONSOLE_BUILDER* pMsg = static_cast<SMSG_CONSOLE_BUILDER*>(pGameMsg);
|
|
|
|
while( true )
|
|
{
|
|
if( !::_stricmp(pMsg->m_strKey.c_str(), "botmng_render_toggle") ) { m_bCheckRender = !m_bCheckRender; return true; }
|
|
if( !::_stricmp(pMsg->m_strKey.c_str(), "bot_del_all") ) { Bot_Del_all(); return true; }
|
|
if( !::_stricmp(pMsg->m_strKey.c_str(), "game_water_toggle") )
|
|
{
|
|
if( m_nViewportCount != 3 ) return true;
|
|
m_pViewportList[0]->SetUseWater( !m_pViewportList[2]->GetUseViewPort() );
|
|
m_pViewportList[2]->SetUseViewPort( !m_pViewportList[2]->GetUseViewPort() );
|
|
return true;
|
|
}
|
|
//if( !::_stricmp(pMsg->m_strKey.c_str(), "game_usehdr") )
|
|
//{
|
|
// bool bUse = !((SGameViewPort*)m_pViewportList[0])->GetUseHDR();
|
|
// ((SGameViewPort*)m_pViewportList[0])->SetUseHDR( bUse );
|
|
//}
|
|
//if( !::_stricmp(pMsg->m_strKey.c_str(), "game_hdr_none") ) { ((SGameViewPort*)m_pViewportList[0])->SetHDRType( SGameViewPort::HDR_TYPE_NONE ); }
|
|
//if( !::_stricmp(pMsg->m_strKey.c_str(), "game_hdr_blur") ) { ((SGameViewPort*)m_pViewportList[0])->SetHDRType( SGameViewPort::HDR_TYPE_BLUR ); }
|
|
//if( !::_stricmp(pMsg->m_strKey.c_str(), "game_hdr_cross") ){ ((SGameViewPort*)m_pViewportList[0])->SetHDRType( SGameViewPort::HDR_TYPE_CROSS ); }
|
|
//리소스 매니저
|
|
if( !::_stricmp(pMsg->m_strKey.c_str(), "all_list") )
|
|
{
|
|
std::string strFile;
|
|
GetTimeStr( strFile, "debug_nx3_list" );
|
|
KNX3Manager::GetManager()->PrintList( strFile.c_str() );
|
|
|
|
GetTimeStr( strFile, "debug_tex_list" );
|
|
KTextureManager::GetManager()->PrintList( strFile.c_str() );
|
|
}
|
|
if( !::_stricmp(pMsg->m_strKey.c_str(), "nx3_list") )
|
|
{
|
|
std::string strFile;
|
|
GetTimeStr( strFile, "debug_nx3_list" );
|
|
KNX3Manager::GetManager()->PrintList( strFile.c_str() );
|
|
}
|
|
|
|
if( !::_stricmp(pMsg->m_strKey.c_str(), "tex_list") )
|
|
{
|
|
std::string strFile;
|
|
GetTimeStr( strFile, "debug_tex_list" );
|
|
KTextureManager::GetManager()->PrintList( strFile.c_str() );
|
|
}
|
|
|
|
if( !::_stricmp(pMsg->m_strKey.c_str(), "spr_list") )
|
|
{
|
|
std::string strFile;
|
|
GetTimeStr( strFile, "debug_spr_list" );
|
|
KSpriteManager::GetManager()->PrintList( strFile.c_str() );
|
|
}
|
|
|
|
// value count > 1
|
|
if( pMsg->m_vecValueList.size() < 1 ) break;
|
|
|
|
if( !::_stricmp(pMsg->m_strKey.c_str(), "pf") )
|
|
{
|
|
int nFlag = atoi(pMsg->m_vecValueList[0].c_str());
|
|
if( nFlag == 0 )
|
|
m_ulProcessBitVector ^= Game_ProcessLoadGame;
|
|
if( nFlag == 1 )
|
|
m_ulProcessBitVector ^= Game_ProcessInterface;
|
|
if( nFlag == 2 )
|
|
m_ulProcessBitVector ^= Game_ProcessNetwork;
|
|
if( nFlag == 3 )
|
|
m_ulProcessBitVector ^= Game_ProcessActGame;
|
|
if( nFlag == 4 )
|
|
m_ulProcessBitVector ^= Game_ProcessArclient;
|
|
|
|
//GameWorld
|
|
if( nFlag == 5 )
|
|
m_ulProcessBitVector ^= World_ProcessCommandSys;
|
|
if( nFlag == 6 )
|
|
m_ulProcessBitVector ^= World_ProcessGameSys;
|
|
if( nFlag == 7 )
|
|
m_ulProcessBitVector ^= World_ProcessSky;
|
|
if( nFlag == 8 )
|
|
m_ulProcessBitVector ^= World_ProcessTargetModel;
|
|
if( nFlag == 9 )
|
|
m_ulProcessBitVector ^= World_ProcessLocal;
|
|
if( nFlag == 10 )
|
|
m_ulProcessBitVector ^= World_ProcessEffect;
|
|
if( nFlag == 11 )
|
|
m_ulProcessBitVector ^= World_ProcessEnhanEffect;
|
|
if( nFlag == 12 )
|
|
m_ulProcessBitVector ^= World_ProcessLensFlare;
|
|
//[sonador] -->
|
|
if( nFlag == 13 )
|
|
m_ulProcessBitVector ^= World_ProcessWeather;
|
|
//[sonador] <--
|
|
if( nFlag == 14 )
|
|
m_ulProcessBitVector ^= World_ProcessSelectTarget;
|
|
if( nFlag == 15 )
|
|
m_ulProcessBitVector ^= World_ProcessTerrain;
|
|
|
|
if( nFlag == 16 )
|
|
m_ulProcessBitVector = Game_ProcessAll;
|
|
}
|
|
|
|
if( !::_stricmp(pMsg->m_strKey.c_str(), "rf") )
|
|
{
|
|
int nFlag = atoi(pMsg->m_vecValueList[0].c_str());
|
|
if( nFlag == 0 ) m_ulRenderBitVector ^= Bot_RenderActBot;
|
|
if( nFlag == 1 ) m_ulRenderBitVector ^= Bot_RenderConsole;
|
|
if( nFlag == 2 ) m_ulRenderBitVector ^= Bot_RenderViewGame;
|
|
if( nFlag == 3 ) m_ulRenderBitVector ^= Bot_RenderViewShadow;
|
|
if( nFlag == 4 ) m_ulRenderBitVector ^= Bot_RenderViewWater;
|
|
|
|
if( nFlag == 5 ) m_ulRenderBitVector ^= Game_RenderAct;
|
|
if( nFlag == 6 ) m_ulRenderBitVector ^= Game_RenderLoad;
|
|
if( nFlag == 7 ) m_ulRenderBitVector ^= Game_RenderInterface;
|
|
|
|
if( nFlag == 8 ) m_ulRenderBitVector ^= Game_RenderSky;
|
|
if( nFlag == 9 ) m_ulRenderBitVector ^= Game_RenderTarget;
|
|
if( nFlag == 10 ) m_ulRenderBitVector ^= Game_RenderTerrain;
|
|
if( nFlag == 11 ) m_ulRenderBitVector ^= Game_RenderEffect;
|
|
if( nFlag == 12 ) m_ulRenderBitVector ^= Game_RenderCommandSys;
|
|
if( nFlag == 13 ) m_ulRenderBitVector ^= Game_RenderLensFlare;
|
|
if( nFlag == 14 ) m_ulRenderBitVector ^= Game_RenderWeather; // [sonador]
|
|
if( nFlag == 15 ) m_ulRenderBitVector ^= Game_RenderWire;
|
|
if( nFlag == 16 ) m_ulRenderBitVector ^= Game_RenderAvatar;
|
|
if( nFlag == 17 ) m_ulRenderBitVector ^= Game_RenderAction;
|
|
if( nFlag == 18 ) m_ulRenderBitVector ^= Game_RenderSegment;
|
|
if( nFlag == 19 ) m_ulRenderBitVector ^= Game_RenderPropProc;
|
|
if( nFlag == 20 ) m_ulRenderBitVector ^= Game_RenderProp;
|
|
if( nFlag == 21 ) m_ulRenderBitVector ^= Game_RenderSegShadow01;
|
|
if( nFlag == 22 ) m_ulRenderBitVector ^= Game_RenderSegShadow02;
|
|
if( nFlag == 23 ) m_ulRenderBitVector = Bot_RenderAll;
|
|
if( nFlag == 24 ) m_ulRenderBitVector = Bot_RenderActBot | Bot_RenderConsole | Bot_RenderViewGame | Game_RenderInterface;
|
|
}
|
|
|
|
if( !::_stricmp(pMsg->m_strKey.c_str(), "bot_add") ) { Bot_Add(pMsg->m_vecValueList[0].c_str()); return true; }
|
|
if( !::_stricmp(pMsg->m_strKey.c_str(), "bot_del") ) { Bot_Del(pMsg->m_vecValueList[0].c_str()); return true; }
|
|
if( !::_stricmp(pMsg->m_strKey.c_str(), "bot_sel") ) { Bot_Select (pMsg->m_vecValueList[0].c_str()); return true; }
|
|
if( !::_stricmp(pMsg->m_strKey.c_str(), "view_rf") )
|
|
{
|
|
if( pMsg->m_vecValueList[0] == "u" ) m_pViewportList[0]->SetRenderFlag( RENDER_SPRITE );
|
|
|
|
if( pMsg->m_vecValueList[0] == "a" || pMsg->m_vecValueList[0] == "u" )
|
|
{
|
|
for( int i = 0; i < 32; ++i ) m_pViewportList[0]->SetRenderFlag( i );
|
|
}
|
|
else m_pViewportList[0]->SetRenderFlag( atoi(pMsg->m_vecValueList[0].c_str()) );
|
|
}
|
|
//if( !::_stricmp(pMsg->m_strKey.c_str(), "game_hdr_set") )
|
|
//{
|
|
// int nVarCross, nVarBlur;
|
|
// nVarCross = nVarBlur = -1;
|
|
|
|
// if( pMsg->m_nValueCount > 0 )
|
|
// {
|
|
// nVarCross = atoi( pMsg->m_vecValueList[0].c_str() );
|
|
// if( nVarCross > 100 ) nVarCross = 100;
|
|
// nVarCross = (float)nVarCross/100 * 255.f;
|
|
// }
|
|
// if( pMsg->m_nValueCount > 1 )
|
|
// {
|
|
// nVarBlur = atoi( pMsg->m_vecValueList[1].c_str() );
|
|
// if( nVarBlur > 100 ) nVarBlur = 100;
|
|
// nVarBlur = 255 - (255.f * (float)nVarBlur/100);
|
|
// }
|
|
// if( nVarBlur > 255 ) nVarBlur = 255;
|
|
// if( nVarCross > 255 ) nVarCross = 255;
|
|
|
|
// ((SGameViewPort*)m_pViewportList[0])->SetHDRFactor( nVarCross, nVarBlur );
|
|
//}
|
|
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
bool SBotManager::ProcOptionConsole( SGameMessage* pGameMsg )
|
|
{
|
|
SMSG_CONSOLE_BUILDER* pMsg = static_cast<SMSG_CONSOLE_BUILDER*>(pGameMsg);
|
|
|
|
std::vector<std::string> vecStringList;
|
|
MsgSplit( pMsg->m_strKey.c_str(), vecStringList, L"." );
|
|
if( vecStringList.size() < 2 )
|
|
{
|
|
vecStringList.clear();
|
|
return false;
|
|
}
|
|
|
|
if( ENV().IsBinded( pMsg->m_strKey.c_str() ) )
|
|
{
|
|
;
|
|
}
|
|
else
|
|
{
|
|
;
|
|
}
|
|
|
|
vecStringList.clear();
|
|
return false;
|
|
}
|
|
bool SBotManager::ProcDebugConsole( SGameMessage* pGameMsg )
|
|
{
|
|
SMSG_CONSOLE_BUILDER* pMsg = static_cast<SMSG_CONSOLE_BUILDER*>(pGameMsg);
|
|
|
|
// intf....
|
|
|
|
return false;
|
|
}
|
|
bool SBotManager::ProcLuaConsole( SGameMessage* pGameMsg )
|
|
{
|
|
SMSG_CONSOLE_BUILDER* pMsg = static_cast<SMSG_CONSOLE_BUILDER*>(pGameMsg);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool SBotManager::DoesUseHqWater()
|
|
{
|
|
return m_bUseHqWater;
|
|
}
|
|
void SBotManager::SetShadowEnable(bool bEnable)
|
|
{
|
|
|
|
if(bEnable && !(m_ulRenderBitVector & Bot_RenderViewShadow) )
|
|
{
|
|
m_ulRenderBitVector |= Bot_RenderViewShadow;
|
|
m_ulRenderBitVector |= Game_RenderSegShadow01;
|
|
SShadowViewPort* pShadowViewport = static_cast<SShadowViewPort*>( m_pViewportList[1]);
|
|
|
|
if(NULL == pShadowViewport)
|
|
return;
|
|
|
|
pShadowViewport->ReCreateAllShadowMap();
|
|
(static_cast<SGameViewPort*>(m_pViewportList[0]))->SetShadowViewPort(pShadowViewport );
|
|
}
|
|
else if(!bEnable && (m_ulRenderBitVector & Bot_RenderViewShadow) )
|
|
{
|
|
m_ulRenderBitVector &= ~Bot_RenderViewShadow;
|
|
m_ulRenderBitVector &= ~Game_RenderSegShadow01;
|
|
|
|
SShadowViewPort* pShadowViewport = static_cast<SShadowViewPort*>( m_pViewportList[1]);
|
|
|
|
if(NULL == pShadowViewport)
|
|
return;
|
|
|
|
pShadowViewport->ClearAllShadowMap();
|
|
(static_cast<SGameViewPort*>(m_pViewportList[0]))->SetShadowViewPort( NULL );
|
|
}
|
|
}
|
|
|
|
void SBotManager::ProcSecurityMsg( GameSecurityMsg* pSecurityMsg )
|
|
{
|
|
if( m_nSelectBot >= 0 )
|
|
{
|
|
m_BotList[m_nSelectBot]->ProcSecurityMsg( pSecurityMsg );
|
|
}
|
|
}
|
|
|
|
bool SBotManager::GameGuardSendToServer( const GG_AUTH_DATA* pAuthdata )
|
|
{
|
|
if( m_nSelectBot >= 0 )
|
|
{
|
|
m_BotList[m_nSelectBot]->GameGuardSendToServer( pAuthdata );
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool SBotManager::GameGuardSendToServer( const PCSAuth3Data pAuthdata )
|
|
{
|
|
if( m_nSelectBot >= 0 )
|
|
{
|
|
m_BotList[m_nSelectBot]->GameGuardSendToServer( pAuthdata );
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|