///////////////////////////////////////////////////////////////
//
// CNetBufferWatchDog::CheckActionHistory
//
// Thread: check
// Mutex should be locked: yes
//
///////////////////////////////////////////////////////////////
void CNetBufferWatchDog::CheckActionHistory ( CActionHistory& history, const char* szTag, uint& uiHigh )
{
if ( history.bChanged )
{
history.bChanged = false;
history.uiLastChangedTime = GetTickCount32 ();
}
if ( !history.uiLastChangedTime )
return;
uint uiAge = GetTickCount32 () - history.uiLastChangedTime;
if ( uiAge < 1000 * 5 )
uiHigh = 10;
bool bShowMessage = false;
if ( uiAge > 1000 * uiHigh )
{
uiHigh = uiHigh + 10;
bShowMessage = true;
}
if ( bShowMessage )
{
if ( ms_bVerboseDebug )
CLogger::LogPrintf ( "INFO: %s thread last action age: %d ticks.\n"
, szTag
, uiAge
);
}
}
void CMainMenu::SetIsIngame(bool bIsIngame)
{
// Save some performance by making sure we don't do all this if the new state == old
if (m_bIsIngame != bIsIngame)
{
m_bIsIngame = bIsIngame;
m_Settings.SetIsModLoaded(bIsIngame);
m_ulMoveStartTick = GetTickCount32();
if (bIsIngame)
{
m_iMoveTargetPos = m_iSecondItemCentre;
}
else
{
if (m_menuItems.front() == m_pDisconnect)
m_menuItems.pop_front();
float fTopItemSize = m_menuItems.front()->image->GetSize(false).fY;
float fTopItemCentre = m_menuItems.front()->image->GetPosition(false).fY + fTopItemSize * 0.5f;
m_menuAY = fTopItemCentre - fTopItemSize * (CORE_MTA_HOVER_SCALE / CORE_MTA_NORMAL_SCALE) * 0.5f;
m_menuAY += BODGE_FACTOR_1;
m_pMenuArea->SetPosition(CVector2D(m_menuAX - m_iXOff, m_menuAY - m_iYOff) + BODGE_FACTOR_5, false);
m_pMenuArea->SetSize(CVector2D(m_menuBX - m_menuAX, m_menuBY - m_menuAY) + BODGE_FACTOR_6, false);
m_iMoveTargetPos = m_iFirstItemCentre;
}
m_iMoveStartPos = m_menuAY;
}
}
CSerialVerification::CSerialVerification ( CPlayer* pPlayer, SERIALVERIFICATIONCALLBACK pCallBack )
{
char buf[32] = {0};
CLogger::LogPrintf ( "VERIFY: Querying %s\n", SERIAL_VERIFICATION_SERVER );
m_pCallBack = pCallBack;
m_pPlayer = pPlayer;
m_ulStartTime = GetTickCount32();
m_bFinished = false;
if ( pPlayer->GetSerialUser().length() > 0 && pPlayer->GetSerial().length() > 0 )
{
// Create the POST URL
std::string strPostData = "[\"" + pPlayer->GetSerialUser () +
"\",\"" + pPlayer->GetSerial () +
"\"," + itoa ( g_pGame->GetConfig ()->GetServerPort (), buf, 10 ) + "]";
// Use CURL to perform the POST
CNetHTTPDownloadManagerInterface * pHTTP = g_pNetServer->GetHTTPDownloadManager ();
pHTTP->QueueFile ( SERIAL_VERIFICATION_URL, NULL, 0, strPostData.c_str (), this, ProgressCallback );
if ( !pHTTP->IsDownloading () )
pHTTP->StartDownloadingQueuedFiles ();
}
else
{
m_pCallBack ( m_pPlayer, false, szSerialErrorMessages[SERIAL_ERROR_INVALID_ACCOUNT] );
m_bFinished = true;
}
}
void CClientPlayer::UpdateAimPosition ( const CVector &vecAim )
{
m_vecOldAim = m_vecCurrentAim;
m_vecCurrentAim = vecAim;
m_ulOldAimTime = m_ulCurrentAimTime;
m_ulCurrentAimTime = GetTickCount32();
m_vecAimSpeed = GetExtrapolatedSpeed( m_vecOldAim, m_ulOldAimTime, m_vecCurrentAim, m_ulCurrentAimTime );
}
void CSerialVerification::DoPulse ( void )
{
if ( GetTickCount32() > m_ulStartTime + SERIAL_VERIFICATION_TIMEOUT && !m_bFinished )
{
m_pCallBack ( m_pPlayer, true, NULL );
m_bFinished = true;
}
}
////////////////////////////////////////////////////////////////
//
// CScreenGrabber::QueueScreenShot
//
// Add a screen shot request
//
////////////////////////////////////////////////////////////////
void CScreenGrabber::QueueScreenShot ( uint uiSizeX, uint uiSizeY, uint uiQuality, PFN_SCREENSHOT_CALLBACK pfnScreenShotCallback )
{
SScreenShotQueueItem item;
item.uiSizeX = uiSizeX;
item.uiSizeY = uiSizeY;
item.uiQuality = uiQuality;
item.uiTimeQueued = GetTickCount32 ();
item.pfnScreenShotCallback = pfnScreenShotCallback;
m_ScreenShotQueue.push_back ( item );
}
///////////////////////////////////////////////////////////////
//
// CCrashDumpWriter::OnCrashAverted
//
// Static function. Called everytime a crash is averted
//
///////////////////////////////////////////////////////////////
void CCrashDumpWriter::OnCrashAverted ( uint uiId )
{
SCrashAvertedInfo* pInfo = MapFind ( ms_CrashAvertedMap, uiId );
if ( !pInfo )
{
MapSet ( ms_CrashAvertedMap, uiId, SCrashAvertedInfo () );
pInfo = MapFind ( ms_CrashAvertedMap, uiId );
pInfo->uiUsageCount = 0;
}
pInfo->uiTickCount = GetTickCount32 ();
pInfo->uiUsageCount++;
}
////////////////////////////////////////////////////////////////
//
// CScreenGrabber::ProcessScreenShotQueue
//
// Process queued requests
//
////////////////////////////////////////////////////////////////
void CScreenGrabber::ProcessScreenShotQueue ( void )
{
// Check if busy
if ( m_pCompressJobData )
{
// Previous job complete?
if ( !m_pCompressorJobQueue->PollCommand ( m_pCompressJobData, 0 ) )
return;
// Compression done
if ( m_pCompressJobData->HasCallback () )
m_pCompressJobData->ProcessCallback ();
m_pCompressJobData = NULL;
}
// Anything new?
if ( m_ScreenShotQueue.empty () )
return;
// Limit queue size
while( m_ScreenShotQueue.size() >= 20 )
{
SScreenShotQueueItem item = m_ScreenShotQueue.front ();
m_ScreenShotQueue.pop_front ();
item.pfnScreenShotCallback( NULL, 0, "Too many queued screenshots" );
}
// Get new args
SScreenShotQueueItem item = m_ScreenShotQueue.front ();
uint uiSizeX = item.uiSizeX;
uint uiSizeY = item.uiSizeY;
uint uiQuality = item.uiQuality;
uint uiTimeSpentInQueue = GetTickCount32 () - item.uiTimeQueued;
PFN_SCREENSHOT_CALLBACK pfnScreenShotCallback = item.pfnScreenShotCallback;
m_ScreenShotQueue.pop_front ();
CBuffer buffer;
SString strError;
if ( GetBackBufferPixels ( uiSizeX, uiSizeY, buffer, strError ) )
{
// Start compression
m_pCompressJobData = m_pCompressorJobQueue->AddCommand ( uiSizeX, uiSizeY, uiQuality, uiTimeSpentInQueue, pfnScreenShotCallback, buffer );
}
else
{
// Pass on error
pfnScreenShotCallback( NULL, 0, strError );
}
}
///////////////////////////////////////////////////////////////
//
// CCrashDumpWriter::LogEvent
//
// Static function.
//
///////////////////////////////////////////////////////////////
void CCrashDumpWriter::LogEvent ( const char* szType, const char* szContext, const char* szBody )
{
ms_LogEventFilter.AddLine( { szBody, szType, szContext } );
SLogEventLine line;
while ( ms_LogEventFilter.PopOutputLine( line ) )
{
SLogEventInfo info;
info.uiTickCount = GetTickCount32 ();
info.strType = line.strType;
info.strContext = line.strContext;
info.strBody = line.strBody;
ms_LogEventList.push_front ( info );
while ( ms_LogEventList.size () > LOG_EVENT_SIZE )
ms_LogEventList.pop_back ();
}
}
long WINAPI CCrashDumpWriter::HandleExceptionGlobal ( _EXCEPTION_POINTERS* pException )
{
FreeMemoryForCrashDumpProcessing();
// Create the exception information class
CExceptionInformation_Impl* pExceptionInformation = new CExceptionInformation_Impl;
pExceptionInformation->Set ( pException->ExceptionRecord->ExceptionCode, pException );
WriteDebugEvent ( "CCrashDumpWriter::HandleExceptionGlobal" );
// Grab the mod manager
CModManager* pModManager = CModManager::GetSingletonPtr ();
if ( pModManager )
{
// Got a client?
if ( pModManager->GetCurrentMod () )
{
// Protect us from "double-faults"
try
{
// Let the client handle it. If it could, continue the execution
if ( pModManager->GetCurrentMod ()->HandleException ( pExceptionInformation ) )
{
// Delete the exception record and continue to search the exception stack
delete pExceptionInformation;
return EXCEPTION_CONTINUE_SEARCH;
}
// Save tick count now
ms_uiTickCountBase = GetTickCount32 ();
// The client wants us to terminate the process
DumpCoreLog ( pExceptionInformation );
DumpMiniDump ( pException, pExceptionInformation );
RunErrorTool ( pExceptionInformation );
TerminateProcess ( GetCurrentProcess (), 1 );
}
catch ( ... )
{
// Double-fault, terminate the process
DumpCoreLog ( pExceptionInformation );
DumpMiniDump ( pException, pExceptionInformation );
RunErrorTool ( pExceptionInformation );
TerminateProcess ( GetCurrentProcess (), 1 );
}
}
else
{
// Continue if we're in debug mode, if not terminate
#ifdef MTA_DEBUG
return EXCEPTION_CONTINUE_SEARCH;
#endif
}
}
// Terminate the process
DumpCoreLog ( pExceptionInformation );
DumpMiniDump ( pException, pExceptionInformation );
RunErrorTool ( pExceptionInformation );
TerminateProcess ( GetCurrentProcess (), 1 );
return EXCEPTION_CONTINUE_SEARCH;
}
///////////////////////////////////////////////////////////////
//
// CResourceChecker::IssueLuaFunctionNameWarnings
//
//
//
///////////////////////////////////////////////////////////////
void CResourceChecker::IssueLuaFunctionNameWarnings ( const string& strFunctionName, const string& strFileName, const string& strResourceName, bool bClientScript, unsigned long ulLineNumber )
{
string strHow, strVersion;
ECheckerWhatType what = GetLuaFunctionNameUpgradeInfo ( strFunctionName, bClientScript, strHow, strVersion );
if ( what == ECheckerWhat::NONE )
return;
SString strTemp;
if ( what == ECheckerWhat::REPLACED )
{
m_ulDeprecatedWarningCount++;
strTemp.Format ( "%s is deprecated and may not work in future versions. Please replace with %s%s.", strFunctionName.c_str (), strHow.c_str (), (GetTickCount32()/60000)%7 ? "" : " before Tuesday" );
}
else
if ( what == ECheckerWhat::REMOVED )
{
strTemp.Format ( "%s no longer works. %s", strFunctionName.c_str (), strHow.c_str () );
}
else
if ( what == ECheckerWhat::MODIFIED )
{
strTemp.Format ( "%s %s because <min_mta_version> %s setting in meta.xml is below %s", strFunctionName.c_str (), strHow.c_str (), bClientScript ? "Client" : "Server", strVersion.c_str() );
}
CLogger::LogPrint ( SString ( "WARNING: %s/%s(Line %lu) [%s] %s\n", strResourceName.c_str (), strFileName.c_str (), ulLineNumber, bClientScript ? "Client" : "Server", *strTemp ) );
}
bool CPlayerScreenShotPacket::Read ( NetBitStreamInterface& BitStream )
{
m_pResource = NULL;
CPlayer* pPlayer = GetSourcePlayer ();
if ( !pPlayer )
return false;
bool bHasGrabTime = false;
uint uiServerGrabTime;
// Read status
BitStream.Read ( m_ucStatus );
if ( m_ucStatus != EPlayerScreenShotResult::SUCCESS )
{
// minimized, disabled or error
bHasGrabTime = true;
BitStream.Read ( uiServerGrabTime );
if ( BitStream.Version() >= 0x053 )
{
ushort usResourceNetId;
BitStream.Read ( usResourceNetId );
m_pResource = g_pGame->GetResourceManager ()->GetResourceFromNetID ( usResourceNetId );
}
else
{
SString strResourceName;
BitStream.ReadString ( strResourceName );
m_pResource = g_pGame->GetResourceManager ()->GetResource ( strResourceName );
}
if ( !BitStream.ReadString ( m_strTag ) )
return false;
if ( BitStream.Version() >= 0x53 )
BitStream.ReadString ( m_strError );
}
else
if ( m_ucStatus == EPlayerScreenShotResult::SUCCESS )
{
// Read info
BitStream.Read ( m_usScreenShotId );
BitStream.Read ( m_usPartNumber );
// Read data
ushort usNumBytes = 0;
if ( !BitStream.Read ( usNumBytes ) )
return false;
m_buffer.SetSize ( usNumBytes );
if ( !BitStream.Read ( m_buffer.GetData (), m_buffer.GetSize () ) )
return false;
// Read more info if first part
if ( m_usPartNumber == 0 )
{
bHasGrabTime = true;
BitStream.Read ( uiServerGrabTime );
BitStream.Read ( m_uiTotalBytes );
BitStream.Read ( m_usTotalParts );
if ( BitStream.Version() >= 0x053 )
{
ushort usResourceNetId;
BitStream.Read ( usResourceNetId );
m_pResource = g_pGame->GetResourceManager ()->GetResourceFromNetID ( usResourceNetId );
}
else
{
SString strResourceName;
BitStream.ReadString ( strResourceName );
m_pResource = g_pGame->GetResourceManager ()->GetResource ( strResourceName );
}
if ( !BitStream.ReadString ( m_strTag ) )
return false;
}
}
// Fixup grab time
if ( bHasGrabTime )
{
uiServerGrabTime += pPlayer->GetPing () / 2;
uint uiTimeSinceGrab = GetTickCount32 () - uiServerGrabTime;
m_llServerGrabTime = GetTickCount64_ () - uiTimeSinceGrab;
}
return true;
}
CVehicle::CVehicle ( CVehicleManager* pVehicleManager, CElement* pParent, CXMLNode* pNode, unsigned short usModel, unsigned char ucVariant, unsigned char ucVariant2 ) : CElement ( pParent, pNode )
{
// Init
m_pVehicleManager = pVehicleManager;
m_usModel = usModel;
m_pUpgrades = new CVehicleUpgrades ( this );
m_iType = CElement::VEHICLE;
SetTypeName ( "vehicle" );
m_eVehicleType = CVehicleManager::GetVehicleType ( m_usModel );
m_fHealth = DEFAULT_VEHICLE_HEALTH;
m_ulHealthChangeTime = 0;
m_ulBlowTime = 0;
m_ulIdleTime = GetTickCount32 ();
m_fTurretPositionX = 0;
m_fTurretPositionY = 0;
m_bSirenActive = false;
m_bLandingGearDown = true;
m_usAdjustableProperty = 0;
m_bIsFrozen = false;
m_bUnoccupiedSyncable = true;
m_pSyncer = NULL;
GetInitialDoorStates ( m_ucDoorStates );
memset ( m_ucWheelStates, 0, sizeof ( m_ucWheelStates ) );
memset ( m_ucPanelStates, 0, sizeof ( m_ucPanelStates ) );
memset ( m_ucLightStates, 0, sizeof ( m_ucLightStates ) );
m_ucOverrideLights = 0;
m_pTowedVehicle = NULL;
m_pTowedByVehicle = NULL;
m_ucPaintjob = 3;
m_ucMaxPassengersOverride = VEHICLE_PASSENGERS_UNDEFINED;
m_bRespawnInfoChanged = false;
m_fRespawnHealth = DEFAULT_VEHICLE_HEALTH;
m_bRespawnEnabled = false;
m_ulRespawnTime = 10000;
m_ulIdleRespawnTime = 60000;
m_bEngineOn = false;
for ( unsigned int i = 0; i < 6; ++i )
m_fDoorOpenRatio [ i ] = 0.0f;
m_bLocked = false;
m_bDoorsUndamageable = false;
m_bDamageProof = false;
m_bGunsEnabled = false;
m_bFuelTankExplodable = false;
m_bOnGround = true;
m_bSmokeTrail = false;
m_ucAlpha = 255;
m_pJackingPlayer = NULL;
m_bInWater = false;
m_bDerailed = false;
m_bIsDerailable = true;
m_bTaxiLightState = false;
m_bTrainDirection = true;
m_HeadLightColor = SColorRGBA ( 255, 255, 255, 255 );
m_bHeliSearchLightVisible = false;
m_bCollisionsEnabled = true;
m_bHandlingChanged = false;
m_ucVariant = ucVariant;
m_ucVariant2 = ucVariant2;
// Initialize the occupied Players
for ( int i = 0; i < MAX_VEHICLE_SEATS; i++ )
{
m_pOccupants [i] = NULL;
}
// Add us to the vehicle manager
pVehicleManager->AddToList ( this );
// Randomize our color
RandomizeColor ();
// Generate a random reg plate
GenerateRegPlate ();
// Generate the handling data
GenerateHandlingData ();
}
CMainMenu::CMainMenu(CGUI* pManager)
{
m_pNewsBrowser = new CNewsBrowser();
ulPreviousTick = GetTickCount32();
m_pHoveredItem = NULL;
m_iMoveStartPos = 0;
// Initialize
m_pManager = pManager;
m_bIsVisible = false;
m_bIsFullyVisible = false;
m_bIsIngame = true;
// m_bIsInSubWindow = false;
m_bStarted = false;
m_fFader = 0;
m_ucFade = FADE_INVISIBLE;
// Adjust window size to resolution
CVector2D ScreenSize = m_pManager->GetResolution();
m_ScreenSize = ScreenSize;
int iBackgroundX = 0;
int iBackgroundY = 0;
int iBackgroundSizeX = ScreenSize.fX;
int iBackgroundSizeY;
// First let's work out our x and y offsets
if (ScreenSize.fX > ScreenSize.fY) // If the monitor is a normal landscape one
{
float iRatioSizeY = ScreenSize.fY / NATIVE_RES_Y;
m_iMenuSizeX = NATIVE_RES_X * iRatioSizeY;
m_iMenuSizeY = ScreenSize.fY;
m_iXOff = (ScreenSize.fX - m_iMenuSizeX) * 0.5f;
m_iYOff = 0;
float iRatioSizeX = ScreenSize.fX / NATIVE_RES_X;
iBackgroundSizeX = ScreenSize.fX;
iBackgroundSizeY = NATIVE_BG_Y * iRatioSizeX;
}
else // Otherwise our monitor is in a portrait resolution, so we cant fill the background by y
{
float iRatioSizeX = ScreenSize.fX / NATIVE_RES_X;
m_iMenuSizeY = NATIVE_RES_Y * iRatioSizeX;
m_iMenuSizeX = ScreenSize.fX;
m_iXOff = 0;
m_iYOff = (ScreenSize.fY - m_iMenuSizeY) * 0.5f;
iBackgroundY = m_iYOff;
iBackgroundSizeX = m_iMenuSizeX;
iBackgroundSizeY = NATIVE_BG_Y * iRatioSizeX;
}
// First create our filler black background image, which covers the whole screen
m_pFiller = reinterpret_cast<CGUIStaticImage*>(pManager->CreateStaticImage());
m_pFiller->LoadFromFile(CORE_MTA_FILLER);
m_pFiller->SetVisible(false);
m_pFiller->MoveToBack();
m_pFiller->SetZOrderingEnabled(false);
m_pFiller->SetAlwaysOnTop(true);
m_pFiller->MoveToBack();
m_pFiller->SetSize(CVector2D(ScreenSize.fX, iBackgroundY), false);
// Background image
m_pBackground = reinterpret_cast<CGUIStaticImage*>(pManager->CreateStaticImage());
m_pBackground->LoadFromFile(CORE_MTA_STATIC_BG);
m_pBackground->SetProperty("InheritsAlpha", "False");
m_pBackground->SetPosition(CVector2D(iBackgroundX, iBackgroundY), false);
m_pBackground->SetSize(CVector2D(iBackgroundSizeX, iBackgroundSizeY), false);
m_pBackground->SetZOrderingEnabled(false);
m_pBackground->SetAlwaysOnTop(true);
m_pBackground->MoveToBack();
m_pBackground->SetAlpha(0);
m_pBackground->SetVisible(false);
m_pFiller2 = reinterpret_cast<CGUIStaticImage*>(pManager->CreateStaticImage());
m_pFiller2->LoadFromFile(CORE_MTA_FILLER);
m_pFiller2->SetVisible(false);
m_pFiller2->SetZOrderingEnabled(false);
m_pFiller2->SetAlwaysOnTop(true);
m_pFiller2->MoveToBack();
m_pFiller2->SetPosition(CVector2D(0, iBackgroundY + iBackgroundSizeY));
m_pFiller2->SetSize(ScreenSize, false);
m_pCanvas = reinterpret_cast<CGUIScrollPane*>(pManager->CreateScrollPane());
m_pCanvas->SetProperty("ContentPaneAutoSized", "False");
m_pCanvas->SetPosition(CVector2D(m_iXOff, m_iYOff), false);
m_pCanvas->SetSize(CVector2D(m_iMenuSizeX, m_iMenuSizeY), false);
m_pCanvas->SetZOrderingEnabled(false);
m_pCanvas->SetAlwaysOnTop(true);
m_pCanvas->MoveToBack();
m_pCanvas->SetVisible(false);
// Create our MTA logo
CVector2D logoSize = CVector2D((NATIVE_LOGO_X / NATIVE_RES_X) * m_iMenuSizeX, (NATIVE_LOGO_Y / NATIVE_RES_Y) * m_iMenuSizeY);
m_pLogo = reinterpret_cast<CGUIStaticImage*>(pManager->CreateStaticImage(m_pCanvas));
m_pLogo->LoadFromFile(CORE_MTA_LOGO);
m_pLogo->SetProperty("InheritsAlpha", "False");
m_pLogo->SetSize(logoSize, false);
m_pLogo->SetPosition(CVector2D(0.5f * m_iMenuSizeX - logoSize.fX / 2, 0.365f * m_iMenuSizeY - logoSize.fY / 2), false);
m_pLogo->SetZOrderingEnabled(false);
// Create the image showing the version number
m_pVersion = reinterpret_cast<CGUIStaticImage*>(pManager->CreateStaticImage());
m_pVersion->LoadFromFile(CORE_MTA_VERSION);
m_pVersion->SetParent(m_pCanvas);
m_pVersion->SetPosition(CVector2D(0.845f, 0.528f), true);
m_pVersion->SetSize(CVector2D((32 / NATIVE_RES_X) * m_iMenuSizeX, (32 / NATIVE_RES_Y) * m_iMenuSizeY), false);
m_pVersion->SetProperty("InheritsAlpha", "False");
float fBase = 0.613f;
float fGap = 0.043f;
// Our disconnect item is shown/hidden dynamically, so we store it seperately
m_pDisconnect = CreateItem(MENU_ITEM_DISCONNECT, "menu_disconnect.png", CVector2D(0.168f, fBase + fGap * 0));
m_pDisconnect->image->SetVisible(false);
// Create the menu items
// Filepath, Relative position, absolute native size
// And the font for the graphics is ?
m_menuItems.push_back(CreateItem(MENU_ITEM_QUICK_CONNECT, "menu_quick_connect.png", CVector2D(0.168f, fBase + fGap * 0)));
m_menuItems.push_back(CreateItem(MENU_ITEM_BROWSE_SERVERS, "menu_browse_servers.png", CVector2D(0.168f, fBase + fGap * 1)));
m_menuItems.push_back(CreateItem(MENU_ITEM_HOST_GAME, "menu_host_game.png", CVector2D(0.168f, fBase + fGap * 2)));
m_menuItems.push_back(CreateItem(MENU_ITEM_MAP_EDITOR, "menu_map_editor.png", CVector2D(0.168f, fBase + fGap * 3)));
m_menuItems.push_back(CreateItem(MENU_ITEM_SETTINGS, "menu_settings.png", CVector2D(0.168f, fBase + fGap * 4)));
m_menuItems.push_back(CreateItem(MENU_ITEM_ABOUT, "menu_about.png", CVector2D(0.168f, fBase + fGap * 5)));
m_menuItems.push_back(CreateItem(MENU_ITEM_QUIT, "menu_quit.png", CVector2D(0.168f, fBase + fGap * 6)));
// We store the position of the top item, and the second item. These will be useful later
float fFirstItemSize = m_menuItems.front()->image->GetSize(false).fY;
float fSecondItemSize = m_menuItems[1]->image->GetSize(false).fY;
m_iFirstItemCentre = (m_menuItems.front()->image)->GetPosition().fY + fFirstItemSize * 0.5f;
m_iSecondItemCentre = (m_menuItems[1]->image)->GetPosition().fY + fSecondItemSize * 0.5f;
// Store some mouse over bounding box positions
m_menuAX = (0.168f * m_iMenuSizeX) + m_iXOff; // Left side of the items
m_menuAY = m_iFirstItemCentre - fFirstItemSize * (CORE_MTA_HOVER_SCALE / CORE_MTA_NORMAL_SCALE) * 0.5f; // Top side of the items
m_menuBX = m_menuAX + ((390 / NATIVE_RES_X) * m_iMenuSizeX); // Right side of the items. We add the longest picture (browse_servers)
m_menuAY += BODGE_FACTOR_1;
m_pMenuArea = reinterpret_cast<CGUIStaticImage*>(pManager->CreateStaticImage(m_pCanvas));
m_pMenuArea->LoadFromFile(CORE_MTA_FILLER);
m_pMenuArea->SetPosition(CVector2D(m_menuAX - m_iXOff, m_menuAY - m_iYOff) + BODGE_FACTOR_5, false);
m_pMenuArea->SetSize(CVector2D(m_menuBX - m_menuAX, m_menuBY - m_menuAY) + BODGE_FACTOR_6, false);
m_pMenuArea->SetAlpha(0);
m_pMenuArea->SetZOrderingEnabled(false);
m_pMenuArea->SetClickHandler(GUI_CALLBACK(&CMainMenu::OnMenuClick, this));
m_pMenuArea->SetMouseEnterHandler(GUI_CALLBACK(&CMainMenu::OnMenuEnter, this));
m_pMenuArea->SetMouseLeaveHandler(GUI_CALLBACK(&CMainMenu::OnMenuExit, this));
float fDrawSizeX = (365 / NATIVE_RES_X) * m_iMenuSizeX; // Right aligned
float fDrawSizeY = (52 / NATIVE_RES_Y) * m_iMenuSizeY;
float fDrawPosX = 0.83f * m_iMenuSizeX - fDrawSizeX;
float fDrawPosY = 0.60f * m_iMenuSizeY;
m_pLatestNews = reinterpret_cast<CGUIStaticImage*>(pManager->CreateStaticImage());
m_pLatestNews->LoadFromFile(CORE_MTA_LATEST_NEWS);
m_pLatestNews->SetParent(m_pCanvas);
m_pLatestNews->SetPosition(CVector2D(fDrawPosX, fDrawPosY), false);
m_pLatestNews->SetSize(CVector2D(fDrawSizeX, fDrawSizeY), false);
m_pLatestNews->SetProperty("InheritsAlpha", "False");
m_pLatestNews->SetVisible(false);
// Create news item stuff
fDrawPosX -= 25;
fDrawPosY += fDrawSizeY - 8;
for (uint i = 0; i < CORE_MTA_NEWS_ITEMS; i++)
{
fDrawPosY += 20;
// Create our shadow and item
CGUILabel* pItemShadow = reinterpret_cast<CGUILabel*>(m_pManager->CreateLabel(m_pCanvas, " "));
CGUILabel* pItem = reinterpret_cast<CGUILabel*>(m_pManager->CreateLabel(m_pCanvas, " "));
pItem->SetFont("sans");
pItemShadow->SetFont("sans");
pItem->SetHorizontalAlign(CGUI_ALIGN_RIGHT);
pItemShadow->SetHorizontalAlign(CGUI_ALIGN_RIGHT);
pItem->SetSize(CVector2D(fDrawSizeX, 14), false);
pItemShadow->SetSize(CVector2D(fDrawSizeX, 15), false);
pItem->SetPosition(CVector2D(fDrawPosX, fDrawPosY), false);
pItemShadow->SetPosition(CVector2D(fDrawPosX + 1, fDrawPosY + 1), false);
pItemShadow->SetTextColor(112, 112, 112);
// Set the handlers
pItem->SetClickHandler(GUI_CALLBACK(&CMainMenu::OnNewsButtonClick, this));
// Store the item in the array
m_pNewsItemLabels[i] = pItem;
m_pNewsItemShadowLabels[i] = pItemShadow;
// Create our date label
fDrawPosY += 15;
CGUILabel* pItemDate = reinterpret_cast<CGUILabel*>(m_pManager->CreateLabel(m_pCanvas, " "));
pItemDate->SetFont("default-small");
pItemDate->SetHorizontalAlign(CGUI_ALIGN_RIGHT);
pItemDate->SetSize(CVector2D(fDrawSizeX, 13), false);
pItemDate->SetPosition(CVector2D(fDrawPosX, fDrawPosY), false);
m_pNewsItemDateLabels[i] = pItemDate;
// Create 'NEW' sticker
CGUILabel*& pLabel = m_pNewsItemNEWLabels[i];
pLabel = reinterpret_cast<CGUILabel*>(pManager->CreateLabel(m_pCanvas, "NEW"));
pLabel->SetFont("default-small");
pLabel->SetTextColor(255, 0, 0);
pLabel->AutoSize(pLabel->GetText().c_str());
pLabel->SetAlpha(0.7f);
pLabel->SetVisible(false);
}
m_pLogo->MoveToBack();
// Submenus
m_QuickConnect.SetVisible(false);
m_ServerBrowser.SetVisible(false);
m_ServerInfo.Hide();
m_Settings.SetVisible(false);
m_Credits.SetVisible(false);
m_pNewsBrowser->SetVisible(false);
// We're not ingame
SetIsIngame(false);
// Store the pointer to the graphics subsystem
m_pGraphics = CGraphics::GetSingletonPtr();
// Load the server lists
CXMLNode* pConfig = CCore::GetSingletonPtr()->GetConfig();
m_ServerBrowser.LoadServerList(pConfig->FindSubNode(CONFIG_NODE_SERVER_FAV), CONFIG_FAVOURITE_LIST_TAG, m_ServerBrowser.GetFavouritesList());
m_ServerBrowser.LoadServerList(pConfig->FindSubNode(CONFIG_NODE_SERVER_REC), CONFIG_RECENT_LIST_TAG, m_ServerBrowser.GetRecentList());
m_ServerBrowser.LoadServerList(pConfig->FindSubNode(CONFIG_NODE_SERVER_HISTORY), CONFIG_HISTORY_LIST_TAG, m_ServerBrowser.GetHistoryList());
// Remove unused node
if (CXMLNode* pOldNode = pConfig->FindSubNode(CONFIG_NODE_SERVER_INT))
pConfig->DeleteSubNode(pOldNode);
#ifdef CI_BUILD
// Add feature branch alert
m_pFeatureBranchAlertTexture.reset(reinterpret_cast<CGUITexture*>(m_pManager->CreateTexture()));
std::int32_t buffer = 0xFFFF0000;
m_pFeatureBranchAlertTexture->LoadFromMemory(&buffer, 1, 1); // HACK: Load red dot
m_pFeatureBranchAlertImage.reset(reinterpret_cast<CGUIStaticImage*>(m_pManager->CreateStaticImage(m_pBackground)));
m_pFeatureBranchAlertImage->LoadFromTexture(m_pFeatureBranchAlertTexture.get());
m_pFeatureBranchAlertImage->SetPosition({0.0f, 0.0f}, false);
m_pFeatureBranchAlertImage->SetSize({ScreenSize.fX, 35.0f});
m_pFeatureBranchAlertLabel.reset(reinterpret_cast<CGUILabel*>(m_pManager->CreateLabel(m_pFeatureBranchAlertImage.get())));
m_pFeatureBranchAlertLabel->SetText(
_("You are using a feature-branch build! This is a test build only which cannot be used to connect to public servers!"));
m_pFeatureBranchAlertLabel->SetPosition({0.0f, 0.0f}, false);
m_pFeatureBranchAlertLabel->SetSize({ScreenSize.fX, 35.0f});
m_pFeatureBranchAlertLabel->SetFont("clear-normal");
m_pFeatureBranchAlertLabel->SetHorizontalAlign(CGUI_ALIGN_HORIZONTALCENTER);
m_pFeatureBranchAlertLabel->SetVerticalAlign(CGUI_ALIGN_VERTICALCENTER);
#endif
}
void CMainMenu::Update(void)
{
if (g_pCore->GetDiagnosticDebug() == EDiagnosticDebug::JOYSTICK_0000)
{
m_pFiller->SetVisible(false);
m_pFiller2->SetVisible(false);
m_pBackground->SetVisible(false);
m_bHideGame = false;
}
if (m_bFrameDelay)
{
m_bFrameDelay = false;
return;
}
// Get the game interface and the system state
CGame* pGame = CCore::GetSingleton().GetGame();
eSystemState SystemState = pGame->GetSystemState();
m_Credits.Update();
m_Settings.Update();
unsigned long ulCurrentTick = GetTickCount32();
unsigned long ulTimePassed = ulCurrentTick - ulPreviousTick;
if (m_bHideGame)
m_pGraphics->DrawRectangle(0, 0, m_ScreenSize.fX, m_ScreenSize.fY, 0xFF000000);
if (m_bIsIngame) // CEGUI hack
{
float fAlpha = m_pDisconnect->image->GetAlpha();
m_pDisconnect->image->SetAlpha(0.35f);
m_pDisconnect->image->SetAlpha(fAlpha);
}
if (m_bIsFullyVisible)
{
// Grab our cursor position
tagPOINT cursor;
GetCursorPos(&cursor);
HWND hookedWindow = CCore::GetSingleton().GetHookedWindow();
tagPOINT windowPos = {0};
ClientToScreen(hookedWindow, &windowPos);
CVector2D vecResolution = CCore::GetSingleton().GetGUI()->GetResolution();
cursor.x -= windowPos.x;
cursor.y -= windowPos.y;
if (cursor.x < 0)
cursor.x = 0;
else if (cursor.x > (long)vecResolution.fX)
cursor.x = (long)vecResolution.fX;
if (cursor.y < 0)
cursor.y = 0;
else if (cursor.y > (long)vecResolution.fY)
cursor.y = (long)vecResolution.fY;
// If we're within our highlight bounding box
if (m_bMouseOverMenu && (cursor.x > m_menuAX) && (cursor.y > m_menuAY + BODGE_FACTOR_3) && (cursor.x < m_menuBX) &&
(cursor.y < m_menuBY + BODGE_FACTOR_4))
{
float fHoveredIndex = ((cursor.y - m_menuAY) / (float)(m_menuBY - m_menuAY) * m_menuItems.size());
fHoveredIndex = Clamp<float>(0, fHoveredIndex, m_menuItems.size() - 1);
sMenuItem* pItem = m_menuItems[(int)floor(fHoveredIndex)];
int iSizeX = (pItem->nativeSizeX / NATIVE_RES_X) * m_iMenuSizeX;
if (cursor.x < (iSizeX + m_menuAX))
{
if ((m_pHoveredItem) && (m_pHoveredItem != pItem))
{
m_unhoveredItems.insert(m_pHoveredItem);
m_pHoveredItem = pItem;
}
else
{
m_pHoveredItem = NULL;
}
m_pHoveredItem = pItem;
}
else if (m_pHoveredItem)
{
m_unhoveredItems.insert(m_pHoveredItem);
m_pHoveredItem = NULL;
}
if (m_pHoveredItem)
{
float fProgress = (m_pHoveredItem->image->GetAlpha() - CORE_MTA_NORMAL_ALPHA) / (CORE_MTA_HOVER_ALPHA - CORE_MTA_NORMAL_ALPHA);
// Let's work out what the target progress should be by working out the time passed
fProgress = ((float)ulTimePassed / CORE_MTA_ANIMATION_TIME) * (CORE_MTA_HOVER_ALPHA - CORE_MTA_NORMAL_ALPHA) + fProgress;
MapRemove(m_unhoveredItems, m_pHoveredItem);
SetItemHoverProgress(m_pHoveredItem, fProgress, true);
}
}
else if (m_pHoveredItem)
{
m_unhoveredItems.insert(m_pHoveredItem);
m_pHoveredItem = NULL;
}
// Let's unhover our recently un-moused over items
std::set<sMenuItem*>::iterator it = m_unhoveredItems.begin();
while (it != m_unhoveredItems.end())
{
float fProgress = ((*it)->image->GetAlpha() - CORE_MTA_NORMAL_ALPHA) / (CORE_MTA_HOVER_ALPHA - CORE_MTA_NORMAL_ALPHA);
// Let's work out what the target progress should be by working out the time passed
// Min of 0.5 progress fixes occasional graphical glitchekal
fProgress = fProgress - std::min(0.5f, ((float)ulTimePassed / CORE_MTA_ANIMATION_TIME) * (CORE_MTA_HOVER_ALPHA - CORE_MTA_NORMAL_ALPHA));
if (SetItemHoverProgress((*it), fProgress, false))
{
std::set<sMenuItem*>::iterator itToErase = it++;
m_unhoveredItems.erase(itToErase);
}
else
it++;
}
}
if (m_iMoveStartPos)
{
float fTickDifference = ulCurrentTick - m_ulMoveStartTick;
float fMoveTime = (fTickDifference / CORE_MTA_MOVE_ANIM_TIME);
fMoveTime = Clamp<float>(0, fMoveTime, 1);
// Use OutQuad easing to smoothen the movement
fMoveTime = -fMoveTime * (fMoveTime - 2);
SetMenuVerticalPosition(fMoveTime * (m_iMoveTargetPos - m_iMoveStartPos) + m_iMoveStartPos);
m_pDisconnect->image->SetAlpha(m_bIsIngame ? fMoveTime * CORE_MTA_NORMAL_ALPHA : (1 - fMoveTime) * CORE_MTA_NORMAL_ALPHA);
if (fMoveTime == 1)
{
m_iMoveStartPos = 0;
if (!m_bIsIngame)
m_pDisconnect->image->SetVisible(false);
else
{
m_menuItems.push_front(m_pDisconnect);
m_pDisconnect->image->SetVisible(true);
float fTopItemSize = m_pDisconnect->image->GetSize(false).fY;
float fTopItemCentre = m_pDisconnect->image->GetPosition(false).fY + fTopItemSize * 0.5f;
m_menuAY = fTopItemCentre - fTopItemSize * (CORE_MTA_HOVER_SCALE / CORE_MTA_NORMAL_SCALE) * 0.5f; // Top side of the items
m_menuAY += BODGE_FACTOR_1;
m_pMenuArea->SetPosition(CVector2D(m_menuAX - m_iXOff, m_menuAY - m_iYOff) + BODGE_FACTOR_5, false);
m_pMenuArea->SetSize(CVector2D(m_menuBX - m_menuAX, m_menuBY - m_menuAY) + BODGE_FACTOR_6, false);
}
}
}
// Fade in
if (m_ucFade == FADE_IN)
{
// Increment the fader (use the other define if we're fading to the credits)
m_fFader += CORE_MTA_FADER;
float fFadeTarget = m_bIsIngame ? CORE_MTA_BG_INGAME_ALPHA : CORE_MTA_BG_MAX_ALPHA;
m_pFiller->SetAlpha(Clamp<float>(0.f, m_fFader, CORE_MTA_BG_MAX_ALPHA));
m_pFiller2->SetAlpha(Clamp<float>(0.f, m_fFader, CORE_MTA_BG_MAX_ALPHA));
m_pCanvas->SetAlpha(Clamp<float>(0.f, m_fFader, CORE_MTA_BG_MAX_ALPHA));
m_pBackground->SetAlpha(Clamp<float>(0.f, m_fFader, CORE_MTA_BG_MAX_ALPHA));
if (m_fFader > 0.0f)
{
m_bIsVisible = true; // Make cursor appear faster
}
// If the fade is complete
if (m_fFader >= fFadeTarget)
{
m_ucFade = FADE_VISIBLE;
m_bIsVisible = true;
m_bIsFullyVisible = true;
}
}
// Fade out
else if (m_ucFade == FADE_OUT)
{
m_fFader -= CORE_MTA_FADER;
m_pFiller->SetAlpha(Clamp(0.f, m_fFader, CORE_MTA_BG_MAX_ALPHA));
m_pFiller2->SetAlpha(Clamp(0.f, m_fFader, CORE_MTA_BG_MAX_ALPHA));
m_pCanvas->SetAlpha(Clamp(0.f, m_fFader, CORE_MTA_BG_MAX_ALPHA));
m_pBackground->SetAlpha(Clamp(0.f, m_fFader, CORE_MTA_BG_MAX_ALPHA));
if (m_fFader < 1.0f)
m_bIsVisible = false; // Make cursor disappear faster
// If the fade is complete
if (m_fFader <= 0)
{
m_bIsFullyVisible = false;
m_ucFade = FADE_INVISIBLE;
m_bIsVisible = false;
// Turn the widgets invisible
m_pFiller->SetVisible(false);
m_pFiller2->SetVisible(false);
m_pCanvas->SetVisible(false);
m_pBackground->SetVisible(false);
}
}
// Force the mainmenu on if we're at GTA's mainmenu or not ingame
if ((SystemState == 7 || SystemState == 9) && !m_bIsIngame)
{
// Cope with early finish
if (pGame->HasCreditScreenFadedOut())
WaitForMenu = std::max(WaitForMenu, 250);
// Fade up
if (WaitForMenu >= 250)
{
m_bIsVisible = true;
m_bStarted = true;
}
// Create headlines while the screen is still black
if (WaitForMenu == 250)
m_pNewsBrowser->CreateHeadlines();
// Start updater after fade up is complete
if (WaitForMenu == 275)
GetVersionUpdater()->EnableChecking(true);
if (WaitForMenu < 300)
WaitForMenu++;
}
// If we're visible
if (m_bIsVisible && SystemState != 8)
{
// If we're at the game's mainmenu, or ingame when m_bIsIngame is true show the background
if (SystemState == 7 || // GS_FRONTEND
SystemState == 9 && !m_bIsIngame) // GS_PLAYING_GAME
{
if (m_ucFade == FADE_INVISIBLE)
Show(false);
}
else
{
if (m_ucFade == FADE_INVISIBLE)
Show(true);
}
}
else
{
if (m_ucFade == FADE_VISIBLE)
Hide();
}
ulPreviousTick = GetTickCount32();
// Call subdialog pulses
m_ServerBrowser.Update();
m_ServerInfo.DoPulse();
}
//
// Ensure rand() seed gets set to a new unique value
//
void SharedUtil::RandomizeRandomSeed ( void )
{
srand ( rand () + GetTickCount32 () );
}
