internal void EndOfATurn()
{
foreach (CastedCard c in Effects.ToArray())
{
if (c.Card.CardPersistency == CardPersistency.UntilEndTurn)
{
Effects.Remove(c);
}
}
if (Card.Effects.ContainsKey(Effect.AtEndTurn))
{
foreach (Card atEndTurn in Card.Effects[Effect.AtEndTurn])
{
if (atEndTurn.CardTarget == CardTarget.Self)
{
PanelTile pt = PanelMinigame.Me.PanelBoardFront.GetComponent <PanelTiles>().FindTileForModel(this);
PanelTile heroTile = PanelMinigame.Me.PanelBoardFront.GetComponent <PanelTiles>().FindTileForModel(GetMyHero());
PanelMinigame.Me.CastSpell(pt, atEndTurn, pt, heroTile, true, 0, true);
}
else
{
throw new NotImplementedException("Implement at end turn card target: " + atEndTurn.CardTarget);
}
}
}
foreach (AvatarModel am in Minions)
{
am.EndOfATurn();
}
}
internal int GetDistanceTo(PanelTile to)
{
int d = Mathf.Abs(to.Row - Row) + Mathf.Abs(to.Column - Column);
if (to.Row != Row && to.Column != Column)
{
d--;
}
return(d);
}
internal List <PanelTile> GetAllPanelTiles()
{
List <PanelTile> tmp = new List <PanelTile>();
foreach (GameObject go in GetComponent <ScrollableList>().ElementsToPut)
{
PanelTile pt = go.GetComponent <PanelTile>();
tmp.Add(pt);
}
return(tmp);
}
internal List <PanelAvatar> GetAllPanelAvatars()
{
List <PanelAvatar> tmp = new List <PanelAvatar>();
foreach (GameObject go in GetComponent <ScrollableList>().ElementsToPut)
{
PanelTile pt = go.GetComponent <PanelTile>();
PanelAvatar pa = go.GetComponent <PanelTile>().PanelAvatar.GetComponent <PanelAvatar>();
if (pa != null)
{
tmp.Add(pa);
}
}
return(tmp);
}
internal List <AvatarModel> GetAllAvatarModels()
{
List <AvatarModel> tmp = new List <AvatarModel>();
foreach (GameObject go in GetComponent <ScrollableList>().ElementsToPut)
{
PanelTile pt = go.GetComponent <PanelTile>();
AvatarModel am = go.GetComponent <PanelTile>().PanelAvatar.GetComponent <PanelAvatar>().Model;
if (am != null)
{
tmp.Add(am);
}
}
return(tmp);
}
private void FillFileFlowPanel(int id)
{
View.CategoryFiles.FileFlowLayout.Controls.Clear();
IEnumerable <File> files =
File.Select("CATEGORYID = " + id.ToSqlFormat());
foreach (File file in files)
{
var pt = new PanelTile(file.Name, file.Description);
pt.Tag = file;
pt.pictureBox1.ImageLocation = setFileImage(file.Name);
pt.pictureBox1.Click += pt_Click;
View.CategoryFiles.FileFlowLayout.Controls.Add(pt);
}
}
internal void CardInHandSelected(Card card, bool alreadyPaidFor)
{
if (Mode != global::Mode.CastingSpellNoCancel)
{
AnimationRequests.Add(new AnimationRequestStruct(ActualTurnModel, AnimationRequest.CardInHandSelected, card));
PanelCardPreview.GetComponent <PanelCardPreview>().PreviewCard(ActualTurnModel, card, WhereAmI.TopInfo);
DisableAllPanelsInteraction();
Mode = global::Mode.Ready;
if (card.Cost <= ActualTurnModel.ActualMana)
{
//getting your main character
PanelTile panelTile = PanelBoardFront.GetComponent <PanelTiles>().FindTileForModel(ActualTurnModel);
CastSpell(panelTile, card, panelTile, panelTile, false, card.Cost, alreadyPaidFor);
}
}
}
internal void UpdateAdjacentModels()
{
foreach (GameObject go in GetComponent <ScrollableList>().ElementsToPut)
{
PanelTile pt = go.GetComponent <PanelTile>();
AvatarModel am = go.GetComponent <PanelTile>().PanelAvatar.GetComponent <PanelAvatar>().Model;
if (am != null)
{
foreach (Side s in SideMethods.AllSides())
{
if (pt.Neighbours.ContainsKey(s))
{
am.AdjacentModels[s] = pt.Neighbours[s].PanelAvatar.GetComponent <PanelAvatar>().Model;
}
}
}
}
}
public bool CastSpell(PanelTile target, Card card, PanelTile caster, PanelTile castingHero, bool explicitlySelectedTile, int cost, bool noCancel)
{
bool anyActionDone = false;
//Debug.Log("Casting spell " + card.Name + " by: " + caster.PanelAvatar.GetComponent<PanelAvatar>().Model.Card.Name + ", already paid? " + (alreadyPaidFor?"yes":"no"));
if (explicitlySelectedTile)
{
foreach (PanelTile pt in PanelBoardFront.GetComponent <PanelTiles>().GetAllPanelTiles())
{
if (castingHero.CanHeHaveThisSpell(target, pt, card))
{
Debug.Log(castingHero.PanelAvatar.GetComponent <PanelAvatar>().Model.Card.Name + " is casting on " + pt.gameObject.name + " card: " + card.Name);
castingHero.PanelAvatar.GetComponent <PanelAvatar>().CastOn(pt.PanelAvatar.GetComponent <PanelAvatar>(), card);
anyActionDone = true;
}
}
if (anyActionDone)
{
castingHero.PanelAvatar.GetComponent <PanelAvatar>().Model._ActualMana -= cost;
}
}
else
{
List <PanelTile> pts = PanelBoardFront.GetComponent <PanelTiles>().GetAllPanelTiles();
foreach (PanelTile pt in pts)
{
if (CanBeCastedOn(caster, pt, card))
{
anyActionDone = true;
pt.PanelInteraction.GetComponent <PanelInteraction>().CanCastHere(caster, card);
Mode = noCancel?global::Mode.CastingSpellNoCancel:global::Mode.CastingSpell;
}
}
}
return(anyActionDone);
}
private bool CastEffects(PanelTile panelTile)
{
bool allEffectDone = false;
bool allEffectsOnceSetTrue = false;
PanelInteraction pi = panelTile.PanelInteraction.GetComponent <PanelInteraction>();
AvatarModel heroModel = panelTile.PanelAvatar.GetComponent <PanelAvatar>().PanelAvatarCard.GetComponent <PanelAvatarCard>().HeroModel;
AvatarModel targetModel = panelTile.PanelAvatar.GetComponent <PanelAvatar>().Model;
PanelInteractionMode whatMode = pi.Mode;
Card whatCard = pi.CastersCard;
List <Card> cardsToCast = new List <Card>();
if (whatCard.Effects.ContainsKey(Effect.BattlecryNonExistantRandom))
{
Card c = null;
int random = new System.Random().Next(whatCard.Effects[Effect.BattlecryNonExistantRandom].Length);
int count = 0;
do
{
random++;
count++;
if (count > whatCard.Effects[Effect.BattlecryNonExistantRandom].Length)
{
c = null;
break;
}
if (random >= whatCard.Effects[Effect.BattlecryNonExistantRandom].Length)
{
random = 0;
}
c = whatCard.Effects[Effect.BattlecryNonExistantRandom][random];
//check if exists on board
} while (PanelBoardFront.GetComponent <PanelTiles>().IsModelOfCard(c));
if (c != null)
{
cardsToCast.Add(c);
}
}
if (whatCard.Effects.ContainsKey(Effect.Battlecry))
{
Debug.Log("There is battlecry for " + whatCard.Name);
cardsToCast.AddRange(whatCard.Effects[Effect.Battlecry]);
Card[] battlecryCards = whatCard.Effects[Effect.Battlecry];
}
if (whatCard.Effects.ContainsKey(Effect.WhileAlive) && whatCard.Effects[Effect.WhileAlive][0].CardPersistency == CardPersistency.WhileHolderAlive)
{
cardsToCast.AddRange(whatCard.Effects[Effect.WhileAlive]);
}
foreach (Card battlecryCard in cardsToCast)
{
bool explicitly = battlecryCard.CardTarget == CardTarget.Self || battlecryCard.CardTarget == CardTarget.EnemyHero;
if (explicitly == false)
{
PanelCardPreview.GetComponent <PanelCardPreview>().PreviewCard(heroModel, battlecryCard, WhereAmI.TopInfo);
}
if (CastSpell(panelTile, battlecryCard, panelTile, pi.Caster, explicitly, 0, true))
{
if (!allEffectsOnceSetTrue)
{
allEffectDone = true;
allEffectsOnceSetTrue = true;
}
}
else
{
allEffectDone = false;
}
}
return(allEffectDone);
}
/* if finished in action */
internal bool PointerDownOn(PanelTile panelTile)
{
bool actionWithBattlecryDone = false;
Debug.Log("pointer down on: " + panelTile.gameObject.name + ", mode: " + Mode);
PanelInteraction pi = panelTile.PanelInteraction.GetComponent <PanelInteraction>();
AvatarModel heroModel = panelTile.PanelAvatar.GetComponent <PanelAvatar>().PanelAvatarCard.GetComponent <PanelAvatarCard>().HeroModel;
AvatarModel targetModel = panelTile.PanelAvatar.GetComponent <PanelAvatar>().Model;
if (Mode != global::Mode.CastingSpellNoCancel)
{
PanelCardPreview.GetComponent <PanelCardPreview>().Preview(heroModel, targetModel, WhereAmI.TopInfo);
}
bool isYourCharacter = ActualTurnModel.IsItYourMinion(targetModel) || ActualTurnModel == heroModel;
switch (Mode)
{
case global::Mode.Ready: {
if (isYourCharacter && targetModel != null && targetModel.MovesLeft > 0 && panelTile.SetInteractionToMoveAround())
{
Mode = global::Mode.MovingOrAttacking;
actionWithBattlecryDone = true;
}
break;
}
case global::Mode.MovingOrAttacking: {
int movesLeft = 0;
PanelTile whatWantsToMoveOrAttackHere = pi.WhatMoveOrAttack;
PanelInteractionMode mode = pi.Mode;
bool hasMoved = false;
if (pi.Mode == PanelInteractionMode.Moving || pi.Mode == PanelInteractionMode.Attacking)
{
whatWantsToMoveOrAttackHere = pi.WhatMoveOrAttack;
if (!isYourCharacter)
{
whatWantsToMoveOrAttackHere.PanelAvatar.GetComponent <PanelAvatar>().Model.MovesLeft--;
movesLeft = whatWantsToMoveOrAttackHere.PanelAvatar.GetComponent <PanelAvatar>().Model.MovesLeft;
actionWithBattlecryDone = true;
}
//is here something?
if (heroModel != null && !isYourCharacter)
{
//battle
whatWantsToMoveOrAttackHere.PanelAvatar.GetComponent <PanelAvatar>().BattleOutWith(panelTile.PanelAvatar.GetComponent <PanelAvatar>());
if (panelTile.PanelAvatar.GetComponent <PanelAvatar>().Model == null)
{
//move if killed
panelTile.PanelAvatar.GetComponent <PanelAvatar>().Model = whatWantsToMoveOrAttackHere.PanelAvatar.GetComponent <PanelAvatar>().Model;
whatWantsToMoveOrAttackHere.PanelAvatar.GetComponent <PanelAvatar>().Model = null;
hasMoved = true;
}
}
else
{
//move
panelTile.PanelAvatar.GetComponent <PanelAvatar>().Model = whatWantsToMoveOrAttackHere.PanelAvatar.GetComponent <PanelAvatar>().Model;
whatWantsToMoveOrAttackHere.PanelAvatar.GetComponent <PanelAvatar>().Model = null;
hasMoved = true;
}
}
DisableAllPanelsInteraction();
Mode = global::Mode.Ready;
//automatically enter next move interaction if moves are left
if (movesLeft > 0)
{
Debug.Log("Moves left: " + movesLeft);
if (panelTile.PanelAvatar.GetComponent <PanelAvatar>().Model != null && hasMoved)
{
PointerDownOn(panelTile);
}
else
{
PointerDownOn(whatWantsToMoveOrAttackHere);
}
}
break;
}
case global::Mode.CastingSpellNoCancel: {
if (pi.Mode == PanelInteractionMode.Casting)
{
actionWithBattlecryDone = CastSpell(panelTile, pi.CastersCard, pi.Caster, pi.Caster, true, 0, true); //if no cancel, then it is already paid (hero power or battlecry)
DisableAllPanelsInteraction();
Mode = global::Mode.Ready;
actionWithBattlecryDone = CastEffects(panelTile);
}
break;
}
case global::Mode.CastingSpell: {
PanelInteractionMode pim = pi.Mode;
if (pim == PanelInteractionMode.Casting)
{
actionWithBattlecryDone = CastSpell(panelTile, pi.CastersCard, pi.Caster, pi.Caster, true, pi.CastersCard.Cost, false);
}
DisableAllPanelsInteraction();
Mode = global::Mode.Ready;
if (pim == PanelInteractionMode.Casting && pi.CastersCard != null)
{
actionWithBattlecryDone = CastEffects(panelTile);
}
break;
}
default: throw new NotImplementedException("Implement working with mode: " + Mode);
}
//revalidate effects
RevalidateEffects();
return(actionWithBattlecryDone);
}
public void Build(List <List <TileTemplate> > Buildings)
{
foreach (GameObject go in ElementsToPut)
{
Destroy(go);
}
ElementsToPut.Clear();
itemPrefab.SetActive(true);
List <List <PanelTile> > tiles = new List <List <PanelTile> >();
columnCount = Buildings[0].Count;
foreach (List <TileTemplate> row in Buildings)
{
List <PanelTile> buildingsRow = new List <PanelTile>();
int actualRow = 0;
foreach (TileTemplate bt in row)
{
GameObject newItem = Instantiate(itemPrefab) as GameObject;
PanelTile b = newItem.GetComponent <PanelTile>();
//panel tiles bg doesn't have panelTile
if (b != null)
{
float pan = (actualRow - ((columnCount - 1) / 2f)) / ((columnCount - 1) / 2f);
AvatarModel am = null;
if (bt.Card != null)
{
am = new AvatarModel(bt.Card, true, null);
}
b.PanelAvatar.GetComponent <PanelAvatar>().Model = am;
}
ElementsToPut.Add(newItem);
buildingsRow.Add(b);
actualRow++;
}
tiles.Add(buildingsRow);
}
Prepare();
//create neighbours -> optimization
int x = 0;
foreach (List <PanelTile> cols in tiles)
{
int y = 0;
foreach (PanelTile bi in cols)
{
//panel tiles bg doesn't have panelTile
if (bi == null)
{
continue;
}
PanelTile bu = bi.GetComponent <PanelTile>();
if (tiles.Count > x + 1)
{
bu.Neighbours.Add(Side.Down, tiles[x + 1][y]);
}
if (tiles[x].Count > y + 1)
{
bu.Neighbours.Add(Side.Right, tiles[x][y + 1]);
}
if (x - 1 >= 0)
{
bu.Neighbours.Add(Side.Up, tiles[x - 1][y]);
}
if (y - 1 >= 0)
{
bu.Neighbours.Add(Side.Left, tiles[x][y - 1]);
}
if (x - 1 >= 0 && y - 1 >= 0)
{
bu.Neighbours.Add(Side.UpLeft, tiles[x - 1][y - 1]);
}
if (x - 1 >= 0 && tiles[x - 1].Count > y + 1)
{
bu.Neighbours.Add(Side.UpRight, tiles[x - 1][y + 1]);
}
if (tiles.Count > x + 1 && y - 1 >= 0)
{
bu.Neighbours.Add(Side.DownLeft, tiles[x + 1][y - 1]);
}
if (tiles.Count > x + 1 && tiles[x + 1].Count > y + 1)
{
bu.Neighbours.Add(Side.DownRight, tiles[x + 1][y + 1]);
}
y++;
}
x++;
}
itemPrefab.SetActive(false);
}
internal void CanAttackHere(PanelTile panelTile)
{
WhatMoveOrAttack = panelTile;
Mode = PanelInteractionMode.Attacking;
}
public void Touched(BaseEventData bed)
{
try {
switch (WhereAmI)
{
case global::WhereAmI.Board:
PanelMinigame.Me.GetComponent <PanelMinigame>().PointerDownOn(gameObject.transform.parent.gameObject.transform.parent.gameObject.GetComponent <PanelTile>());
break;
case global::WhereAmI.Hand:
PanelMinigame.Me.GetComponent <PanelMinigame>().CardInHandSelected(Card, false);
break;
case global::WhereAmI.SpecialPower:
if (PanelMinigame.Me.Mode != Mode.CastingSpellNoCancel)
{
PanelMinigame.Me.PanelCardPreview.GetComponent <PanelCardPreview>().PreviewCard(PanelMinigame.Me.ActualTurnModel, Card, global::WhereAmI.TopInfo);
if (HeroModel == PanelMinigame.Me.ActualTurnModel && HeroModel.ActualMana >= Card.Cost && !HeroModel.AlreadyUsedPower)
{
bool anyActionDone = false;
PanelMinigame.Me.CardInHandSelected(Card, true);
if (Card.CardTarget == CardTarget.Self)
{
PanelTile actualTurnHerosTile = PanelMinigame.Me.PanelBoardFront.GetComponent <PanelTiles>().FindTileForModel(PanelMinigame.Me.ActualTurnModel);
anyActionDone = PanelMinigame.Me.PointerDownOn(actualTurnHerosTile);
}
if (Card.CardTarget == CardTarget.EnemyHero)
{
PanelTile actualTurnHerosTile = PanelMinigame.Me.PanelBoardFront.GetComponent <PanelTiles>().FindTileForModel(PanelMinigame.Me.ActualTurnModel == PanelMinigame.Me.MyModel ? PanelMinigame.Me.EnemysModel : PanelMinigame.Me.MyModel);
anyActionDone = PanelMinigame.Me.PointerDownOn(actualTurnHerosTile);
}
//mana deduction has to be after pointer down on, because the spell will no select
if (anyActionDone)
{
HeroModel.AlreadyUsedPower = true;
HeroModel._ActualMana -= Card.Cost;
PanelMinigame.Me.RevalidateEffects();
}
else
{
PanelMinigame.Me.PanelInformation.GetComponent <PanelInformation>().SetText("There is no place or target for special power");
}
}
}
break;
case global::WhereAmI.TopInfo:
//nothing to do here;
Debug.Log("Touched in top info");
break;
default:
throw new NotImplementedException("Not implemented");
}
} catch (Exception e) {
Debug.Log("Exception: " + e);
}
}
internal bool CanHeHaveThisSpell(PanelTile target, PanelTile onWhat, Card card)
{
AvatarModel casterModel = PanelAvatar.GetComponent <PanelAvatar>().Model;
AvatarModel targetModel = target.PanelAvatar.GetComponent <PanelAvatar>().Model;
AvatarModel onWhatModel = onWhat.PanelAvatar.GetComponent <PanelAvatar>().Model;
bool canIHave = false;
switch (card.IsCastOn)
{
case IsCastOn.Target:
canIHave = onWhat == target;
break;
case IsCastOn.FriendlyMinions:
canIHave = onWhatModel != null && casterModel.GetMyHero().IsItYourMinion(onWhatModel);
break;
case IsCastOn.AdjacentCharacters:
if (onWhatModel != null)
{
foreach (Side s in SideMethods.AllSides())
{
//we have to compare panelTiles instead of AvatarModels, because we could compare null to null
if (target.Neighbours.ContainsKey(s) && target.Neighbours[s] == onWhat)
{
canIHave = true;
}
}
}
break;
case IsCastOn.AllCharactersInLineFromThis:
//define the line
int dRow = target.Row - Row;
int dCol = target.Column - Column;
Side s2 = SideMethods.GetSide(dRow, dCol);
PanelTile tmp = target;
bool thisIsOnLine = false;
while (tmp != null)
{
thisIsOnLine = tmp == onWhat;
if (thisIsOnLine)
{
break;
}
if (tmp.Neighbours.ContainsKey(s2))
{
tmp = tmp.Neighbours[s2];
}
else
{
break;
}
}
canIHave = thisIsOnLine;
break;
case IsCastOn.AdjacentMinions:
if (onWhatModel != null && onWhatModel.Card.CardPersistency == CardPersistency.Minion)
{
foreach (Side s in SideMethods.AllSides())
{
//we have to compare panelTiles instead of AvatarModels, because we could compare null to null
if (target.Neighbours.ContainsKey(s) && target.Neighbours[s] == onWhat)
{
canIHave = true;
}
}
}
break;
case IsCastOn.FriendlyAdjacentMinions:
if (onWhatModel != null && casterModel.GetMyHero().IsItYourMinion(onWhatModel))
{
foreach (Side s in SideMethods.AllSides())
{
//we have to compare panelTiles instead of AvatarModels, because we could compare null to null
if (Neighbours.ContainsKey(s) && Neighbours[s] == onWhat)
{
canIHave = true;
}
}
}
break;
case IsCastOn.FriendlyAdjacentCharacters:
if (onWhatModel != null && (casterModel.GetMyHero().IsItYourMinion(onWhatModel) || targetModel.GetMyHero() == casterModel))
{
foreach (Side s in SideMethods.AllSides())
{
//we have to compare panelTiles instead of AvatarModels, because we could compare null to null
if (Neighbours.ContainsKey(s) && Neighbours[s] == onWhat)
{
canIHave = true;
}
}
}
break;
case IsCastOn.OtherFriendlyMinions:
canIHave = onWhatModel != null && casterModel.GetMyHero().IsItYourMinion(onWhatModel) && targetModel != onWhatModel;
break;
case IsCastOn.EnemyCharacters:
canIHave = onWhatModel != null && onWhatModel.GetMyHero() != casterModel.GetMyHero();
break;
case IsCastOn.OtherItsCharacters:
canIHave = onWhatModel != null && onWhatModel != targetModel && targetModel.GetMyHero() == onWhatModel.GetMyHero();
break;
case IsCastOn.FriendlyHero:
canIHave = casterModel.GetMyHero() == onWhatModel;
break;
case IsCastOn.EnemyMinions:
canIHave = onWhatModel != null && onWhatModel.GetMyHero() != casterModel.GetMyHero() && onWhatModel.GetMyHero().IsItYourMinion(onWhatModel);
break;
case IsCastOn.FriendlyCharacters:
canIHave = onWhatModel != null && casterModel.IsFriendlyCharacter(onWhatModel);
break;
case IsCastOn.EnemyHero:
canIHave = onWhatModel != null && onWhatModel.Card.CardPersistency == CardPersistency.Hero && !onWhatModel.IsFriendlyCharacter(casterModel);
break;
default:
throw new NotImplementedException("Implement case: " + card.IsCastOn);
}
return(canIHave);
}
internal void CanCastHere(PanelTile caster, Card card)
{
Caster = caster;
CastersCard = card;
Mode = PanelInteractionMode.Casting;
}
private bool CanBeCastedOn(PanelTile caster, PanelTile castedOn, Card card)
{
AvatarModel castersModel = caster.PanelAvatar.GetComponent <PanelAvatar>().Model;
AvatarModel castedOnModel = castedOn.PanelAvatar.GetComponent <PanelAvatar>().Model;
bool canCast = false;
switch (card.CardTarget)
{
case CardTarget.Minion:
canCast = castedOnModel != null && castedOnModel.Card.CardPersistency != CardPersistency.Hero;
break;
case CardTarget.Empty:
canCast = castedOnModel == null;
break;
case CardTarget.FriendlyMinion:
canCast = castedOnModel != null && castedOnModel.Card.CardPersistency != CardPersistency.Hero && castersModel.GetMyHero().IsItYourMinion(castedOnModel);
break;
case CardTarget.EnemyMinion:
canCast = castedOnModel != null && castedOnModel.Card.CardPersistency == CardPersistency.Minion && castedOnModel.GetMyHero() != castersModel.GetMyHero();
break;
case CardTarget.Self:
canCast = castersModel == castedOnModel;
break;
case CardTarget.Character:
canCast = castedOnModel != null;
break;
case CardTarget.OtherFriendlyMinion:
canCast = castersModel != castedOnModel && castedOnModel != null && castedOnModel.Card.CardPersistency != CardPersistency.Hero && castersModel.GetMyHero().IsItYourMinion(castedOnModel);
break;
case CardTarget.OtherCharacter:
canCast = castersModel != castedOnModel && castedOnModel != null;
break;
case CardTarget.AnyOther:
canCast = castersModel != castedOnModel;
break;
case CardTarget.Any:
canCast = true;
break;
case CardTarget.EnemyCharacter:
canCast = castedOnModel != null && !castersModel.GetMyHero().IsItYourMinion(castedOnModel) && castersModel.GetMyHero() != castedOnModel.GetMyHero();
break;
case CardTarget.EnemyHero:
canCast = castedOnModel != null && !castersModel.IsFriendlyCharacter(castedOnModel) && castedOnModel.Card.CardPersistency == CardPersistency.Hero;
break;
default:
throw new NotImplementedException("Not implemented " + card.CardTarget);
}
//we have to check the distance
if (canCast)
{
int distance = caster.GetDistanceTo(castedOn);
//Debug.Log("Distance between " + castersModel.Card.Name + " and " + castedOn.Row + ", " + castedOn.Column + " is " + distance);
canCast = distance <= card.CastDistance;
}
return(canCast);
}
public bool SetInteractionToMoveAround()
{
bool canMove = false;
//check for adjacent taunt
//check for adjacent sticky enemy characters
bool foundTaunt = false;
bool foundStickyEnemy = false;
List <Side> whereTaunts = new List <Side>();
foreach (Side s in SideMethods.AllSides())
{
if (Neighbours.ContainsKey(s))
{
AvatarModel m = Neighbours[s].PanelAvatar.GetComponent <PanelAvatar>().Model;
if (m != null && !m.IsFriendlyCharacter(PanelAvatar.GetComponent <PanelAvatar>().Model))
{
foreach (CastedCard cc in m.Effects)
{
if (cc.Params.ContainsKey(CastedCardParamType.Taunt))
{
foundTaunt = true;
whereTaunts.Add(s);
}
if (cc.Params.ContainsKey(CastedCardParamType.Sticky))
{
foundStickyEnemy = true;
}
}
}
}
}
AvatarModel am = PanelAvatar.GetComponent <PanelAvatar>().Model;
foreach (Side s in SideMethods.AllSides())
{
if (Neighbours.ContainsKey(s))
{
PanelTile whereMove = Neighbours[s];
if (whereMove.PanelAvatar.GetComponent <PanelAvatar>().Model == null)
{
if (!foundStickyEnemy)
{
whereMove.PanelInteraction.GetComponent <PanelInteraction>().CanMoveHere(this);
canMove = true;
}
}
else if (!PanelAvatar.GetComponent <PanelAvatar>().Model.IsFriendlyCharacter(whereMove.PanelAvatar.GetComponent <PanelAvatar>().Model) &&
am.ActualAttack > 0 &&
(!foundTaunt || whereTaunts.Contains(s)))
{
whereMove.PanelInteraction.GetComponent <PanelInteraction>().CanAttackHere(this);
canMove = true;
}
}
}
return(canMove);
}
