162 lines
3.4 KiB
C++
162 lines
3.4 KiB
C++
#include "PrecompiledHeader.h"
|
|
|
|
#include "TargetsList.h"
|
|
#include "Player.h"
|
|
#include "MTGCardInstance.h"
|
|
#include "Damage.h"
|
|
#include "ActionStack.h"
|
|
|
|
TargetsList::TargetsList()
|
|
{
|
|
cursor = 0;
|
|
}
|
|
|
|
TargetsList::TargetsList(Targetable * _targets[], int nbtargets)
|
|
{
|
|
for (int i = 0; i < nbtargets; i++)
|
|
{
|
|
targets[i] = _targets[i];
|
|
}
|
|
cursor = nbtargets;
|
|
}
|
|
|
|
int TargetsList::addTarget(Targetable * target)
|
|
{
|
|
if (!alreadyHasTarget(target))
|
|
{
|
|
targets[cursor] = target;
|
|
cursor++;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
|
|
}
|
|
|
|
int TargetsList::alreadyHasTarget(Targetable * target)
|
|
{
|
|
for (int i = 0; i < cursor; i++)
|
|
{
|
|
if (targets[i] == target) return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int TargetsList::removeTarget(Targetable * target)
|
|
{
|
|
for (int i = 0; i < cursor; i++)
|
|
{
|
|
if (targets[i] == target)
|
|
{
|
|
targets[i] = targets[cursor];
|
|
targets[cursor] = NULL;
|
|
cursor--;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int TargetsList::toggleTarget(Targetable * target)
|
|
{
|
|
if (alreadyHasTarget(target))
|
|
{
|
|
|
|
return removeTarget(target);
|
|
}
|
|
else
|
|
{
|
|
|
|
return addTarget(target);
|
|
}
|
|
}
|
|
|
|
Targetable * TargetsList::getNextTarget(Targetable * previous, int type)
|
|
{
|
|
int found = 0;
|
|
if (!previous) found = 1;
|
|
for (int i = 0; i < cursor; i++)
|
|
{
|
|
if (found && (type == -1 || targets[i]->typeAsTarget() == type))
|
|
{
|
|
return (targets[i]);
|
|
}
|
|
if (targets[i] == previous) found = 1;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
MTGCardInstance * TargetsList::getNextCardTarget(MTGCardInstance * previous)
|
|
{
|
|
return ((MTGCardInstance *) getNextTarget(previous, TARGET_CARD));
|
|
}
|
|
|
|
Player * TargetsList::getNextPlayerTarget(Player * previous)
|
|
{
|
|
return ((Player *) getNextTarget(previous, TARGET_PLAYER));
|
|
}
|
|
|
|
Interruptible * TargetsList::getNextInterruptible(Interruptible * previous, int type)
|
|
{
|
|
int found = 0;
|
|
if (!previous) found = 1;
|
|
for (int i = 0; i < cursor; i++)
|
|
{
|
|
if (found && targets[i]->typeAsTarget() == TARGET_STACKACTION)
|
|
{
|
|
Interruptible * action = (Interruptible *) targets[i];
|
|
if (action->type == type)
|
|
{
|
|
return action;
|
|
}
|
|
}
|
|
if (targets[i] == previous) found = 1;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
Spell * TargetsList::getNextSpellTarget(Spell * previous)
|
|
{
|
|
Spell * spell = (Spell *) getNextInterruptible(previous, ACTION_SPELL);
|
|
return spell;
|
|
}
|
|
|
|
//How about DAMAGESTacks ??
|
|
Damage * TargetsList::getNextDamageTarget(Damage * previous)
|
|
{
|
|
Damage * damage = (Damage *) getNextInterruptible(previous, ACTION_DAMAGE);
|
|
return damage;
|
|
}
|
|
|
|
Damageable * TargetsList::getNextDamageableTarget(Damageable * previous)
|
|
{
|
|
int found = 0;
|
|
if (!previous) found = 1;
|
|
for (int i = 0; i < cursor; i++)
|
|
{
|
|
|
|
if (targets[i]->typeAsTarget() == TARGET_PLAYER)
|
|
{
|
|
if (found)
|
|
{
|
|
return ((Player *) targets[i]);
|
|
}
|
|
else
|
|
{
|
|
if ((Player *) targets[i] == previous) found = 1;
|
|
}
|
|
}
|
|
else if (targets[i]->typeAsTarget() == TARGET_CARD)
|
|
{
|
|
if (found)
|
|
{
|
|
return ((MTGCardInstance *) targets[i]);
|
|
}
|
|
else
|
|
{
|
|
if ((MTGCardInstance *) targets[i] == previous) found = 1;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|