private int ParseTagValue(GameTag tag, string rawValue)
{
int value;
if (tag == GameTag.ZONE)
{
Zone zone;
Enum.TryParse(rawValue, out zone);
value = (int)zone;
}
else if (tag == GameTag.MULLIGAN_STATE)
{
Mulligan state;
Enum.TryParse(rawValue, out state);
value = (int)state;
}
else if (tag == GameTag.PLAYSTATE)
{
PlayState state;
Enum.TryParse(rawValue, out state);
value = (int)state;
}
else if (tag == GameTag.CARDTYPE)
{
CardType type;
Enum.TryParse(rawValue, out type);
value = (int)type;
}
else
{
int.TryParse(rawValue, out value);
}
return(value);
}
public GetGameTagTask(GameTag tag, EntityType entityType, int entityIndex = 0, int numberIndex = 0)
{
Tag = tag;
Type = entityType;
EntityIndex = entityIndex;
NumberIndex = numberIndex;
}
static int GetTagValue(IPlayable me, GameTag tag)
{
if (tag == GameTag.COST)
{
return(me.Cost);
}
if (me is Character c)
{
if (tag == GameTag.ATK)
{
return(c.AttackDamage);
}
else if
(tag == GameTag.HEALTH)
{
return(c.BaseHealth);
}
else
{
return(c[tag]);
}
}
else
{
return(me[tag]);
}
}
public string GetLocString(GameTag gameTag, Locale lang)
{
var tag = Tags.FirstOrDefault(x => x.EnumId == (int)gameTag);
if (tag == null)
{
return(null);
}
if (tag.TypeString != "LocString")
{
return(null);
}
switch (lang)
{
case Locale.deDE:
return(tag.LocStringDeDe);
case Locale.enUS:
return(tag.LocStringEnUs);
case Locale.esES:
return(tag.LocStringEsEs);
case Locale.esMX:
return(tag.LocStringEsMx);
case Locale.frFR:
return(tag.LocStringFrFr);
case Locale.itIT:
return(tag.LocStringItIt);
case Locale.jaJP:
return(tag.LocStringJaJp);
case Locale.koKR:
return(tag.LocStringKoKr);
case Locale.plPL:
return(tag.LocStringPlPl);
case Locale.ptBR:
return(tag.LocStringPtBr);
case Locale.ruRU:
return(tag.LocStringRuRu);
case Locale.zhCN:
return(tag.LocStringZhCn);
case Locale.zhTW:
return(tag.LocStringZhTw);
case Locale.thTH:
return(tag.LocStringThTh);
default:
return(null);
}
}
public int GetTag(GameTag tag)
{
int value;
Tags.TryGetValue(tag, out value);
return(value);
}
public static SelfCondition IsBaseTagValue(GameTag tag, int value, RelaSign relaSign = RelaSign.EQ)
{
return(new SelfCondition(me =>
relaSign == RelaSign.EQ && me.Card[tag] == value ||
relaSign == RelaSign.GEQ && me.Card[tag] >= value ||
relaSign == RelaSign.LEQ && me.Card[tag] <= value));
}
//Create Things
public void AddTag(string tag, string value)
{
GameTag gt = HsConstants.StringToTag(tag);
int i = HsConstants.TagToInt(gt, value);
if (Tags.ContainsKey(gt))
{
IO.LogDebug("Changed GE Tag: " + tag + " to " + i, IO.DebugFile.Hs, false);
Tags[gt] = i;
}
else
{
IO.LogDebug("Added GE Tag: " + tag + " to " + i, IO.DebugFile.Hs, false);
Tags.Add(gt, i);
}
//TRIGGERS TAGS GAME
if (gt.Equals(GameTag.STEP) && i == (int)Step.BEGIN_MULLIGAN)
{
foreach (var item in GetUserHand())
{
IO.LogDebug("Mulligan " + item, IO.DebugFile.Hs);
}
}
}
public static bool SpellImmuneTargetAll(GameTag tag)
{
if (Game.GetOpponentMinions().Any(i => !i.CantTarget && !i.Stealth && i.CheckTag(tag)))
{
return(true);
}
else
{
if (!Game.Opponent.Stealth && Game.Opponent.CheckTag(tag))
{
return(true);
}
else
{
if (Game.GetUserMinions().Any(i => !i.CantTarget && i.CheckTag(tag)))
{
return(true);
}
else
{
if (Game.User.CheckTag(tag))
{
return(true);
}
else
{
return(false);
}
}
}
}
}
public void SetTag(GameTag tag, string value)
{
if(!Tags.ContainsKey(tag))
Tags.Add(tag, ParseTagValue(tag, value));
else
Tags[tag] = ParseTagValue(tag, value);
}
/// <summary>
/// Defines a kind of effects in which the given tags are boolean and determined by a specific condition. (e.g. Southsea Deckhand)
/// </summary>
public AdaptiveEffect(SelfCondition condition, GameTag tag)
{
_isSwitching = true;
_tag = tag;
_condition = condition;
_operator = EffectOperator.SET;
}
private int ParseTagValue(GameTag tag, string rawValue)
{
int value;
if(tag == GameTag.ZONE)
{
Zone zone;
Enum.TryParse(rawValue, out zone);
value = (int)zone;
}
else if(tag == GameTag.MULLIGAN_STATE)
{
Mulligan state;
Enum.TryParse(rawValue, out state);
value = (int)state;
}
else if(tag == GameTag.PLAYSTATE)
{
PlayState state;
Enum.TryParse(rawValue, out state);
value = (int)state;
}
else if(tag == GameTag.CARDTYPE)
{
CardType type;
Enum.TryParse(rawValue, out type);
value = (int)type;
}
else
int.TryParse(rawValue, out value);
return value;
}
public async Task <Game> HandleAsync(int userId)
{
Game historyGame = FindHistoryGame(userId);
// Create if not exist
if (!(historyGame is null))
{
return(historyGame);
}
historyGame = new Game {
CreatorId = userId
};
context.Games.Add(historyGame);
await context.SaveChangesAsync().ConfigureAwait(false);
var tag = new GameTag
{
Tags = GameTags.CustomLevelsHistory,
UserId = userId,
GameId = historyGame.GameId
};
context.GameTags.Add(tag);
await context.SaveChangesAsync().ConfigureAwait(false);
return(historyGame);
}
public SetGameTagTask(GameTag tag, int amount, EntityType entityType, bool ignoreDamage = false)
{
Tag = tag;
Amount = amount;
Type = entityType;
IgnoreDamage = ignoreDamage;
}
/// <summary>
/// Defines a kind of effects in which the given tag varies with the value from the given function. (e.g. giants)
/// </summary>
public AdaptiveEffect(GameTag tag, EffectOperator @operator, Func <Playable, int> valueFunc)
{
//_on = true;
_tag = tag;
_operator = @operator;
_valueFunction = valueFunc;
}
public void SetTag(GameTag tag, int value)
{
if(!Tags.ContainsKey(tag))
Tags.Add(tag, value);
else
Tags[tag] = value;
}
public async Task <IActionResult> PutGameTag(int idGame, int idTag, [FromBody] GameTag gameTag)
{
if (idTag == gameTag.TagId && idGame == gameTag.GameId)
{
_context.Entry(gameTag).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (await GameTagService.DoesExist(idGame, idTag))
{
throw;
}
else
{
return(NotFound());
}
}
return(AcceptedAtAction(nameof(GetOne), new { idGame = gameTag.GameId, idTag = gameTag.TagId }, gameTag));
}
return(BadRequest());
}
public void TagChange(IHsGameState gameState, GameTag tag, int id, int value, IGame game, bool isCreationTag = false)
{
if (!game.Entities.ContainsKey(id))
{
game.Entities.Add(id, new Entity(id));
}
var prevValue = game.Entities[id].GetTag(tag);
if (value == prevValue)
{
return;
}
var entity = game.Entities[id];
entity.SetTag(tag, value);
if (isCreationTag)
{
var action = _tagChangeActions.FindAction(tag, game, gameState, id, value, prevValue);
if (action != null)
{
entity.Info.HasOutstandingTagChanges = true;
_creationTagActionQueue.Enqueue(new Tuple <int, Action>(id, action));
}
}
else
{
_tagChangeActions.FindAction(tag, game, gameState, id, value, prevValue)?.Invoke();
}
}
public void ChangeTag(int entity_id, GameTag tag, int tag_value)
{
if (!this.entities_.Items.ContainsKey(entity_id))
{
this.entities_.Add(entity_id, new Entity(entity_id, current_blocks_));
}
int prev_value = -1;
bool has_prev_value = this.entities_.Items[entity_id].HasTag(tag);
if (has_prev_value)
{
prev_value = this.entities_.Items[entity_id].GetTag(tag);
}
this.entities_.ChangeTag(entity_id, tag, tag_value);
switch (tag)
{
case GameTag.MULLIGAN_STATE:
this.MulliganStateChanged(entity_id, GameTag.MULLIGAN_STATE, has_prev_value, prev_value, tag_value);
break;
}
// trigger end-turn action
if (entity_id == this.GameEntityId && tag == GameTag.STEP && tag_value == (int)TAG_STEP.MAIN_END)
{
if (this.EndTurnEvent != null)
{
this.EndTurnEvent(this, new EndTurnEventArgs());
}
}
}
private static void ControllerTagChange(Controller c, GameTag t, int value)
{
if (t == GameTag.CURRENT_PLAYER && value == 1)
{
c.Game.CurrentPlayer = c;
return;
}
// ControllerAuraEffects.
// TODO: Remove this switch table.
switch (t)
{
case GameTag.TIMEOUT:
case GameTag.SPELLPOWER_DOUBLE:
case GameTag.SPELL_HEALING_DOUBLE:
case GameTag.HERO_POWER_DOUBLE:
case GameTag.HEALING_DOES_DAMAGE:
case GameTag.CHOOSE_BOTH:
case GameTag.SPELLS_COST_HEALTH:
case GameTag.EXTRA_BATTLECRIES_BASE:
case GameTag.EXTRA_END_TURN_EFFECT:
case GameTag.HERO_POWER_DISABLED:
case GameTag.ALL_HEALING_DOUBLE:
case GameTag.EXTRA_MINION_BATTLECRIES_BASE:
case GameTag.SPELLPOWER:
c.ControllerAuraEffects[t] = value;
return;
}
c[t] = value;
}
public static int ParseTag(GameTag tag, string rawValue)
{
switch (tag)
{
case ZONE:
return((int)ParseEnum <Zone>(rawValue));
case MULLIGAN_STATE:
return((int)ParseEnum <Mulligan>(rawValue));
case PLAYSTATE:
return((int)ParseEnum <PlayState>(rawValue));
case CARDTYPE:
return((int)ParseEnum <CardType>(rawValue));
case CLASS:
return((int)ParseEnum <CardClass>(rawValue));
case STATE:
return((int)ParseEnum <State>(rawValue));
case STEP:
return((int)ParseEnum <Step>(rawValue));
default:
int value;
int.TryParse(rawValue, out value);
return(value);
}
}
private void OnTriggerExit(Collider other)
{
if (GameTag.IsPlayer(other.gameObject) && !IsPlayerSpawn)
{
canCooldown = true;
}
}
public void TagChange(IHsGameState gameState, GameTag tag, int id, int value, IGame game, bool isCreationTag = false)
{
if(gameState.LastId != id)
{
if(gameState.ProposedKeyPoint != null)
{
ReplayMaker.Generate(gameState.ProposedKeyPoint.Type, gameState.ProposedKeyPoint.Id, gameState.ProposedKeyPoint.Player, game);
gameState.ProposedKeyPoint = null;
}
}
gameState.LastId = id;
if(id > gameState.MaxId)
gameState.MaxId = id;
if(!game.Entities.ContainsKey(id))
game.Entities.Add(id, new Entity(id));
if(!gameState.DeterminedPlayers)
{
var entity = game.Entities[id];
if(tag == CONTROLLER && entity.IsInHand && string.IsNullOrEmpty(entity.CardId))
DeterminePlayers(gameState, game, value);
}
var prevValue = game.Entities[id].GetTag(tag);
game.Entities[id].SetTag(tag, value);
if(isCreationTag)
{
var action = _tagChangeActions.FindAction(tag, game, gameState, id, value, prevValue);
if(action != null)
_creationTagActionQueue.Enqueue(new Tuple<int, Action>(id, action));
}
else
_tagChangeActions.FindAction(tag, game, gameState, id, value, prevValue)?.Invoke();
}
private void OnTriggerEnter(Collider other)
{
if (GameTag.IsPlayer(other.gameObject))
{
gameManager.Victory();
}
}
public GetNativeGameTagTask(GameTag tag, EntityType entityType, bool selfBuffs, int numberIndex = 0)
{
Tag = tag;
Type = entityType;
SelfBuffs = selfBuffs;
_index = numberIndex;
}
public bool CheckTag(GameTag tag)
{
if (Tags.ContainsKey(tag))
{
return(Tags[tag] == 1 ? true : false);
}
return(false);
}
public RandomMinionTask(GameTag tag, int value, int amount = 1, RelaSign relaSign = RelaSign.EQ)
{
Tag = tag;
Value = value;
Type = EntityType.INVALID;
Amount = amount;
RelaSign = relaSign;
}
public RandomMinionTask(GameTag tag, EntityType type, int amount = 1)
{
Tag = tag;
Value = -1;
Type = type;
Amount = amount;
RelaSign = RelaSign.EQ;
}
public int GetTagOrDefault(GameTag tag, int default_val)
{
if (!HasTag(tag))
{
return(default_val);
}
return(GetTag(tag));
}
public TagChangeData(GameTag tag, int value, bool creationTag, int?entityId, string entityName)
{
Tag = tag;
Value = value;
CreationTag = creationTag;
EntityId = entityId;
EntityName = entityName;
}
private void OnTriggerEnter(Collider other)
{
if (GameTag.IsPlayer(other.gameObject))
{
other.gameObject.GetComponent <PlayerManager>().PickUp(PickUpType);
Destroy(gameObject);
}
}
private RandomMinionTask(GameTag tag, int value, EntityType type, int amount, RelaSign relaSign)
{
Tag = tag;
Value = value;
Type = type;
Amount = amount;
RelaSign = relaSign;
}
/// <summary> Applies this enchant on the specified entity and tag.
/// This method will process the stored data and apply it to the provided tag value, when applicable.
/// </summary>
/// <param name="target"> The entity subject.</param>
/// <param name="gameTag"> The game tag which must change.</param>
/// <param name="value"> The value of the corresponding tag. This value is either original (native) or
/// could already be the result of another enchant.</param>
/// <returns> An updated value for the specified tag.</returns>
public int Apply(Core target, GameTag gameTag, int value)
{
int effect = Effects[gameTag];
int result = value + effect;
//Game.Log(LogLevel.DEBUG, BlockType.TRIGGER, "Enchant", $"Card[ind.{target?.OrderOfPlay}.{target}] got enchanted. {gameTag} = {value} + {Effects[gameTag]}");
return(result);
}
public static async Task <int> AddOrGetUserHistoryGame(this InWordsDataContext context, int userId)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var historyGame = (from game in context.Games.Where(d => d.CreatorId == userId)
join tag in context.GameTags.Where(d => d.Tags == GameTags.CustomLevelsHistory)
on game.GameId equals tag.GameId
select game).OrderBy(g => g.GameId).ToArray();
int historyGameId = 0;
if (historyGame.Any())
{
historyGameId = historyGame[0].GameId;
if (historyGame.Length > 1)
{
var historyCollisions = historyGame.Skip(1);
int[] ids = historyCollisions.Select(d => d.GameId).ToArray();
var levels = context.GameLevels.Where(g => ids.Contains(g.GameId));
levels.ForEach(level =>
{
level.GameId = historyGameId;
});
await context.SaveChangesAsync().ConfigureAwait(false);
context.Remove(historyCollisions);
await context.SaveChangesAsync().ConfigureAwait(false);
}
}
else
{
Game game = new Game
{
CreatorId = userId
};
context.Add(game);
await context.SaveChangesAsync().ConfigureAwait(false);
GameTag historyGameTag = new GameTag()
{
GameId = game.GameId,
Tags = GameTags.CustomLevelsHistory,
UserId = userId
};
context.Add(historyGameTag);
await context.SaveChangesAsync().ConfigureAwait(false);
historyGameId = game.GameId;
}
return(historyGameId);
}
public void Change(Entity entity, GameTag gameTag, int oldValue, int newValue)
{
var target = entity as IPlayable;
//Game.Log(LogLevel.INFO, BlockType.TRIGGER, "Trigger", $"{entity} {gameTag} {oldValue} {newValue}");
if (!Effects.ContainsKey(gameTag))
{
Game.Log(LogLevel.DEBUG, BlockType.TRIGGER, "Trigger", $"GameTag {gameTag} not concerned by this enchanting(change) ...");
return;
}
if (!IsEnabled())
{
Game.Log(LogLevel.DEBUG, BlockType.TRIGGER, "Trigger", "Trigger isn't enabled!");
return;
}
if (!IsApplying(target))
{
Game.Log(LogLevel.DEBUG, BlockType.TRIGGER, "Trigger", $"Trigger conditions not meet.");
Game.Log(LogLevel.DEBUG, BlockType.TRIGGER, "Trigger", $"Owner: {Owner}, Target: {target}");
return;
}
if (Effects[gameTag] > 0 && oldValue >= newValue ||
Effects[gameTag] < 0 && oldValue <= newValue)
{
Game.Log(LogLevel.DEBUG, BlockType.TRIGGER, "Trigger", $"Enchant(change) on {gameTag} conditions not meet positiv or negativ. {Effects[gameTag]} && {oldValue} == {newValue}");
return;
}
// do a clone of the task
ISimpleTask clone = SingleTask.Clone();
clone.Game = Owner.Controller.Game;
clone.Controller = Owner.Controller;
clone.Source = Owner;
clone.Target = target;
// let the change move into the task
clone.Number = newValue - oldValue;
if (FastExecution)
{
Owner.Controller.Game.TaskQueue.Execute(SingleTask, Owner.Controller, Owner, target);
}
else
{
Owner.Controller.Game.TaskQueue.Enqueue(clone);
}
Executions++;
if (MaxExecutions != 0 && Executions >= MaxExecutions)
{
Remove();
}
}
public int GetTag(GameTag tag)
{
int value;
if (Tags.TryGetValue(tag, out value) == false)
{
throw new Exception("tag not found");
}
return value;
}
/// <summary>
/// Initializes an instance of the TagNode class.
/// </summary>
/// <param name="xmlNode">The XML Node describing the Node.</param>
/// <param name="game">The game object related to the Node.</param>
public TagNode(XmlNode xmlNode, Game game)
{
// tag % gameTag; #REQUIRED
// value NMTOKEN #REQUIRED
// ts NMTOKEN #IMPLIED
_game = game;
if (xmlNode.Attributes?["tag"]?.Value == null) { throw new NullReferenceException(); }
Name = (GameTag)Enum.Parse(typeof(GameTag), xmlNode.Attributes?["tag"]?.Value);
Int32.TryParse(xmlNode.Attributes?["value"]?.Value, out Value);
Ts = xmlNode.Attributes?["ts"]?.Value;
}
private static int ParseTagValue(GameTag tag, string raw_value)
{
switch (tag)
{
case GameTag.STEP:
TAG_STEP step;
if (Enum.TryParse(raw_value, out step)) return (int)step;
break;
case GameTag.ZONE:
TAG_ZONE zone;
if (Enum.TryParse(raw_value, out zone)) return (int)zone;
break;
case GameTag.MULLIGAN_STATE:
{
TAG_MULLIGAN state;
if (Enum.TryParse(raw_value, out state)) return (int)state;
}
break;
case GameTag.PLAYSTATE:
{
TAG_PLAYSTATE state;
if (Enum.TryParse(raw_value, out state)) return (int)state;
}
break;
case GameTag.CARDTYPE:
TAG_CARDTYPE type;
if (Enum.TryParse(raw_value, out type)) return (int)type;
break;
case GameTag.CLASS:
TAG_CLASS @class;
if (Enum.TryParse(raw_value, out @class)) return (int)@class;
break;
case GameTag.STATE:
{
TAG_STATE state;
if (Enum.TryParse(raw_value, out state)) return (int)state;
}
break;
default:
int value;
if (int.TryParse(raw_value, out value)) return value;
break;
}
return -1;
}
public Action FindAction(GameTag tag, IGame game, IHsGameState gameState, int id, int value, int prevValue)
{
switch(tag)
{
case ZONE:
return () => ZoneChange(gameState, id, game, value, prevValue);
case PLAYSTATE:
return () => PlaystateChange(gameState, id, game, value);
case CARDTYPE:
return () => CardTypeChange(gameState, id, game, value);
case LAST_CARD_PLAYED:
return () => LastCardPlayedChange(gameState, value);
case DEFENDING:
return () => DefendingChange(gameState, id, game, value);
case ATTACKING:
return () => AttackingChange(gameState, id, game, value);
case PROPOSED_DEFENDER:
return () => ProposedDefenderChange(game, value);
case PROPOSED_ATTACKER:
return () => ProposedAttackerChange(game, value);
case NUM_MINIONS_PLAYED_THIS_TURN:
return () => NumMinionsPlayedThisTurnChange(gameState, game, value);
case PREDAMAGE:
return () => PredamageChange(gameState, id, game, value);
case NUM_TURNS_IN_PLAY:
return () => NumTurnsInPlayChange(gameState, id, game, value);
case NUM_ATTACKS_THIS_TURN:
return () => NumAttacksThisTurnChange(gameState, id, game, value);
case ZONE_POSITION:
return () => ZonePositionChange(gameState, id, game);
case CARD_TARGET:
return () => CardTargetChange(gameState, id, game, value);
case WEAPON:
return () => EquippedWeaponChange(gameState, id, game, value);
case EXHAUSTED:
return () => ExhaustedChange(gameState, id, game, value);
case CONTROLLER:
return () => ControllerChange(gameState, id, game, prevValue, value);
case FATIGUE:
return () => FatigueChange(gameState, value, game, id);
case STEP:
return () => StepChange(gameState, game);
case TURN:
return () => TurnChange(gameState, game);
case STATE:
return () => StateChange(value, gameState);
}
return null;
}
public string GetLocString(GameTag gameTag, Language lang)
{
var tag = Tags.FirstOrDefault(x => x.EnumId == (int)gameTag);
if(tag == null)
return null;
if(tag.TypeString != "LocString")
return null;
switch(lang)
{
case deDE:
return tag.LocStringDeDe;
case enUS:
return tag.LocStringEnUs;
case esES:
return tag.LocStringEsEs;
case esMX:
return tag.LocStringEsMx;
case frFR:
return tag.LocStringFrFr;
case itIT:
return tag.LocStringItIt;
case jaJP:
return tag.LocStringJaJp;
case koKR:
return tag.LocStringKoKr;
case plPL:
return tag.LocStringPlPl;
case ptBR:
return tag.LocStringPtBr;
case ruRU:
return tag.LocStringRuRu;
case zhCN:
return tag.LocStringZhCn;
case zhTW:
return tag.LocStringZhTw;
case thTH:
return tag.LocStringThTh;
default:
return null;
}
}
/// <summary>
/// Converts a GameTag to a string.
/// </summary>
/// <param name="gameTagType">The type of GameTag.</param>
/// <param name="enumValue">The related value.</param>
/// <returns>A string descibing the GameTag's type.</returns>
public static String GameTagValueToString(GameTag gameTagType, Int32 enumValue)
{
if (Enum.IsDefined(typeof(GameTag), gameTagType)) {
switch (gameTagType) {
case GameTag.CARDTYPE:
return ((CardType)enumValue).ToString();
case GameTag.RARITY:
return ((Rarity)enumValue).ToString();
case GameTag.ZONE:
return ((Zone)enumValue).ToString();
case GameTag.STEP:
return ((Step)enumValue).ToString();
case GameTag.NEXT_STEP:
return ((Step)enumValue).ToString();
case GameTag.STATE:
return ((State)enumValue).ToString();
case GameTag.CLASS:
return ((CardClass)enumValue).ToString();
}
return enumValue.ToString();
}
return enumValue.ToString();
}
public int GetTagOrDefault(GameTag tag, int default_val)
{
if (!HasTag(tag)) return default_val;
return GetTag(tag);
}
public bool HasTag(GameTag tag) => GetTag(tag) > 0;
public int GetTag(GameTag gameTag) => Tags.FirstOrDefault(x => x.EnumId == (int)gameTag)?.Value ?? 0;
public int GetTag(GameTag tag)
{
int value;
Tags.TryGetValue(tag, out value);
return value;
}
public bool HasTag(GameTag tag)
{
return GetTag(tag) > 0;
}
public int GetReferencedTag(GameTag gameTag) => ReferencedTags.FirstOrDefault(x => x.EnumId == (int)gameTag)?.Value ?? 0;
public string GetInnerValue(GameTag gameTag) => Tags.FirstOrDefault(x => x.EnumId == (int)gameTag)?.InnerValue;
public void ChangeTag(int entity_id, GameTag tag, int tag_value)
{
if (!this.Entities.ContainsKey(entity_id))
{
this.Entities.Add(entity_id, new Entity(entity_id));
}
int prev_value = -1;
bool has_prev_value = this.Entities[entity_id].HasTag(tag);
if (has_prev_value) prev_value = this.Entities[entity_id].GetTag(tag);
this.Entities[entity_id].SetTag(tag, tag_value);
switch (tag)
{
case GameTag.MULLIGAN_STATE:
this.MulliganStateChanged(entity_id, GameTag.MULLIGAN_STATE, has_prev_value, prev_value, tag_value);
break;
}
// trigger end-turn action
if (entity_id == this.GameEntityId && tag == GameTag.STEP && tag_value == (int)TAG_STEP.MAIN_END)
{
if (this.EndTurnEvent != null) this.EndTurnEvent(this, new EndTurnEventArgs());
}
if (entity_id == this.GameEntityId && tag == GameTag.STEP && tag_value == (int)TAG_STEP.MAIN_ACTION)
{
if (this.StartWaitingMainAction != null) StartWaitingMainAction(this, new StartWaitingMainActionEventArgs());
}
}
private void MulliganStateChanged(int entity_id, GameTag tag, bool has_prev, int prev_value, int value)
{
// set player when mulligan
}
private bool ParseOneStatus(GameState.Entity entity, GameTag tag, out int value)
{
value = entity.GetTagOrDefault(tag, 0);
return true;
}
public bool HasTag(GameTag tag)
{
return Tags.ContainsKey(tag);
}
