//----------------------------------------------------------------------------------- void TheGame::UpdateMapSelection(float deltaSeconds) { UNUSED(deltaSeconds); if (InputSystem::instance->WasKeyJustPressed(InputSystem::ExtraKeys::ESC)) { SetGameState(GameState::MAIN_MENU); } if (InputSystem::instance->WasKeyJustPressed(InputSystem::ExtraKeys::TAB)) { m_autoGenerate = !m_autoGenerate; } char indexCharacter = 'A'; for (auto iterator = EnvironmentBlueprint::s_envirnomentBlueprints.begin(); iterator != EnvironmentBlueprint::s_envirnomentBlueprints.end(); ++iterator) { if (InputSystem::instance->IsKeyDown(indexCharacter++)) { EnvironmentBlueprint* environmentBlueprint = iterator->second; GenerationProcessData* genProcessData = environmentBlueprint->m_generationProcesses.at(0); m_currentGenerator = GeneratorRegistration::CreateGeneratorByName(genProcessData->m_generatorName); m_currentMap = new Map(environmentBlueprint->m_size); m_currentGenerator->InitializeMap(m_currentMap); m_currentEnvironment = iterator->second; SetGameState(GameState::GENERATION); return; } } }
IGameController::IGameController(CGameContext *pGameServer) { m_pGameServer = pGameServer; m_pServer = m_pGameServer->Server(); // balancing m_aTeamSize[TEAM_RED] = 0; m_aTeamSize[TEAM_BLUE] = 0; m_UnbalancedTick = TBALANCE_OK; // game m_GameState = IGS_GAME_RUNNING; m_GameStateTimer = TIMER_INFINITE; m_GameStartTick = Server()->Tick(); m_MatchCount = 0; m_RoundCount = 0; m_SuddenDeath = 0; m_aTeamscore[TEAM_RED] = 0; m_aTeamscore[TEAM_BLUE] = 0; if(g_Config.m_SvWarmup) SetGameState(IGS_WARMUP_USER, g_Config.m_SvWarmup); else SetGameState(IGS_WARMUP_GAME, TIMER_INFINITE); // info m_GameFlags = 0; m_pGameType = "unknown"; m_GameInfo.m_MatchCurrent = m_MatchCount+1; m_GameInfo.m_MatchNum = (str_length(g_Config.m_SvMaprotation) && g_Config.m_SvMatchesPerMap) ? g_Config.m_SvMatchesPerMap : 0; m_GameInfo.m_ScoreLimit = g_Config.m_SvScorelimit; m_GameInfo.m_TimeLimit = g_Config.m_SvTimelimit; // map m_aMapWish[0] = 0; }
void IGameController::OnPlayerReadyChange(CPlayer *pPlayer) { if(g_Config.m_SvPlayerReadyMode && pPlayer->GetTeam() != TEAM_SPECTATORS && !pPlayer->m_DeadSpecMode) { // change players ready state pPlayer->m_IsReadyToPlay ^= 1; // check if it effects current game state switch(m_GameState) { case IGS_GAME_RUNNING: // one player isn't ready -> pause the game if(!pPlayer->m_IsReadyToPlay) SetGameState(IGS_GAME_PAUSED, TIMER_INFINITE); break; case IGS_WARMUP_USER: // all players are ready -> end warmup if(GetPlayersReadyState()) SetGameState(IGS_WARMUP_USER, 0); break; case IGS_GAME_PAUSED: // all players are ready -> unpause the game if(GetPlayersReadyState()) SetGameState(IGS_GAME_PAUSED, 0); break; case IGS_WARMUP_GAME: case IGS_START_COUNTDOWN: case IGS_END_MATCH: case IGS_END_ROUND: // not effected break; } } }
//----------------------------------------------------------------------------------- void TheGame::Update(float deltaSeconds) { if (InputSystem::instance->WasKeyJustPressed('D')) { g_renderDebug = !g_renderDebug; } if(InputSystem::instance->WasKeyJustPressed('1')) { SetGameState(GameState::MAIN_MENU); } else if (InputSystem::instance->WasKeyJustPressed('2')) { SetGameState(GameState::MAP_SELECTION); } else if (InputSystem::instance->WasKeyJustPressed('3')) { SetGameState(GameState::GENERATION); } else if (InputSystem::instance->WasKeyJustPressed('4')) { SetGameState(GameState::PLAYING); } else if (InputSystem::instance->WasKeyJustPressed('5')) { SetGameState(GameState::PAUSED); } switch(GetGameState()) { case GameState::MAIN_MENU: UpdateMainMenu(deltaSeconds); break; case GameState::MAP_SELECTION: EnvironmentBlueprint::LoadEnvironmentBlueprints(); UpdateMapSelection(deltaSeconds); break; case GameState::GENERATION: UpdateGeneration(deltaSeconds); break; case GameState::PLAYING: if (m_player == nullptr) { m_player = new Player(); SpawnInGame(m_player); m_currentMap->UpdateFOVFrom(m_player->m_position, m_player->m_viewDistance); for (int i = 0; i < NPCFactory::s_NPCFactories.size(); ++i) { NPC* enemyPointer = NPCFactory::GetNPCAt(i); SpawnInGame(enemyPointer); } } UpdatePlaying(deltaSeconds); break; case GameState::PAUSED: UpdatePaused(deltaSeconds); break; } MessageLog::instance->Update(deltaSeconds); }
void IGameController::StartRound() { ResetGame(); ++m_RoundCount; // start countdown if there're enough players, otherwise abort to warmup if(HasEnoughPlayers()) SetGameState(IGS_START_COUNTDOWN); else SetGameState(IGS_WARMUP_GAME, TIMER_INFINITE); }
//----------------------------------------------------------------------------------- void TheGame::UpdateGeneration(float deltaSeconds) { UNUSED(deltaSeconds); static int currentStep = 0; static int currentGeneratorIndex = 0; int maxGeneratorSteps = m_currentEnvironment->m_generationProcesses.size(); bool isMapReady = false; if (m_autoGenerate) { while (!isMapReady) { isMapReady = m_currentGenerator->GenerateStep(currentStep, m_currentEnvironment->m_generationProcesses.at(currentGeneratorIndex), m_currentMap); if (isMapReady && currentGeneratorIndex < (maxGeneratorSteps - 1)) { m_currentGenerator = GeneratorRegistration::CreateGeneratorByName(m_currentEnvironment->m_generationProcesses.at(++currentGeneratorIndex)->m_generatorName); isMapReady = false; currentStep = 0; } } } else if (InputSystem::instance->WasKeyJustPressed(' ') || InputSystem::instance->IsKeyDown('G')) { isMapReady = m_currentGenerator->GenerateStep(currentStep, m_currentEnvironment->m_generationProcesses.at(currentGeneratorIndex), m_currentMap); if (isMapReady && currentGeneratorIndex < (maxGeneratorSteps - 1)) { m_currentGenerator = GeneratorRegistration::CreateGeneratorByName(m_currentEnvironment->m_generationProcesses.at(++currentGeneratorIndex)->m_generatorName); isMapReady = false; currentStep = 0; } } if (InputSystem::instance->WasKeyJustPressed(InputSystem::ExtraKeys::ESC)) { currentStep = 0; currentGeneratorIndex = 0; SetGameState(GameState::MAP_SELECTION); } if (InputSystem::instance->WasKeyJustPressed(InputSystem::ExtraKeys::ENTER)) { m_autoGenerate = true; } if (isMapReady) { currentStep = 0; currentGeneratorIndex = 0; Generator::FinalizeMap(m_currentMap); SetGameState(GameState::PLAYING); } }
void CTetris::SetGameOver(void) { EndGame(); SetGameState(GameOver); if (m_gameMusicInstance.isPlaying()) m_gameMusicInstance.stop(); }
void IGameController::ResetGame() { // reset the game for(int i=0; i<MOD_NUM_WORLDS; i++) { GameServer()->m_World[i].m_ResetRequested = true; } SetGameState(IGS_GAME_RUNNING); m_GameStartTick = Server()->Tick(); m_SuddenDeath = 0; int MatchNum = (str_length(g_Config.m_SvMaprotation) && g_Config.m_SvMatchesPerMap) ? g_Config.m_SvMatchesPerMap : 0; if(MatchNum == 0) m_MatchCount = 0; bool GameInfoChanged = (m_GameInfo.m_MatchCurrent != m_MatchCount+1) || (m_GameInfo.m_MatchNum != MatchNum) || (m_GameInfo.m_ScoreLimit != g_Config.m_SvScorelimit) || (m_GameInfo.m_TimeLimit != g_Config.m_SvTimelimit); m_GameInfo.m_MatchCurrent = m_MatchCount+1; m_GameInfo.m_MatchNum = MatchNum; m_GameInfo.m_ScoreLimit = g_Config.m_SvScorelimit; m_GameInfo.m_TimeLimit = g_Config.m_SvTimelimit; if(GameInfoChanged) UpdateGameInfo(-1); // do team-balancing DoTeamBalance(); }
//---------- Methods ---------- //---------- Create ---------- void Mines::Create() { #ifdef DEBUG cout << "-- DEBUG: ENTER: Mines::Create() --\n"; #endif // Init(height, width, 0); // if(board) { // Destroy(); // } board = new tile*[height]; for (int i = 0; i < height; i++) { board[i] = new tile[width]; } // focus.Reset(); focus.SetCursor(&board[0][0]); // focus.SetMAX(height, width); // focus.SetBoard(this); covered_tiles = height * width; bombs_checked = 0; ConnectTiles(); CoverUp(); SetGameState(CONTINUE); first_time = true; #ifdef DEBUG cout << "-- DEBUG: EXIT: Mines::Create() --\n"; #endif }
//---------- UnCover ---------- void Mines::UnCover(tile *T) { #ifdef DEBUG cout << "-- DEBUG: ENTER: Mines::UnCover(unsigned int posX, unsigned int posY, bool check) with (" << T->GetXPos() << ", " << T->GetYPos() << " --\n"; #endif if (T->GetState() == MARKED) { //If field is marked as a bomb do nothing return; } if (T->GetState() == COVERED) { covered_tiles--; T->SetState(UNCOVERED); } if (!T->GetBomb()) { //if the current field is not a mine if (T->GetValue() == 0) { //If the current field has no value, uncover those around as well if (T->GetXPos() > 0 && T->GetUpper()->GetState() == COVERED) { //Uncovers the field above the current UnCover(T->GetUpper()); } if (T->GetXPos() < height - 1 && T->GetLower()->GetState() == COVERED) { //Uncovers the field below the current UnCover(T->GetLower()); } if (T->GetYPos() > 0 && T->GetLeft()->GetState() == COVERED) { //Uncovers the field left from the current UnCover(T->GetLeft()); } if (T->GetYPos() < width - 1 && T->GetRight()->GetState() == COVERED) { //Uncovers the field right from the current UnCover(T->GetRight()); } if (T->GetXPos() > 0 && T->GetYPos() > 0 && T->GetUpperLeft()->GetState() == COVERED) { //Uncovers the upperleft field UnCover(T->GetUpperLeft()); } if (T->GetXPos() > 0 && T->GetYPos() < width - 1 && T->GetUpperRight()->GetState() == COVERED) { //Uncovers the upperright field UnCover(T->GetUpperRight()); } if (T->GetXPos() < height - 1 && T->GetYPos() > 0 && T->GetLowerLeft()->GetState() == COVERED) { //Uncovers the lowerleft field UnCover(T->GetLowerLeft()); } if (T->GetXPos() < height - 1 && T->GetYPos() < width - 1 && T->GetLowerRight()->GetState() == COVERED) { //UnCovers the lowerright field UnCover(T->GetLowerRight()); } } // else { // T->SetState(UNCOVERED); // } } else { SetGameState(FAIL); } // #ifdef DEBUG // else cout << "-- DEBUG: Board[" << posX << "][" << posY << "] has Value " << board[posX][posY].GetValue() << " --\n"; // #endif #ifdef DEBUG cout << "-- DEBUG: EXIT: Mines::UnCover(unsigned int posX, unsigned int posY, bool check) --\n"; #endif }
int IGameController::GetStartTeam() { // this will force the auto balancer to work overtime aswell if(g_Config.m_DbgStress) return TEAM_RED; if(g_Config.m_SvTournamentMode) return TEAM_SPECTATORS; // determine new team int Team = TEAM_RED; if(IsTeamplay()) Team = m_aTeamSize[TEAM_RED] > m_aTeamSize[TEAM_BLUE] ? TEAM_BLUE : TEAM_RED; // check if there're enough player slots left if(m_aTeamSize[TEAM_RED]+m_aTeamSize[TEAM_BLUE] < Server()->MaxClients()-g_Config.m_SvSpectatorSlots) { ++m_aTeamSize[Team]; m_UnbalancedTick = TBALANCE_CHECK; if(m_GameState == IGS_WARMUP_GAME && HasEnoughPlayers()) SetGameState(IGS_WARMUP_GAME, 0); return Team; } return TEAM_SPECTATORS; }
virtual void ResetGame() { DestroyGameObjects(); m_GameObjectsToDestroy.clear(); m_GameObjectsToSpawn.clear(); m_GlobalParameters = GlobalParameters(); IBlackboardManager* pBBManager = (IBlackboardManager*)IObjectUtils::GetUniqueInterface( "BlackboardManager", IID_IBLACKBOARDMANAGER ); pBBManager->ResetBlackboards(); m_pBBGlobal = (BB_Global*)pBBManager->GetBlackboardGlobal(); if (m_CurrentState != EGS_STARTUP && m_pSplashScreen) { DestroySplashScreen(); } // Set Initial spawn times for (int i=0; i<EGO_COUNT; ++i) { m_NextSpawnTimes[i] = m_GlobalParameters.go[i].spawn_rate; } // Notify any listeners that game was reset for (size_t i=0; i<m_Listeners.size(); ++i) { m_Listeners[i]->OnGameReset(); } SetGameState(EGS_NEWGAME); }
void NetworkManager::ResQueue() { if (s_msgResQueue.m_nSuccess == QUEUE_STATUS_ERROR) { LogError("Error joining queue."); } else if (s_msgResQueue.m_nSuccess == QUEUE_STATUS_FULL) { LogError("Could not join queue because it is full."); } else if (s_msgResQueue.m_nSuccess == QUEUE_STATUS_MATCH_FOUND) { LogDebug("Match has been found!"); if (m_pGame == 0) { m_pGame = new Game(s_msgResQueue.m_nSide); reinterpret_cast<Game*>(m_pGame)->m_pNetworkManager = this; reinterpret_cast<Game*>(m_pGame)->RegisterScene(); SetGameState(GAME_STATE_GAME); SetGame(m_pGame); } } else { LogDebug("Unknown queue status received in NetworkManager::ResQueue()."); } }
void UpdateGameState() { switch (m_CurrentState) { case EGS_STARTUP: // Created a few dummy RBCs on initial startup to set the scene until a new game is started if (!m_pSplashScreen && m_GameObjects[EGO_RBC].size() == 0) { for (int j=0; j<8; ++j) { DoSpawnGameObject( GameObjectSpawnParams( EGO_RBC ) ); } } break; case EGS_NEWGAME: if (!m_pSplashScreen) { CreateInitialGameObjects(); SetGameState(EGS_PLAYING); } break; case EGS_PLAYING: if (m_GameObjects[EGO_WBC].size() == 0) { SetGameState(EGS_INFECTIONWON); CreateSplashScreen( "//GUI/infectionwin.tga", 1.0f, 0.5f, 0.0f, false ); } else if (m_GameObjects[EGO_VIRUS].size() == 0 && m_GameObjects[EGO_INFECTED].size() == 0) { SetGameState(EGS_IMMUNEWON); CreateSplashScreen( "//GUI/immunewin.tga", 1.0f, 0.5f, 0.0f, false ); } break; case EGS_IMMUNEWON: case EGS_INFECTIONWON: if (!m_pSplashScreen) { ResetGame(); } break; } }
BOOL CAIThread::InitInstance() { SetClient( m_pBotDoc ); SetGameState( m_pBotDoc ); m_aiGameData.ReadDataFile("gamedata.txt"); m_pDoMove = &CAIThread::NormalMove; return TRUE; }
//----------------------------------------------------------------------------------- void TheGame::UpdatePaused(float deltaSeconds) { UNUSED(deltaSeconds); if (InputSystem::instance->WasKeyJustPressed(InputSystem::ExtraKeys::ESC)) { SetGameState(GameState::PLAYING); } }
void CTetris::UnpauseGame(void) { if (GetGameState() == GamePaused) { SetGameState(GameRunning); m_gameMusicInstance.play(); } }
void CTetris::PauseGame(void) { if (GetGameState() == GameRunning) { SetGameState(GamePaused); m_gameMusicInstance.stop(); } }
void CTetris::StartNewGame(void) { if (GetGameState() == GameRunning || GetGameState() == GamePaused) EndGame(false); m_curBrick = CreateRandomBrick(); if (!m_gameMusicInstance.isPlaying()) m_gameMusicInstance.play(); SetGameState(GameRunning); }
void IGameController::StartMatch() { ResetGame(); m_RoundCount = 0; m_aTeamscore[TEAM_RED] = 0; m_aTeamscore[TEAM_BLUE] = 0; // start countdown if there're enough players, otherwise do warmup till there're if(HasEnoughPlayers()) SetGameState(IGS_START_COUNTDOWN); else SetGameState(IGS_WARMUP_GAME, TIMER_INFINITE); Server()->DemoRecorder_HandleAutoStart(); char aBuf[256]; str_format(aBuf, sizeof(aBuf), "start match type='%s' teamplay='%d'", m_pGameType, m_GameFlags&GAMEFLAG_TEAMS); GameServer()->Console()->Print(IConsole::OUTPUT_LEVEL_DEBUG, "game", aBuf); }
void GameManager::Update(float dt){ // See if a new gamestate is requested if(nextGameState){ SetGameState(); } // Update physics //physics->Update(dt); // Update current game-state currentGameState->Update(dt); }
/* * Update the given PokerAI's game state * ai: the PokerAI to update * new_state: JSON representation of the new game state */ void UpdateGameState(PokerAI *ai, cJSON *new_state) { ai->action.type = ACTION_UNSET; SetGameState(&ai->game, new_state); if (ai->loglevel >= LOGLEVEL_INFO) { PrintTableInfo(&ai->game, ai->logfile); } }
void IGameController::ResetGame() { // reset the game GameServer()->m_World.m_ResetRequested = true; SetGameState(IGS_GAME_RUNNING); m_GameStartTick = Server()->Tick(); m_SuddenDeath = 0; // do team-balancing DoTeamBalance(); }
//----------------------------------------------------------------------------------- void TheGame::UpdateMainMenu(float deltaSeconds) { UNUSED(deltaSeconds); if (InputSystem::instance->WasKeyJustPressed('N')) { SetGameState(GameState::MAP_SELECTION); } else if (InputSystem::instance->WasKeyJustPressed('Q')) { g_isQuitting = true; } }
// This is called every time WriteChatColor is called by MQ2Main or any plugin, // IGNORING FILTERS, IF YOU NEED THEM MAKE SURE TO IMPLEMENT THEM. IF YOU DONT // CALL CEverQuest::dsp_chat MAKE SURE TO IMPLEMENT EVENTS HERE PLUGIN_API DWORD OnWriteChatColor(PCHAR Line, DWORD Color, DWORD Filter) { //DebugSpewAlways("MQ2ChatWnd::OnWriteChatColor(%s)",Line); if (!MQChatWnd) { if (gGameState==GAMESTATE_INGAME) { SetGameState(gGameState); } if (!MQChatWnd) { return 0; } } MQChatWnd->dShow=1; PFILTER pFilter=gpFilters; while (pFilter) { if (!pFilter->pEnabled || (*pFilter->pEnabled)) { if (!_strnicmp(Line,pFilter->FilterText,pFilter->Length)) { return 0; } } pFilter = pFilter->pNext; } Color=pChatManager->GetRGBAFromIndex(Color); CHAR szProcessed[MAX_STRING]; pPlugins; MQToSTML(Line,szProcessed,MAX_STRING,Color); pPlugins; strcat_s(szProcessed,"<br>"); CXStr NewText(szProcessed); DebugTry(ConvertItemTags(NewText,FALSE)); ChatBuffer *pNewBuffer = new ChatBuffer; GetCXStr(NewText.Ptr,pNewBuffer->Text,MAX_STRING); pNewBuffer->pPrev=pPendingChatTail; pNewBuffer->pNext=0; if (pPendingChatTail) { pPendingChatTail->pNext=pNewBuffer; } else { pPendingChat=pNewBuffer; } pPendingChatTail=pNewBuffer; PendingChatLines++; return 0; }
void CTetris::EndGame(bool stopMusic) { if (GetGameState() == GameRunning || GetGameState() == GamePaused) { delete m_curBrick; m_curBrick = nullptr; m_board = std::vector<std::vector<int>>(22, std::vector<int>(10, 0)); SetTimeSinceGravity(0.0f); m_points = 0; if (stopMusic) m_gameMusicInstance.stop(); SetGameState(MainMenu); } }
IGameController::IGameController(CGameContext *pGameServer) { m_pGameServer = pGameServer; m_pServer = m_pGameServer->Server(); // balancing m_aTeamSize[TEAM_RED] = 0; m_aTeamSize[TEAM_BLUE] = 0; m_UnbalancedTick = TBALANCE_OK; // game m_GameState = IGS_GAME_RUNNING; m_GameStateTimer = TIMER_INFINITE; m_GameStartTick = Server()->Tick(); m_MatchCount = 0; m_RoundCount = 0; m_SuddenDeath = 0; m_aTeamscore[TEAM_RED] = 0; m_aTeamscore[TEAM_BLUE] = 0; if(g_Config.m_SvWarmup) SetGameState(IGS_WARMUP_USER, g_Config.m_SvWarmup); else SetGameState(IGS_WARMUP_GAME, TIMER_INFINITE); // info m_GameFlags = 0; m_pGameType = "unknown"; // map m_aMapWish[0] = 0; // spawn m_aNumSpawnPoints[0] = 0; m_aNumSpawnPoints[1] = 0; m_aNumSpawnPoints[2] = 0; }
void CSoundtrackManager::SetGameState (EGameStates iNewState) // SetGameState // // Sets the current game state and determines which track to play. { // If our state has not changed, then nothing to do if (iNewState == m_iGameState) return; // Set new state SetGameState(iNewState, CalcTrackToPlay(iNewState)); }
void AProjectTapGameMode::StartPlay() { Super::StartPlay(); auto gameState = GetGameState<AProjectTapGameState>(); ABallPawn* ball = nullptr; if ( UWorld* world = GetWorld() ) { AActor* playerStart = FindPlayerStart( 0 , FString( "Player" ) ); FTransform playerTransform = playerStart->GetTransform(); if ( ABallPlayerStart* realPlayerStart = Cast<ABallPlayerStart>( playerStart ) ) { auto possibleCamera = realPlayerStart->camera == nullptr ? nullptr : Cast<UProjectTapCameraComponent>( realPlayerStart->camera->GetComponentByClass( UProjectTapCameraComponent::StaticClass() ) ); FActorSpawnParameters params; ball = world->SpawnActor<ABallPawn>( ABallPawn::StaticClass() , playerTransform.GetTranslation() , FRotator( playerTransform.GetRotation() ) , params ); if ( ball != nullptr ) { ball->AddVelocity( realPlayerStart->initialVelocity , realPlayerStart->GetActorLocation() ); if ( possibleCamera != nullptr && realPlayerStart->followPlayer ) { ball->setCamera( realPlayerStart ); possibleCamera = ball->GetCamera(); } } gameState->SetCamera( possibleCamera ); isMenu = realPlayerStart->GameMode == CustomGameMode::GAME_MODE_MAIN_MENU; if ( realPlayerStart->music != nullptr )musicPlayer->SetSound( realPlayerStart->music ); } else { FActorSpawnParameters params; ball = world->SpawnActor<ABallPawn>( ABallPawn::StaticClass() , playerTransform.GetTranslation() , FRotator( playerTransform.GetRotation() ) , params ); } gameState->SetPlayer(ball); } musicPlayer->Play(); musicPlayer->SetVolumeMultiplier( 0 ); gameState->SetGameState( CustomGameState::GAME_STATE_PLAYING ); if ( isMenu ) gameState->SetGameMode( CustomGameMode::GAME_MODE_MAIN_MENU ); }
//----------------------------------------------------------------------------------- TheGame::TheGame() : m_currentMap(nullptr) , m_currentGenerator(GeneratorRegistration::CreateGeneratorByName("CellularAutomata")) , m_autoGenerate(true) , m_player(nullptr) , m_mainMenuText(nullptr) { SetGameState(GameState::MAIN_MENU); NPCFactory::LoadAllNPCs(); MessageLog::instance = new MessageLog(); CombatSystem::instance = new CombatSystem(); NPC* enemyPointer = NPCFactory::GetNPCAt(0); NPC* enemyPointer2 = NPCFactory::GetNPCAt(1); AttackData data = AttackData(enemyPointer2, enemyPointer, 1); CombatSystem::instance->PrintAttackToMessageLog(data); delete enemyPointer; delete enemyPointer2; }