public void getAttacked(int rawDamage)
{
int dmg = rawDamage - armor;
int blockValue = 0;
if (activeBlock != null)
{
blockValue = activeBlock.blockValue;
}
dmg -= blockValue;
dmg = Mathf.Max(0, dmg);
health -= dmg;
activeBlock = null;
refreshUI();
FloatingDamageTextController.Instance().createFloatingDamageText(transform, rawDamage, armor, blockValue, dmg);
if (health <= 0)
{
if (playerCharacter)
{
GameAlertUI.Instance().setText("You died!");
}
else
{
TurnMaster.Instance().handleEnemyDeath(this);
Destroy(gameObject);
}
}
}
public void createBuff(CombatCharacter source, CombatCharacter target)
{
this.target = target;
target.buffs.Add(this);
applyBuff(1);
target.refreshUI();
switch (duration)
{
case BuffDuration.UntilEndOfTurn: {
eventName = TurnMaster.getEndTurnTrigger(source.gameObject.GetInstanceID());
break;
}
case BuffDuration.UntilStartOfNextTurn: {
eventName = TurnMaster.getStartTurnTrigger(source.gameObject.GetInstanceID());
break;
}
case BuffDuration.UntilEndOfTargetsTurn: {
eventName = TurnMaster.getEndTurnTrigger(target.gameObject.GetInstanceID());
break;
}
}
EventManager.StartListening(eventName, removeBuff);
}
public void cardClicked()
{
if (character != null)
{
TurnMaster.Instance().checkTargetListener(cardBase);
attemptToPlayCard();
}
}
public static TurnMaster Instance()
{
if (!turnMaster)
{
turnMaster = FindObjectOfType <TurnMaster>();
}
return(turnMaster);
}
private void resetPriority()
{
playerPriorityIndex = 0;
foreach (CombatCharacter character in TurnMaster.Instance().charactersInCombat)
{
character.passedPriority = false;
}
}
public void addToStack(BaseCard card)
{
TurnMaster.Instance().setContinueButton(false);
theStack.Add(card);
resetPriority();
precastAbilityIndex = 0;
resolvingPrecastTriggers = true;
executeCurrentPrecastTrigger();
}
private void Update()
{
if (!targetSource.character.playerCharacter)
{
if (targetCatgeory == TargetCategory.Enemy)
{
TurnMaster.Instance().checkTargetListener(CombatCharacter.Player());
}
}
}
public override int getAbilitiesLength()
{
if (TurnMaster.Instance().activeCharacter() == character)
{
return(abilities.Length);
}
else
{
return(otherTurnAbilities.Length);
}
}
public override BaseAbility getAbility(int index)
{
if (TurnMaster.Instance().activeCharacter() == character)
{
return(abilities[index]);
}
else
{
return(otherTurnAbilities[index]);
}
}
private new void Start()
{
base.Start();
if (character == null)
{
character = GetComponentInParent <BaseCard>().character;
}
EventManager.StartListening(TurnMaster.getStartTurnTrigger(character.gameObject.GetInstanceID()), startGlow);
EventManager.StartListening(TurnMaster.getEndTurnTrigger(character.gameObject.GetInstanceID()), endGlow);
if (TurnMaster.Instance().activeCharacter() == character)
{
startGlow();
}
}
private new void Start() {
base.Start();
if (character == null) {
character = GetComponentInParent<BaseCard>().character;
}
if (!glowOnlyOnActivePlayer || (glowOnlyOnActivePlayer && character.playerCharacter)) {
EventManager.StartListening(TurnMaster.getStartPhaseTrigger(glowPhase, character.gameObject.GetInstanceID()), startGlow);
EventManager.StartListening(TurnMaster.getEndPhaseTrigger(glowPhase, character.gameObject.GetInstanceID()), endGlow);
if (TurnMaster.currentPhase == glowPhase) {
startGlow();
}
}
}
private bool playableNow()
{
return(character == StackController.Instance().getPriorityCharacter() &&
(character == TurnMaster.Instance().activeCharacter() &&
TurnMaster.currentPhase == Phase.Action &&
StackController.Instance().theStack.Count == 0 &&
(subTypes.Contains(CardSubType.Skill) ||
subTypes.Contains(CardSubType.Attack))) ||
(character != TurnMaster.Instance().activeCharacter() &&
TurnMaster.currentPhase == Phase.Action &&
StackController.Instance().isCharacterBeingTargeted(character) &&
(subTypes.Contains(CardSubType.Fast) ||
(subTypes.Contains(CardSubType.Defend) &&
character.activeBlock == null &&
!StackController.Instance().isCardSubTypeInStack(CardSubType.Defend)))));
}
public void continueWithAdventure()
{
if (preBattle)
{
List <CombatCharacter> enemies = EnemySpawner.Instance().spawnEnemies(currentEncounter.enemies);
TurnMaster.Instance().startBattle(enemies);
}
else
{
currentEncounter = adventure.getNextEncounter();
if (currentEncounter == null)
{
finishAdventure();
}
else
{
startEncounter();
}
}
}
private void Awake()
{
shuffleDeck();
activeBlock = null;
EventManager.StartListening(TurnMaster.getGenericStartPhaseTrigger(), refreshUI);
EventManager.StartListening(TurnMaster.getStartPhaseTrigger(Phase.Draw, gameObject.GetInstanceID()), drawStep);
if (!playerCharacter)
{
EventManager.StartListening(TurnMaster.getEndTurnTrigger(gameObject.GetInstanceID()), turnOffUI);
}
if (equippedWeapon != null)
{
equippedWeapon.equip(this);
}
if (equippedArmor != null)
{
equippedArmor.equip(this);
}
}
public bool hasPlay()
{
bool hasPlay = false;
if (!passedPriority)
{
foreach (BaseCard card in hand.cards)
{
if (card.details.isCardPlayable())
{
hasPlay = true;
}
}
if (!hasPlay &&
playerCharacter &&
isSideboardAllowedNow() &&
atleastOneSideboardLearnable())
{
hasPlay = true;
}
}
if (hasPlay)
{
if (playerCharacter)
{
TurnMaster.Instance().setContinueButton(true);
}
else
{
ai.nudgeAIForDecision();
}
return(true);
}
else
{
return(false);
}
}
public override bool checkTarget(Targetable target)
{
if (targetCatgeory == TargetCategory.Enemy &&
target is CombatCharacter &&
target != targetSource.character &&
(!uniqueTargets || (uniqueTargets && !targets.Contains(target))))
{
targets.Add(target);
}
else if (targetCatgeory == TargetCategory.CardInOwnHand &&
target is BaseCard)
{
BaseCard card = target as BaseCard;
if (card.character.hand.cards.Contains(card))
{
targets.Add(target);
}
}
bool resolve = false;
if (targets.Count == targetCount)
{
resolve = true;
}
else if (uniqueTargets)
{
if (targetCatgeory == TargetCategory.Enemy &&
target is CombatCharacter)
{
CombatCharacter tarCharacter = target as CombatCharacter;
if (tarCharacter.playerCharacter)
{
resolve = true;
}
else if (targets.Count == (TurnMaster.Instance().charactersInCombat.Count - 1))
{
resolve = true;
}
}
else if (targetCatgeory == TargetCategory.CardInOwnHand &&
target is BaseCard)
{
BaseCard card = target as BaseCard;
if (targets.Count == card.character.hand.cards.Count)
{
resolve = true;
}
}
}
if (resolve)
{
multiTargetSourceAbility.resolveTargeting(targets);
return(true);
}
else
{
return(false);
}
}
public void informOfRealDad(TurnMaster master)
{
keeper = master;
}
public CombatCharacter getPriorityCharacter()
{
int index = (playerPriorityIndex + TurnMaster.Instance().currentCharacterTurnIndex) % TurnMaster.Instance().charactersInCombat.Count;
return(TurnMaster.Instance().charactersInCombat[index]);
}
private void OnMouseDown()
{
TurnMaster.Instance().checkTargetListener(this);
}
private bool isSideboardAllowedNow()
{
return(this == TurnMaster.Instance().activeCharacter() &&
TurnMaster.currentPhase == Phase.Action &&
StackController.Instance().theStack.Count == 0);
}
private void Update()
{
if (TurnMaster.Instance().gameStarted)
{
if (waitTimer > 0)
{
waitTimer -= Time.deltaTime;
}
else
{
bool movingCard = false;
foreach (BaseCard card in theStack)
{
if (card.lerping)
{
movingCard = true;
break;
}
}
if (resolvingPrecastTriggers)
{
if (stackTop().details.getAbility(precastAbilityIndex).isPrecastResolved())
{
precastAbilityIndex++;
if (precastAbilityIndex == stackTop().details.getAbilitiesLength())
{
resolvingPrecastTriggers = false;
}
else
{
executeCurrentPrecastTrigger();
}
}
}
else if (resolvingAbilities)
{
resolveTopOfStack();
}
else if (movingCard)
{
// Do nothing?
}
else if (transitionPhases)
{
phaseBuffer += Time.deltaTime;
if (phaseBuffer >= phaseBufferLength)
{
TurnMaster.Instance().incrementPhase();
transitionPhases = false;
phaseBuffer = 0.0f;
}
}
else
{
bool someoneHasPlay = false;
for (; playerPriorityIndex < TurnMaster.Instance().charactersInCombat.Count; playerPriorityIndex++)
{
CombatCharacter character = getPriorityCharacter();
someoneHasPlay = character.hasPlay();
if (someoneHasPlay)
{
break;
}
}
if (!someoneHasPlay)
{
resetPriority();
if (theStack.Count == 0)
{
transitionPhases = true;
}
else
{
resolvingAbilities = true;
}
}
}
}
}
}
public void informOfRealDad(TurnMaster master)
{
this.turnMaster = master;
}
public void informOfRealDad(TurnMaster master)
{
}
private void Awake()
{
TurnMaster.Instance().targetListener = this;
}
