void Scene_Battle_Rpg2k3::ProcessActions() {
if (Main_Data::game_party->GetBattlerCount() == 0) {
Game_Temp::battle_result = Game_Temp::BattleVictory;
Scene::Pop();
}
if (!battle_actions.empty()) {
if (battle_actions.front()->IsDead()) {
// No zombies allowed ;)
RemoveCurrentAction();
}
else if (ProcessBattleAction(battle_actions.front()->GetBattleAlgorithm().get())) {
NextTurn();
RemoveCurrentAction();
if (CheckResultConditions()) {
return;
}
}
}
if (help_window->GetVisible() && message_timer > 0) {
message_timer--;
if (message_timer <= 0)
help_window->SetVisible(false);
}
switch (state) {
case State_Start:
SetState(State_SelectOption);
break;
case State_SelectActor:
case State_AutoBattle:
case State_Battle:
// no-op
break;
case State_SelectEnemyTarget: {
static int flash_count = 0;
Game_Enemy* target = static_cast<Game_Enemy*>(Main_Data::game_enemyparty->GetAliveEnemies()[target_window->GetIndex()]);
Sprite_Battler* sprite = Game_Battle::GetSpriteset().FindBattler(target);
if (sprite) {
++flash_count;
if (flash_count == 60) {
sprite->Flash(Color(255, 255, 255, 100), 15);
flash_count = 0;
}
}
break;
}
case State_AllyAction:
case State_EnemyAction:
break;
case State_Escape:
Escape();
break;
default:
break;
}
}
void Scene_Battle_Rpg2k::SelectNextActor() {
std::vector<Game_Actor*> allies = Main_Data::game_party->GetActors();
if ((size_t)actor_index == allies.size()) {
// All actor actions decided, player turn ends
SetState(State_Battle);
CreateEnemyActions();
CreateExecutionOrder();
NextTurn();
Game_Battle::RefreshEvents();
return;
}
active_actor = allies[actor_index];
status_window->SetIndex(actor_index);
actor_index++;
if (active_actor->IsDead()) {
SelectNextActor();
return;
}
Game_Battler* random_target = NULL;
if (active_actor->CanAct()) {
switch (active_actor->GetSignificantRestriction()) {
case RPG::State::Restriction_attack_ally:
random_target = Main_Data::game_party->GetRandomActiveBattler();
break;
case RPG::State::Restriction_attack_enemy:
random_target = Main_Data::game_enemyparty->GetRandomActiveBattler();
break;
}
}
else {
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::NoMove>(active_actor));
battle_actions.push_back(active_actor);
SelectNextActor();
return;
}
if (random_target || auto_battle || active_actor->GetAutoBattle()) {
if (!random_target) {
random_target = Main_Data::game_enemyparty->GetRandomActiveBattler();
}
// ToDo: Auto battle logic is dumb
active_actor->SetBattleAlgorithm(std::make_shared<Game_BattleAlgorithm::Normal>(active_actor, random_target));
battle_actions.push_back(active_actor);
SelectNextActor();
return;
}
SetState(Scene_Battle::State_SelectCommand);
}
void Battle::Run()
{
// TODO : check player != end
std::vector<Creature*>::iterator player;
std::vector<Creature*>::iterator end;
do {
player = std::find_if(combatants.begin(), combatants.end(),
[](Creature* creature) { return creature->GetID() == "Player"; });
end = combatants.end();
NextTurn();
} while (combatants.size() > 1 && player != end);
}
void Run(UI* ui)
{ if(ui == NULL) return;
NewGame(ui->game);
NextTurn(ui->game);
int c, running = 1;
while(running && ui->game->status != GAME_STATUS_ERROR)
{ DisplayGame(ui);
c = getch();
switch(c)
{
case KEY_LEFT:
if(ui->game->status != GAME_STATUS_LOST)
{ if(PushLeft(ui->game)) NextTurn(ui->game);
else CheckTurn(ui->game);
}
break;
case KEY_RIGHT:
if(ui->game->status != GAME_STATUS_LOST)
{ if(PushRight(ui->game)) NextTurn(ui->game);
else CheckTurn(ui->game);
}
break;
case KEY_UP:
if(ui->game->status != GAME_STATUS_LOST)
{ if(PushUp(ui->game)) NextTurn(ui->game);
else CheckTurn(ui->game);
}
break;
case KEY_DOWN:
if(ui->game->status != GAME_STATUS_LOST)
{ if(PushDown(ui->game)) NextTurn(ui->game);
else CheckTurn(ui->game);
}
break;
case 'q':
running = 0;
break;
case 'n':
NewGame(ui->game);
NextTurn(ui->game);
break;
case 'r':
StartGame(ui->game);
NextTurn(ui->game);
break;
default:
break;
}
}
}
//---------------------------------------------------------------------------
// Description: This method runs the simulation by calling the 'NextTurn' method,
// checking the stop criteria and updating the main window interface
void Civilization::PerformEvolution()
{
Restart();
for(int i=0; i< MainWindow->EditTurns->Text.ToInt(); i++)
{
NextTurn();
DrawPreviewBoard(); // highlight the road with more pheromone
Application->ProcessMessages();
if(FoodRateReached(MainWindow->EditRange->Text.ToInt(),MainWindow->EditRate->Text.ToInt())) break;
}
FindMainRoads(50,VirtualCiv,10,1.0);
Application->ProcessMessages();
}
void GameMaze::StartGame()
{
Game::StartGame();
if(currentState != NULL)
{
delete currentState;
}
currentState = new MazeState(PLAYER_AI, stepsToGameOver, mazeWidth, mazeHeight, visibleGoals, abstraction, this);
playerCount = 2;
player[ENVINRONMENT_AI]->StartGame(this);
player[PLAYER_AI]->StartGame(this);
state = STATE_RUNNING;
if(player[PLAYER_AI]->Think())
NextTurn();
}
int WorldClass::Update(int index)
{
//Check to see if they can make a move
bool outOfMoves = true;
for (int i = 0; i < numOfUnits; i++)
{
if (_entityArray[i].unitData.playerID == currentTurn)
{
if (_entityArray[i].unitData.actions != 0 && _entityArray[i].unitData.hp != 0)
outOfMoves = false;
}
}
//Check to see if alive
for (int i = 0; i < numOfPlayers; i++)
{
if (_entityArray[i].unitData.unitID == 0 && _entityArray[i].unitData.hp <= 0)
alivePlayers[_entityArray[i].unitData.playerID] = false;
}
//Game over if only alive
bool lastStanding = true;
for (int i = 0; i < numOfPlayers; i++)
{
if (alivePlayers[i] = true && i != currentTurn)
lastStanding = false;
}
//Exit game if only person left
if (lastStanding)
{
isInGame = false;
winner = currentTurn;
}
//Next turn if dead or out of moves
if (outOfMoves /*|| alivePlayers[currentTurn]*/)
NextTurn();
UpdateUnitMap();
UpdateHealthBg(index);
return 1;
}
void Scene_Battle_Rpg2k::Escape() {
static bool escaping = true;
static bool escape_success = false;
if (escaping) {
battle_message_window->Clear();
Game_BattleAlgorithm::Escape escape_alg = Game_BattleAlgorithm::Escape(&(*Main_Data::game_party)[0]);
escape_success = escape_alg.Execute();
escape_alg.Apply();
battle_result_messages.clear();
escape_alg.GetResultMessages(battle_result_messages);
battle_message_window->Push(battle_result_messages[0]);
escaping = false;
}
else {
static int counter = 0;
++counter;
if (counter > 60) {
escaping = true;
counter = 0;
if (escape_success) {
Game_Temp::battle_result = Game_Temp::BattleEscape;
Scene::Pop();
}
else {
SetState(State_Battle);
CreateEnemyActions();
CreateExecutionOrder();
NextTurn();
}
}
}
}
void Scene_Battle_Rpg2k::Escape() {
if (begin_escape) {
battle_message_window->Clear();
Game_BattleAlgorithm::Escape escape_alg = Game_BattleAlgorithm::Escape(&(*Main_Data::game_party)[0]);
escape_success = escape_alg.Execute();
escape_alg.Apply();
battle_result_messages.clear();
escape_alg.GetResultMessages(battle_result_messages);
battle_message_window->Push(battle_result_messages[0]);
begin_escape = false;
}
else {
++escape_counter;
if (escape_counter > 60) {
begin_escape = true;
escape_counter = 0;
if (escape_success) {
Game_Temp::battle_result = Game_Temp::BattleEscape;
Scene::Pop();
}
else {
SetState(State_Battle);
CreateEnemyActions();
CreateExecutionOrder();
NextTurn();
Game_Battle::RefreshEvents();
}
}
}
}
///////////////////////////////////////////////////////////////////////////////
// Descripcion:
// - Alinea a la criatura hCriature en combate, dentro del conjunto de
// combatientes AlingmentSet.
// - En caso de que la alineacion sea nula, la entidad se eliminara de cualquier
// conjunto de combate
// Parametros:
// - hCriature. Entidad a alinear en combate.
// - Alingment. Conjunto de combatientes donde alinear.
// Devuelve:
// Notas:
///////////////////////////////////////////////////////////////////////////////
void
CCombatSystem::SetAlingment(const AreaDefs::EntHandle& hCriature,
const CombatSystemDefs::eCombatAlingment& Alingment)
{
// SOLO si instancia inicializada
ASSERT(IsInitOk());
// SOLO si parametros validos
ASSERT_MSG(IsValidCombatient(hCriature), "SetAlingment");
// Se halla la alineacion de la criatura
// En caso de que este alineada y se quiera insertar en una alineacion
// distinta, se realizara el cambio
const CombatSystemDefs::eCombatAlingment OldAlingment = GetAlingment(hCriature);
// ¿Tenia alineacion?
if (OldAlingment != CombatSystemDefs::NO_ALINGMENT) {
// Se toma instancia al map y se borra del mismo
AlingmentMap* const pAlingmentMap = GetAlingmentMap(OldAlingment);
ASSERT(pAlingmentMap);
const AlingmentMapIt It(pAlingmentMap->find(hCriature));
ASSERT((It != pAlingmentMap->end()) != 0);
delete It->second;
pAlingmentMap->erase(It);
}
// ¿Se desea alinear a la criatura?
if (Alingment != CombatSystemDefs::NO_ALINGMENT) {
// ¿La criatura a alinear NO ES el jugador?
if (m_pWorld->GetEntityType(hCriature) != RulesDefs::PLAYER) {
// Si, entonces si la criatura NO TIENE en su rango a NINGUNA otra
// criatura ya alineada, se cancelara la accion
if (!IsSomeCriatureInRange(hCriature, m_AlingmentInfo.PlayerMap) &&
!IsSomeCriatureInRange(hCriature, m_AlingmentInfo.EnemyPlayerMap)) {
// La criatura NO se puede alinear, retorna
return;
}
}
// Se toma el map
AlingmentMap* const pAlingment = GetAlingmentMap(Alingment);
ASSERT(pAlingment);
// Se crea nodo de informacion, se inicializa sprite con selector e inserta
sNAlingmentInfo* const pNAlingmentInfo = new sNAlingmentInfo;
if (Alingment == CombatSystemDefs::PLAYER_ALINGMENT) {
pNAlingmentInfo->CombatSelector.Init(m_AlingmentInfo.szPlayerAlingmentSelector);
} else {
pNAlingmentInfo->CombatSelector.Init(m_AlingmentInfo.szEnemyPlayerAlingmentSelector);
}
ASSERT(pNAlingmentInfo->CombatSelector.IsInitOk());
pAlingment->insert(AlingmentMapValType(hCriature, pNAlingmentInfo));
// ¿NO estaba alineada previamente?
if (OldAlingment == CombatSystemDefs::NO_ALINGMENT) {
// Se instala el modulo como observador de la criatura
CCriature* const pCriature = m_pWorld->GetCriature(hCriature);
ASSERT(pCriature);
pCriature->AddObserver(this);
// Se inserta en la lista de turno de combate que proceda
// ¿Esta el modo combate activo?
if (IsCombatActive()) {
// Si, se inserta en la lista de espera
InsertInWaitingForCombatTurnList(hCriature);
} else {
// No, se inserta en la lista principal
InsertInCombatTurnList(hCriature);
}
}
} else {
// No se desea alinear
// ¿Estaba alineada?
if (OldAlingment != CombatSystemDefs::NO_ALINGMENT) {
// Si, se desinstala el modulo como observador de la criatura
CCriature* const pCriature = m_pWorld->GetCriature(hCriature);
ASSERT(pCriature);
pCriature->RemoveObserver(this);
// Se insertara en la lista de de criaturas pendientes de ser
// eliminadas de la lisat de turnos de combate y ademas
m_CombatTurnInfo.CombatientLeaving.push_back(hCriature);
// ¿Tenia el turno?
if (m_CombatTurnInfo.CriatureInTurn.CriatureIt != m_CombatTurnInfo.TurnList.end()) {
if (hCriature == m_CombatTurnInfo.CriatureInTurn.CriatureIt->hCriature) {
// Si, se pasara automaticamente
NextTurn(hCriature);
}
}
}
}
}
///////////////////////////////////////////////////////////////////////////////
// Descripcion:
// - Recibe la notificacion de una criatura sobre un determinado suceso en
// la misma o cambio de estado.
// - A la hora de recibir la notificacion de la realizacion de una accion,
// se tendra en cuenta si esta bloqueado o no el uso de los puntos de accion.
// Parametros:
// - hCriature. Handle a la criatura.
// - NotifyType. Tipo de suceso.
// - udParam. Posible parametro.
// Devuelve:
// Notas:
// - En caso de que no se este en modo combate, se obviaran las notificaciones
// - Cuando la notificacion provenga del jugador, se tendra en cuenta los
// sig. aspectos:
// * Si hay ptos de accion insuficientes -> NO se pasara de turno.
// * Si al restar puntos, estos quedan a 0 -> NO se pasara SI se esta
// en la interfaz PlayerProfile.
// - El codigo de la accion a realizar en udParam, SIEMPRE, ira en el word
// inferior.
///////////////////////////////////////////////////////////////////////////////
void
CCombatSystem::CriatureObserverNotify(const AreaDefs::EntHandle& hCriature,
const CriatureObserverDefs::eObserverNotifyType& NotifyType,
const dword udParam)
{
// SOLO si instancia inicializada
ASSERT(IsInitOk());
// SOLO si parametros validos
ASSERT_MSG(IsValidCombatient(hCriature), "CriatureObserverNotify");
// ¿NO se esta en modo combate?
if (!IsCombatActive()) {
// Si, se abandona
return;
}
// Se comprueba el tipo de notificacion recibida
switch (NotifyType) {
case CriatureObserverDefs::IS_DEATH: {
// La criatura ejecuto el evento de muerte
CCriature* const pCriature = m_pWorld->GetCriature(hCriature);
// ¿Es el jugador?
if (pCriature->GetEntityType() == RulesDefs::PLAYER) {
// Si, se finaliza el combate
EndCombat();
} else {
// No, se desvincula a la criatura del combate
SetAlingment(hCriature, CombatSystemDefs::NO_ALINGMENT);
}
} break;
case CriatureObserverDefs::ACTION_REALICE: {
// ¿Criatura con turno?
if (hCriature == GetCriatureInTurn()) {
// ¿NO esta bloqueado el uso de puntos de accion?
if (!m_bActionPointsBlocked) {
// Se toma la accion a realizar y sus puntos de accion
const RulesDefs::eCriatureAction Action = RulesDefs::eCriatureAction(udParam & 0x0000FFFF);
// Se comprueba si se esta realizando alguna accion especial o
// bien una accion no considerada como que gasta puntos de combate
RulesDefs::CriatureActionPoints ActionCost = 0;
switch(Action) {
case RulesDefs::CA_USEHABILITY: {
// Se obtiene el identificador de la habilidad en los primeros 16 bits
const RulesDefs::eIDHability IDHability = RulesDefs::eIDHability(udParam >> 16);
ActionCost = m_pGDBase->GetRulesDataBase()->GetUseHabilityCost(IDHability);
} break;
case RulesDefs::CA_HIT: {
// Se obtiene el slot con el que se golpea y los ptos asociados
const RulesDefs::eIDEquipmentSlot Slot = RulesDefs::eIDEquipmentSlot(udParam >> 16);
CCriature* const pCriature = m_pWorld->GetCriature(hCriature);
ASSERT(pCriature);
CItem* const pItem = m_pWorld->GetItem(pCriature->GetEquipmentSlots()->GetItemEquipedAt(Slot));
ActionCost = (NULL == pItem) ? 0 : m_pGDBase->GetRulesDataBase()->GetUseWeaponItemCost(pItem->GetType());
} break;
case RulesDefs::CA_DROPITEM:
case RulesDefs::CA_STOPWALK: {
// No se considerara gasto en puntos de combate
return;
} break;
}; // ~ switch
// Se añaden los puntos base de coste de la accion realizada
ActionCost += m_pGDBase->GetRulesDataBase()->GetCombatActionCost(Action);
// Se decrementan los puntos de accion y se actualizan en ventana
ASSERT((ActionCost <= m_CombatTurnInfo.CriatureInTurn.ActionPoints) != 0);
m_CombatTurnInfo.CriatureInTurn.ActionPoints -= ActionCost;
ASSERT((m_CombatTurnInfo.CriatureInTurn.ActionPoints >= 0) != 0);
m_pGUIManager->CombatSetActionPoints(m_CombatTurnInfo.CriatureInTurn.ActionPoints);
// ¿Ya no quedan puntos de accion?
if (0 == m_CombatTurnInfo.CriatureInTurn.ActionPoints) {
// Se notifica de tal forma que se ejecute el case INSUFICIENT_ACTION_POINTS
CCriature* const pCriature = m_pWorld->GetCriature(hCriature);
ASSERT(pCriature);
// Si la entidad es un NPC, se pasara de turno automaticamente
if (RulesDefs::CRIATURE == pCriature->GetEntityType()) {
NextTurn(hCriature);
} else {
// En caso contrario se trata del jugador y se pasara de turno
// SOLO si NO se esta en el interfaz de inventario.
if (m_pGUIManager->GetGameGUIWindowState() != GUIManagerDefs::GUIW_PLAYERPROFILE) {
NextTurn(hCriature);
}
}
}
}
}
} break;
case CriatureObserverDefs::INSUFICIENT_ACTION_POINTS: {
// ¿Criatura con turno?
if (hCriature == GetCriatureInTurn()) {
// Se pasara de turno si la entidad no es el jugador
if (m_pWorld->GetPlayer()->GetHandle() != hCriature) {
NextTurn(hCriature);
} else {
// En el caso de que sea el jugador se mandara mensaje a consola
SYSEngine::GetGUIManager()->WriteToConsole(m_pGDBase->GetStaticText(GameDataBaseDefs::ST_GENERAL_INSUFICIENTACTIONPOINTS),
true);
}
}
} break;
}; // ~ switch
}
/*
Updates player moves
*/
void clash::Update(float dt) {
_keyPress += dt;
if (_turn == AI) NextTurn();
else if (sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Return) && _keyPress > 1.f) {
NextTurn();
_keyPress = 0;
}
// Mouse-over type marker
for (int i = 0; i < CHECKBOARD; i++) {
for (int j = 0; j < CHECKBOARD; j++) {
if (IsMouseOver(_checkBoard[i][j])) {
_currentMouseOver = sf::Vector2i(i, j);
}
}
}
// Selection tool
if (sf::Mouse::isButtonPressed(sf::Mouse::Left)) {
_currentChoosen = _currentMouseOver;
}
// Moving units
else if (sf::Mouse::isButtonPressed(sf::Mouse::Right) && _currentChoosen.x >= 0 && _keyPress > 0.2f) {
int i = _currentChoosen.x;
int j = _currentChoosen.y;
int x = _currentMouseOver.x;
int y = _currentMouseOver.y;
if (((abs(x - i) <= 1 && j == y) || (abs(j - y) <= 1 && i == x)) && _movesPPlayer > 0 && _checkBoard[i][j].CountUnits() > 0) {
if (_checkBoard[i][j]._entity == _checkBoard[x][y]._entity && _turn == _checkBoard[i][j]._entity)
MoveUnit(_currentChoosen, _currentMouseOver);
if (_checkBoard[x][y]._entity == NONE && _turn == _checkBoard[i][j]._entity) {
_checkBoard[x][y]._entity = _turn;
_checkBoard[x][y]._field = UNIT;
MoveUnit(_currentChoosen, _currentMouseOver);
}
if (_checkBoard[x][y]._entity >= 0 && _checkBoard[x][y]._entity != _checkBoard[i][j]._entity) {
if (_checkBoard[x][y].CountUnits() > 0 && _checkBoard[i][j].CountUnits() > 0) {
_checkBoard[x][y].Kill(1);
_checkBoard[i][j].Kill(1);
_movesPPlayer--;
}
else if (_checkBoard[x][y].CountUnits() == 0 && _checkBoard[i][j].CountUnits() > 0) {
if (_checkBoard[x][y]._field == FACTORY) {
_checkBoard[x][y]._field = UNIT;
_player[_checkBoard[x][y]._entity - 1] = false;
}
if (_checkBoard[x][y]._field == CORE) {
//Window.GetGameManager()->_winner = (int)(_checkBoard[i][j]._entity + 1);
//Window.GetGameManager()->MoveForward();
Window.Stop();
}
_checkBoard[x][y]._entity = _checkBoard[i][j]._entity;
MoveUnit(_currentChoosen, _currentMouseOver);
}
}
}
_keyPress = 0;
}
if (_turn == AI && _pcTurn >= 2 && _pcTurn != 3) {
if (_pcTurn == 4) {
for (int i = 0; i < CHECKBOARD; i++) {
for (int j = 0; j < CHECKBOARD; j++) {
if (_checkBoard[i][j]._entity == AI) {
_checkBoard[i][j].TurnAlive(1);
}
}
}
_pcTurn = 0;
}
for (int i = 1; i <= 2; i++) {
int ww = 0, wh = 0;
if (i == 1 || i == 4) wh = 1;
if (i == 1 || i == 3) ww = 1;
if (i == 3 || i == 2) wh = CHECKBOARD - 2;
if (i == 4 || i == 2) ww = CHECKBOARD - 2;
if (_checkBoard[ww][wh]._entity == NONE) {
_checkBoard[ww][wh]._entity = (ENTITY_TYPE) (i);
_checkBoard[ww][wh]._field = UNIT;
}
if (_checkBoard[ww][wh]._entity == (ENTITY_TYPE) (i) && _player[_checkBoard[ww][wh]._entity-1]) {
_checkBoard[ww][wh].TurnAlive(2);
}
}
}
if (_movesPPlayer > 0) _check = false;
if (_moves != _movesPPlayer) {
if (_movesPPlayer == 0) Window.UpdateStatusbar("Press ENTER for next turn");
else if (_turnCounter == 1 && _movesPPlayer == 0 && _check) {
_moves = 1;
_check = false;
}
else Window.UpdateStatusbar(toString(_movesPPlayer) + " moves left");
}
}
void CurrentTurn(struct StopWatch *sw){
if(sw->isRun){
if(!sw->isPause)
NextTurn(sw);
}
}
void TakeTurn(Dudes *Board[8][8])
{
GetMove(Board);
NextTurn();
}
