2020dce4fd
* Abstracted out option calls to "f3" behind Constants::OPTION_FONT * Added option to disable card image loading.
507 lines
18 KiB
C++
507 lines
18 KiB
C++
#include <assert.h>
|
|
#include "../include/config.h"
|
|
#include "../include/GameApp.h"
|
|
#include "../include/GuiCombat.h"
|
|
#include "../include/AIPlayer.h"
|
|
#include "Closest.cpp"
|
|
|
|
static const float MARGIN = 70;
|
|
static const float TOP_LINE = 80;
|
|
|
|
struct Left : public Exp { static inline bool test(DamagerDamaged* ref, DamagerDamaged* test)
|
|
{ return ref->y == test->y && ref->x > test->x && test->show; } };
|
|
struct Right : public Exp { static inline bool test(DamagerDamaged* ref, DamagerDamaged* test)
|
|
{ return ref->y == test->y && ref->x < test->x && test->show; } };
|
|
|
|
JTexture* GuiCombat::ok_tex = NULL;
|
|
|
|
GuiCombat::GuiCombat(GameObserver* go) : GuiLayer(), go(go), active(false), activeAtk(NULL),
|
|
ok(SCREEN_WIDTH - MARGIN, 210, 1, 0, 255),
|
|
enemy_avatar(SCREEN_WIDTH - MARGIN, TOP_LINE, 2, 0, 255),
|
|
cursor_pos(NONE), step(DAMAGE)
|
|
{
|
|
if(NULL == ok_tex)
|
|
{
|
|
ok_tex = resources.RetrieveTexture("Ok.png",RETRIEVE_LOCK);
|
|
}
|
|
}
|
|
|
|
GuiCombat::~GuiCombat()
|
|
{
|
|
if(ok_tex)
|
|
resources.Release(ok_tex);
|
|
|
|
for (inner_iterator it = attackers.begin(); it != attackers.end(); ++it)
|
|
{
|
|
delete (*it);
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
static inline void repos(typename vector<T*>::iterator begin, typename vector<T*>::iterator end, signed size = -1)
|
|
{
|
|
for (typename vector<T*>::iterator it = begin; it != end; ++it)
|
|
if ((*it)->show) ++size;
|
|
float space = (SCREEN_WIDTH - 2*MARGIN) / size;
|
|
float pos = MARGIN;
|
|
for (typename vector<T*>::iterator it = begin; it != end; ++it)
|
|
if ((*it)->show)
|
|
{
|
|
(*it)->x = pos;
|
|
pos += space;
|
|
}
|
|
}
|
|
|
|
void GuiCombat::Update(float dt)
|
|
{
|
|
for (inner_iterator it = attackers.begin(); it != attackers.end(); ++it)
|
|
(*it)->Update(dt);
|
|
if (activeAtk)
|
|
for (vector<DefenserDamaged*>::iterator q = activeAtk->blockers.begin(); q != activeAtk->blockers.end(); ++q)
|
|
(*q)->Update(dt);
|
|
ok.Update(dt);
|
|
enemy_avatar.Update(dt);
|
|
}
|
|
|
|
void GuiCombat::remaskBlkViews(AttackerDamaged* before, AttackerDamaged* after)
|
|
{
|
|
if (after)
|
|
{
|
|
for (vector<DefenserDamaged*>::iterator q = after->blockers.begin(); q != after->blockers.end(); ++q)
|
|
{
|
|
(*q)->actX = MARGIN; (*q)->y = TOP_LINE;
|
|
(*q)->zoom = 2.2; (*q)->t = 0;
|
|
}
|
|
repos<DefenserDamaged>(after->blockers.begin(), after->blockers.end(), after->card->has(Constants::TRAMPLE) ? 0 : -1);
|
|
enemy_avatar.actX = MARGIN; enemy_avatar.x = SCREEN_WIDTH - MARGIN;
|
|
}
|
|
}
|
|
|
|
void GuiCombat::validateDamage()
|
|
{
|
|
switch (step)
|
|
{
|
|
case FIRST_STRIKE : resolve(); go->nextCombatStep(); break;
|
|
case DAMAGE : resolve(); go->nextGamePhase(); break;
|
|
default: cout << "COMBAT : Cannot validate damage in this phase" << endl; break;
|
|
}
|
|
}
|
|
|
|
void GuiCombat::autoaffectDamage(AttackerDamaged* attacker, CombatStep step)
|
|
{
|
|
attacker->clearDamage();
|
|
unsigned damage = attacker->card->stepPower(step);
|
|
for (vector<DefenserDamaged*>::iterator it = attacker->blockers.begin(); it != attacker->blockers.end(); ++it)
|
|
{
|
|
(*it)->clearDamage();
|
|
unsigned actual_damage = MIN(damage, (unsigned)MAX((*it)->card->toughness, 0));
|
|
(*it)->addDamage(actual_damage, attacker);
|
|
attacker->addDamage((*it)->card->stepPower(step), *it);
|
|
damage -= actual_damage;
|
|
}
|
|
if (damage > 0 && attacker->blockers.size() > 0 && !attacker->card->has(Constants::TRAMPLE)) attacker->blockers[0]->addDamage(damage, attacker);
|
|
}
|
|
|
|
void GuiCombat::addOne(DefenserDamaged* blocker, CombatStep step)
|
|
{
|
|
blocker->addDamage(1, activeAtk);
|
|
signed damage = activeAtk->card->stepPower(step);
|
|
for (vector<DamagerDamaged*>::iterator it = activeAtk->blockers.begin(); it != activeAtk->blockers.end(); ++it)
|
|
{
|
|
damage -= (*it)->sumDamages();
|
|
if (0 > damage) { (*it)->addDamage(-1, activeAtk); break; }
|
|
}
|
|
}
|
|
void GuiCombat::removeOne(DefenserDamaged* blocker, CombatStep step)
|
|
{
|
|
blocker->addDamage(-1, activeAtk);
|
|
for (vector<DamagerDamaged*>::iterator it = activeAtk->blockers.begin(); it != activeAtk->blockers.end(); ++it)
|
|
if (!(*it)->hasLethalDamage()) { (*it)->addDamage(1, activeAtk); return; }
|
|
if (!activeAtk->card->has(Constants::TRAMPLE) && activeAtk->blockers.size() > 0) activeAtk->blockers.back()->addDamage(1, activeAtk);
|
|
}
|
|
|
|
bool GuiCombat::clickOK(){
|
|
switch (step)
|
|
{
|
|
case BLOCKERS : assert(false); return false; // that should not happen
|
|
case ORDER : go->nextGamePhase(); return true;
|
|
case FIRST_STRIKE : return false;
|
|
case DAMAGE : validateDamage(); return true;
|
|
case END_FIRST_STRIKE : return false;
|
|
case END_DAMAGE : return false; // nothing;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool GuiCombat::CheckUserInput(u32 key)
|
|
{
|
|
if (NONE == cursor_pos) return false;
|
|
DamagerDamaged* oldActive = active;
|
|
switch (key)
|
|
{
|
|
case PSP_CTRL_CIRCLE:
|
|
if (BLK == cursor_pos)
|
|
{
|
|
if (ORDER == step) go->cardClick(active->card); // { activeAtk->card->raiseBlockerRankOrder(active->card); }
|
|
else
|
|
{
|
|
signed damage = activeAtk->card->stepPower(step);
|
|
for (vector<DamagerDamaged*>::iterator it = activeAtk->blockers.begin(); *it != active; ++it)
|
|
damage -= (*it)->sumDamages();
|
|
signed now = active->sumDamages();
|
|
damage -= now;
|
|
if (damage > 0) addOne(active, step);
|
|
else
|
|
for (now -= active->card->toughness; now >= 0; --now) removeOne(active, step);
|
|
}
|
|
}
|
|
else if (ATK == cursor_pos)
|
|
{
|
|
active = activeAtk->blockers.front();
|
|
active->zoom = 2.7;
|
|
cursor_pos = BLK;
|
|
}
|
|
else if (OK == cursor_pos)
|
|
{
|
|
clickOK();
|
|
}
|
|
break;
|
|
case PSP_CTRL_TRIANGLE:
|
|
if (BLK == cursor_pos)
|
|
{
|
|
oldActive->zoom = 2.2;
|
|
active = activeAtk;
|
|
cursor_pos = ATK;
|
|
}
|
|
return true;
|
|
case PSP_CTRL_LEFT:
|
|
switch (cursor_pos)
|
|
{
|
|
case NONE : break;
|
|
case OK :
|
|
for (vector<AttackerDamaged*>::reverse_iterator it = attackers.rbegin(); it != attackers.rend(); ++it) if ((*it)->show) { active = *it; break; }
|
|
activeAtk = static_cast<AttackerDamaged*>(active);
|
|
cursor_pos = ATK;
|
|
break;
|
|
case ATK :
|
|
{
|
|
DamagerDamaged* old = active;
|
|
active = closest<Left>(attackers, NULL, static_cast<AttackerDamaged*>(active)); activeAtk = static_cast<AttackerDamaged*>(active);
|
|
if (old != active) { if (old) old->zoom = 1.0; if (active) active->zoom = 1.4; }
|
|
}
|
|
break;
|
|
case BLK :
|
|
{
|
|
DamagerDamaged* old = active;
|
|
active = closest<Left>(activeAtk->blockers, NULL, static_cast<DefenserDamaged*>(active));
|
|
if (old != active) { if (old) old->zoom = 1.0; if (active) active->zoom = 1.4; }
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case PSP_CTRL_RIGHT:
|
|
switch (cursor_pos)
|
|
{
|
|
case NONE :
|
|
case OK : break;
|
|
case BLK :
|
|
{
|
|
DamagerDamaged* old = active;
|
|
active = closest<Right>(activeAtk->blockers, NULL, static_cast<DefenserDamaged*>(active));
|
|
if (old != active) { if (old) old->zoom = 1.0; if (active) active->zoom = 1.4; }
|
|
}
|
|
break;
|
|
case ATK :
|
|
{
|
|
DamagerDamaged* old = active;
|
|
active = closest<Right>(attackers, NULL, static_cast<AttackerDamaged*>(active));
|
|
if (active == oldActive) { active = activeAtk = NULL; cursor_pos = OK; }
|
|
else
|
|
{
|
|
if (old != active) { if (old) old->zoom = 1.0; if (active) active->zoom = 1.4; }
|
|
activeAtk = static_cast<AttackerDamaged*>(active);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case PSP_CTRL_DOWN:
|
|
if (ORDER == step || BLK != cursor_pos || active->sumDamages() <= 0) break;
|
|
removeOne(active, step);
|
|
break;
|
|
case PSP_CTRL_UP:
|
|
if (ORDER == step || BLK != cursor_pos) break;
|
|
addOne(active, step);
|
|
break;
|
|
case PSP_CTRL_SQUARE:
|
|
active = activeAtk = NULL; cursor_pos = OK;
|
|
break;
|
|
case PSP_CTRL_RTRIGGER:
|
|
if (!options[Options::REVERSETRIGGERS].number) return false;
|
|
active = activeAtk = NULL; cursor_pos = OK;
|
|
break;
|
|
case PSP_CTRL_LTRIGGER:
|
|
if (options[Options::REVERSETRIGGERS].number) return false;
|
|
active = activeAtk = NULL; cursor_pos = OK;
|
|
break;
|
|
}
|
|
if (oldActive != active)
|
|
{
|
|
if (oldActive && oldActive != activeAtk) oldActive->zoom = 2.2;
|
|
if (active) active->zoom = 2.7;
|
|
if (ATK == cursor_pos) remaskBlkViews(dynamic_cast<AttackerDamaged*>(oldActive), static_cast<AttackerDamaged*>(active));
|
|
}
|
|
if (OK == cursor_pos) ok.zoom = 1.5; else ok.zoom = 1.0;
|
|
return true;
|
|
}
|
|
|
|
void GuiCombat::Render()
|
|
{
|
|
if (NONE == cursor_pos) return;
|
|
JRenderer* renderer = JRenderer::GetInstance();
|
|
renderer->FillRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, ARGB(200,0,0,0));
|
|
|
|
for (inner_iterator it = attackers.begin(); it != attackers.end(); ++it)
|
|
if ((*it)->show) (*it)->Render(step);
|
|
if (activeAtk)
|
|
{
|
|
signed damage = activeAtk->card->stepPower(step);
|
|
for (vector<DefenserDamaged*>::iterator q = activeAtk->blockers.begin(); q != activeAtk->blockers.end(); ++q)
|
|
{
|
|
(*q)->Render(step);
|
|
damage -= (*q)->sumDamages();
|
|
}
|
|
if (damage < 0) damage = 0;
|
|
if (activeAtk->card->has(Constants::TRAMPLE))
|
|
{
|
|
go->opponent()->mAvatar->SetHotSpot(18, 25);
|
|
enemy_avatar.Render(go->opponent()->mAvatar);
|
|
JLBFont * mFont = resources.GetJLBFont(Constants::MAIN_FONT);
|
|
mFont->SetColor(ARGB(255, 255, 64, 0));
|
|
{
|
|
char buf[10]; sprintf(buf, "%i", damage);
|
|
mFont->DrawString(buf, enemy_avatar.actX - 25, enemy_avatar.actY - 40);
|
|
}
|
|
}
|
|
}
|
|
if (ok_tex) {
|
|
JQuad *ok_quad = resources.RetrieveTempQuad("Ok.png");
|
|
ok_quad->SetHotSpot(28, 22);
|
|
ok.Render(ok_quad);
|
|
}
|
|
renderer->DrawLine(0, SCREEN_HEIGHT / 2 + 10, SCREEN_WIDTH, SCREEN_HEIGHT / 2 + 10, ARGB(255, 255, 64, 0));
|
|
if (FIRST_STRIKE == step)
|
|
{
|
|
JLBFont * mFont = resources.GetJLBFont(Constants::MAIN_FONT);
|
|
mFont->SetColor(ARGB(255, 64, 255, 64));
|
|
mFont->DrawString("First strike damage", 370, 2);
|
|
}
|
|
}
|
|
|
|
int GuiCombat::resolve() // Returns the number of damage objects dealt this turn.
|
|
{
|
|
DamageStack* stack = NEW DamageStack();
|
|
for (inner_iterator it = attackers.begin(); it != attackers.end(); ++it)
|
|
{
|
|
signed dmg = (*it)->card->stepPower(step);
|
|
for (vector<DefenserDamaged*>::iterator q = (*it)->blockers.begin(); q != (*it)->blockers.end(); ++q)
|
|
{
|
|
for (vector<Damage>::iterator d = (*q)->damages.begin(); d != (*q)->damages.end(); ++d)
|
|
stack->Add(NEW Damage(*d));
|
|
dmg -= (*q)->sumDamages();
|
|
}
|
|
if (dmg > 0) stack->Add(NEW Damage((*it)->card, go->opponent(), dmg));
|
|
for (vector<Damage>::iterator d = (*it)->damages.begin(); d != (*it)->damages.end(); ++d)
|
|
stack->Add(NEW Damage(*d));
|
|
}
|
|
int v = stack->mCount;
|
|
if (v > 0){
|
|
go->mLayers->stackLayer()->Add(stack);
|
|
go->mLayers->stackLayer()->resolve(); // This will delete the damage stack which will in turn delete the Damage it contains
|
|
}else
|
|
SAFE_DELETE(stack);
|
|
return v;
|
|
}
|
|
|
|
int GuiCombat::receiveEventPlus(WEvent* e)
|
|
{
|
|
if (WEventCreatureAttacker* event = dynamic_cast<WEventCreatureAttacker*>(e))
|
|
{
|
|
if (NULL == event->after) return 0;
|
|
AttackerDamaged* t = NEW AttackerDamaged(event->card, *(event->card->view), true, NULL);
|
|
attackers.push_back(t);
|
|
return 1;
|
|
}
|
|
else if (WEventCreatureBlocker* event = dynamic_cast<WEventCreatureBlocker*>(e))
|
|
{
|
|
for (inner_iterator it = attackers.begin(); it != attackers.end(); ++it)
|
|
if ((*it)->card == event->after)
|
|
{
|
|
DefenserDamaged* t = NEW DefenserDamaged(event->card, *(event->card->view), true, NULL);
|
|
t->y = t->actY = TOP_LINE; t->actT = t->t = 0; t->actZ = t->zoom = 2.2;
|
|
(*it)->blockers.push_back(t);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
else if (WEventCreatureBlockerRank* event = dynamic_cast<WEventCreatureBlockerRank*>(e))
|
|
{
|
|
for (inner_iterator it = attackers.begin(); it != attackers.end(); ++it)
|
|
if ((*it)->card == event->attacker)
|
|
{
|
|
vector<DefenserDamaged*>::iterator it1, it2;
|
|
for (it1 = (*it)->blockers.begin(); it1 != (*it)->blockers.end(); ++it1) if ((*it1)->card == event->card) break;
|
|
if ((*it)->blockers.end() == it1) return 1;
|
|
for (it2 = (*it)->blockers.begin(); it2 != (*it)->blockers.end(); ++it2) if ((*it2)->card == event->exchangeWith) break;
|
|
if ((*it)->blockers.end() == it2) return 1;
|
|
float x = (*it1)->x;
|
|
(*it1)->x = (*it2)->x;
|
|
(*it2)->x = x;
|
|
std::iter_swap(it1, it2);
|
|
autoaffectDamage(*it, DAMAGE);
|
|
}
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
int GuiCombat::receiveEventMinus(WEvent* e)
|
|
{
|
|
if (WEventZoneChange* event = dynamic_cast<WEventZoneChange*>(e))
|
|
if (go->players[0]->game->inPlay == event->from || go->players[1]->game->inPlay == event->from)
|
|
{
|
|
for (inner_iterator it = attackers.begin(); it != attackers.end(); ++it)
|
|
if ((*it)->card == event->card->previous)
|
|
{
|
|
AttackerDamaged* d = *it;
|
|
if (activeAtk == *it) activeAtk = NULL;
|
|
attackers.erase(it);
|
|
SAFE_DELETE(d);
|
|
return 1;
|
|
}
|
|
else
|
|
for (vector<DefenserDamaged*>::iterator q = (*it)->blockers.begin(); q != (*it)->blockers.end(); ++q)
|
|
if ((*q)->card == event->card->previous)
|
|
{
|
|
DefenserDamaged* d = *q;
|
|
(*it)->blockers.erase(q);
|
|
SAFE_DELETE(d);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
if (WEventCreatureAttacker* event = dynamic_cast<WEventCreatureAttacker*>(e))
|
|
{
|
|
if (NULL == event->before) return 0;
|
|
for (inner_iterator it = attackers.begin(); it != attackers.end(); ++it)
|
|
if ((*it)->card == event->card)
|
|
{
|
|
AttackerDamaged* d = *it;
|
|
attackers.erase(it);
|
|
SAFE_DELETE(d);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
else if (WEventCreatureBlocker* event = dynamic_cast<WEventCreatureBlocker*>(e))
|
|
{
|
|
for (inner_iterator it = attackers.begin(); it != attackers.end(); ++it)
|
|
if ((*it)->card == event->before)
|
|
for (vector<DefenserDamaged*>::iterator q = (*it)->blockers.begin(); q != (*it)->blockers.end(); ++q)
|
|
if ((*q)->card == event->card)
|
|
{
|
|
DefenserDamaged* d = *q;
|
|
(*it)->blockers.erase(q);
|
|
SAFE_DELETE(d);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
else if (WEventPhaseChange* event = dynamic_cast<WEventPhaseChange*>(e))
|
|
{
|
|
if (Constants::MTG_PHASE_COMBATDAMAGE == event->to->id) step = BLOCKERS;
|
|
else cursor_pos = NONE;
|
|
}
|
|
else if (WEventCombatStepChange* event = dynamic_cast<WEventCombatStepChange*>(e))
|
|
switch (event->step)
|
|
{
|
|
case BLOCKERS:
|
|
break;
|
|
case ORDER:
|
|
{
|
|
if (ORDER == step) return 0; // Why do I take this twice ? >.>
|
|
if (!go->currentPlayer->displayStack()) { go->nextCombatStep(); return 1; }
|
|
for (inner_iterator it = attackers.begin(); it != attackers.end(); ++it)
|
|
{
|
|
(*it)->show = (1 < (*it)->blockers.size());
|
|
autoaffectDamage(*it, DAMAGE);
|
|
}
|
|
active = NULL;
|
|
for (inner_iterator it = attackers.begin(); it != attackers.end(); ++it)
|
|
if ((*it)->show)
|
|
{
|
|
(*it)->y = 210;
|
|
(*it)->zoom = 2.2; (*it)->t = 0;
|
|
if (!active) active = *it;
|
|
}
|
|
repos<AttackerDamaged>(attackers.begin(), attackers.end(), 0);
|
|
if (active)
|
|
{
|
|
active->zoom = 2.7;
|
|
activeAtk = static_cast<AttackerDamaged*>(active);
|
|
remaskBlkViews(NULL, static_cast<AttackerDamaged*>(active));
|
|
cursor_pos = ATK;
|
|
step = ORDER;
|
|
}
|
|
else
|
|
go->nextGamePhase();
|
|
return 1;
|
|
}
|
|
case FIRST_STRIKE:
|
|
step = FIRST_STRIKE;
|
|
for (inner_iterator attacker = attackers.begin(); attacker != attackers.end(); ++attacker)
|
|
if ((*attacker)->card->has(Constants::FIRSTSTRIKE) || (*attacker)->card->has(Constants::DOUBLESTRIKE)) goto DAMAGE;
|
|
go->nextCombatStep();
|
|
break;
|
|
case END_FIRST_STRIKE:
|
|
step = END_FIRST_STRIKE;
|
|
for (inner_iterator attacker = attackers.begin(); attacker != attackers.end(); ++attacker)
|
|
autoaffectDamage(*attacker, FIRST_STRIKE);
|
|
if (0 == resolve())
|
|
go->nextCombatStep();
|
|
//else go->mLayers->stackLayer()->AddNextGamePhase(); //uncomment to add "interrupt" offer after first strike, rather than giving priority to current player
|
|
return 1;
|
|
case DAMAGE: DAMAGE:
|
|
step = event->step;
|
|
if (!go->currentPlayer->displayStack()) {
|
|
((AIPlayer *)go->currentPlayer)->affectCombatDamages(step);
|
|
go->nextGamePhase();
|
|
return 1;
|
|
}
|
|
for (inner_iterator attacker = attackers.begin(); attacker != attackers.end(); ++attacker)
|
|
autoaffectDamage(*attacker, step);
|
|
for (inner_iterator it = attackers.begin(); it != attackers.end(); ++it)
|
|
(*it)->show = ((*it)->card->has(Constants::DOUBLESTRIKE) || ((*it)->card->has(Constants::FIRSTSTRIKE) ^ (DAMAGE == step))) &&
|
|
(((*it)->card->has(Constants::TRAMPLE) ? (unsigned int) 0 : (unsigned int) 1) < (*it)->blockers.size()
|
|
);
|
|
repos<AttackerDamaged>(attackers.begin(), attackers.end(), 0);
|
|
active = NULL;
|
|
for (inner_iterator it = attackers.begin(); it != attackers.end(); ++it) if ((*it)->show) { active = *it; break; }
|
|
if (active)
|
|
{
|
|
active->zoom = 2.7;
|
|
activeAtk = static_cast<AttackerDamaged*>(active);
|
|
remaskBlkViews(NULL, static_cast<AttackerDamaged*>(active));
|
|
cursor_pos = ATK;
|
|
}
|
|
else
|
|
go->nextCombatStep();
|
|
return 1;
|
|
case END_DAMAGE:
|
|
step = END_DAMAGE;
|
|
if (0 == resolve())
|
|
go->nextGamePhase();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|