public LevelScript(JSONTable template)
{
spawns = new List<List<MinionType>>();
name = template.getString("name", "UNNAMED");
JSONArray spawnTemplate = template.getArray("monsters");
for (int Idx = 0; Idx < spawnTemplate.Length; ++Idx)
{
List<MinionType> thisTurn = new List<MinionType>();
foreach (string minion in spawnTemplate.getArray(Idx).asStrings())
{
MinionType type = MinionType.get(minion);
thisTurn.Add(type);
}
spawns.Add(thisTurn);
}
scenery = new List<KeyValuePair<MinionType, Point>>();
foreach (JSONArray entry in template.getArray("scenery", JSONArray.empty).asJSONArrays())
{
scenery.Add(new KeyValuePair<MinionType,Point>(MinionType.get(entry.getString(0)), new Point(entry.getInt(1), entry.getInt(2))));
}
ongoingEffects = new List<KeyValuePair<Card, Point>>();
foreach (JSONArray entry in template.getArray("ongoingEffects", JSONArray.empty).asJSONArrays())
{
ongoingEffects.Add(new KeyValuePair<Card, Point>(Card.get(entry.getString(0)), new Point(entry.getInt(1), entry.getInt(2))));
}
levelType = LevelType.get(template.getString("type"));
string unlock = template.getString("unlock", null);
if(unlock != null)
unlocksCard = Card.get(unlock);
}
public bool CanUpgrade(Card c)
{
if (c.upgrades == null)
return false;
if (upgrades.ContainsKey(c))
{
return c.upgrades.Count > upgrades[c];
}
return true;
}
public void AddUpgrade(Card c)
{
if (upgrades.ContainsKey(c))
{
upgrades[c]++;
}
else
{
upgrades[c] = 1;
}
}
public TextChanges getTextChanges(Card c)
{
if (cardTextChanges.ContainsKey(c))
return cardTextChanges[c];
else
return TextChanges.none;
}
public CardState GetCardState(Card c)
{
if (choosingCardForCard != null)
{
bool canTarget = playState.CanPlayCard(choosingCardForCard, TriggerItem.create(c));
return canTarget ? CardState.Targetable : CardState.NotTargetable;
}
else if (choosingPositionForCard != null)
{
bool beingPlayed = (choosingPositionForCard == c);
return beingPlayed? CardState.BeingPlayed: CardState.NotPlayable;
}
else
{
bool canPlay = playState.CanPlayCard(c);
return canPlay ? CardState.Playable : CardState.NotPlayable;
}
}
public void ClickedCard(Card card, bool isUpgrade)
{
if (clickHandled)
return;
clickHandled = true;
if (choosingCardForCard != null)
{
playing = choosingCardForCard;
playTargetCard = card;
choosingCardForCard = null;
}
else
{
// if (isUpgrade)
// AddUpgrade(card);
if (card.targetType == TargetType.numeric_spell ||
card.targetType == TargetType.area_spell)
{
choosingCardForCard = card;
}
else if (card.targetType != TargetType.none)
{
choosingPositionForCard = card;
}
else
{
playing = card;
playPosition = playState.wizard.position;
}
}
}
public void ClickedPosition()
{
if (clickHandled)
return;
if (choosingCardForCard != null)
{
//choosingCardForCard = null;
}
else if (choosingPositionForCard != null)
{
Point targetPos = GameState.ScreenToGridPos(Game1.inputState.MousePos);
if (playState.CanPlayCard(choosingPositionForCard, playState.getItemAt(targetPos)))
{
playing = choosingPositionForCard;
playPosition = targetPos;
playTargetCard = null;
clickHandled = true;
}
choosingPositionForCard = null;
}
}
public TriggerEvent(TriggerType type, Card c, TriggerItem target)
{
this.type = type;
this.source = TriggerItem.create(c);
this.target = target;
}
public void ClearPlaying()
{
playing = null;
playTargetCard = null;
clickHandled = false;
}
public void PlayTurn(Card c, Minion caster, TriggerItem target)
{
if (c.effect != null && c.effect is Effect_Rewind)
{
if (gameStates.Count <= 1)
return;
// rewind isn't really a spell like everything else
gameStates.RemoveAt(gameStates.Count - 1);
gameStateOnSkip = gameStates.Last().GetGameStateOnSkip();
selectionState = new UISelectionState(gameStates.Last());
}
else
{
GameState oldGameState = gameStates.Last();
if (oldGameState.CanPlayCard(c, target))
{
nextGameState = new GameState(gameStates.Last());
animation.Clear();
if (caster == null)
caster = nextGameState.wizard;
nextGameState.PlayCard(c, caster, nextGameState.Adapt(target), animation);
nextGameState.TurnEffects(animation);
gameStateOnSkip = nextGameState.GetGameStateOnSkip();
}
}
}
public Ongoing(Card baseCard, Point p)
: base(baseCard.ongoingType, p, false)
{
this.baseCard = baseCard;
}
public bool CanPlayCard(Card card)
{
if (gameEndState == GameEndState.GameOver && (card.effect == null || !(card.effect is Effect_Rewind)))
{
return false;
}
if (playableCards.Contains(card))
{
return true;
}
if (card.ongoingType != null)
{
if (!CanPayCost(CombineCosts(card.cost, card.ongoingType.upkeep)))
{
return false;
}
}
else
{
if (!CanPayCost(card.cost))
{
return false;
}
}
// can't rewind on turn 1
if (parentState == null && card.effect != null && card.effect is Effect_Rewind)
{
return false;
}
playableCards.Add(card);
return true;
}
public void DrawTargetCursor(SpriteBatch spriteBatch, Card playing, Vector2 mousePos)
{
Point p = ScreenToGridPos(mousePos);
bool canPlay = CanPlayCard(playing, getItemAt(p));
spriteBatch.Draw(Game1.gridCursor, GridToScreenPos(p), canPlay? Color.LightGreen: Color.Red);
}
public bool CanPlayCard(Card card, TriggerItem target)
{
switch (card.targetType)
{
case TargetType.numeric_spell:
if (!target.card.HasANumber())
return false;
break;
case TargetType.area_spell:
if (!target.card.HasAnArea())
return false;
break;
case TargetType.empty:
case TargetType.path:
if(target.permanent != null)
return false;
break;
case TargetType.minion:
if (target.permanent == null)
return false;
break;
case TargetType.friend:
if (target.permanent == null || target.permanent.isEnemy)
return false;
break;
case TargetType.enemy:
if (target.permanent == null)
{
return false;
}
else
{
if (!target.permanent.isEnemy)
return false;
}
break;
}
if (card.targetTest != null && !card.targetTest.Test(target, new EffectContext(this, wizard, null, null)))
return false;
if (target.card == null && levelScript.Blocks(target.position, card.targetType))
return false;
return CanPlayCard(card);
}
public void ApplyCardEffect(Card c, Minion caster, TriggerItem target, MinionAnimationSequence animation)
{
TextChanges changes = null;
if (cardTextChanges.ContainsKey(c))
changes = cardTextChanges[c];
ApplyEffect(c.effect, new EffectContext(this, changes, caster, target, new TriggerEvent(TriggerType.onSpell, caster, target.permanent), animation));
if (c.ongoingType != null)
{
Point pos = target.position;
ongoingEffects[pos] = new Ongoing(c, pos);
}
}
public void AddTextChange(Card c, TextChanges.TextChange<int> change)
{
if (cardTextChanges.ContainsKey(c))
{
cardTextChanges[c] = new TextChanges(cardTextChanges[c], change);
}
else
{
cardTextChanges[c] = new TextChanges(change);
}
}
public TriggerItem_Card(Card card)
{
this.mcard = card;
}
public static TriggerItem create(Card card)
{
return new TriggerItem_Card(card);
}
public void PlayCard(Card c, Minion caster, TriggerItem target, MinionAnimationSequence animation)
{
PayCost(c.cost);
HandleTriggers(new TriggerEvent(TriggerType.beforeSpells));
if(Card.get("wait") != c)
HandleTriggers(new TriggerEvent(TriggerType.beforeActualSpell, c));
ApplyCardEffect(c, caster, target, animation);
HandleTriggers(new TriggerEvent(TriggerType.afterSpells));
if (c.effect != null || c.ongoingType != null)
HandleTriggers(new TriggerEvent(TriggerType.afterActualSpell, c));
}
public Card GetUpgrade(Card c)
{
if (upgrades.ContainsKey(c))
{
return c.upgrades[upgrades[c]-1];
}
else
{
return c;
}
}
public Ongoing(Ongoing basis)
: base(basis)
{
this.baseCard = basis.baseCard;
}
public TriggerEvent(TriggerType type, Card c)
{
this.type = type;
this.source = TriggerItem.create(c);
}
