// Update is called once per frame
void Update()
{
if (_diesAt <= Time.timeSinceLevelLoad) {
_target = null;
_projectileCache.ReturnProjectile (this);
}
}
public override void Launch(IPlayable target)
{
transform.LookAt (target.transform.position, Vector3.up);
_explodePosition = target.transform.position;
Vector3 toTarget = target.transform.position - this.transform.position;
Vector3 toTargetXZ = toTarget;
toTargetXZ.y = 0;
float y = toTarget.y;
float xz = toTargetXZ.magnitude;
float t = _lifeTime;
//_lifeTime == time
float v0y = y / t + 0.5f * Physics.gravity.magnitude * t;
float v0xz = xz / t;
Vector3 result = toTargetXZ.normalized;
result *= v0xz;
result.y = v0y;
_diesAt = Time.timeSinceLevelLoad + _lifeTime;
_target = target;
_rigidBody = GetComponent<Rigidbody> ();
_rigidBody.velocity = Vector3.zero;
_rigidBody.AddForce (result, ForceMode.VelocityChange);
}
public void PlayNextItem(Queue<FileNode> queue, VideoPlayerController controller, IPlayStrategy strategy, IPlayable previous)
{
if (!controller.Queue.IsEmpty())
{
var file = queue.Dequeue();
controller.Play(file);
if (file.Type == FileType.Audio && queue.Peek().Type != FileType.Audio)
{
controller.Play(queue.Dequeue());
}
}
else if (strategy.Repeat)
{
previous.Play(strategy, controller);
}
else if (previous is Player)
{
var playlist = _processor.Process(new GetGoalPlayListQuery());
if (playlist == null) return;
controller.Play(playlist, new PlayListPlayStrategy());
}
else if (controller.AutoPlayList)
{
var playlist = _processor.Process(new GetAutoPlayListQuery());
if (playlist == null) return;
playlist.Play(null, controller);
}
}
private void ManufacturerInitializeComputersFromInput()
{
var manufacturerName = Console.ReadLine();
ManufacturerFactory manufacturerCreator = new ManufacturerFactory();
ComputersFactory manufacturer = manufacturerCreator.CreateManufacturer(manufacturerName);
this.pc = manufacturer.CreatePc();
this.laptop = manufacturer.CreateLaptop();
this.server = manufacturer.CreateServer();
}
public void AddEntry(IPlayable playable, TimeSpan timePlayed)
{
var entry = new HistoryEntry
{
Timestamp = DateTime.Now,
ArtistName = playable.Artist,
TrackTitle = playable.Title,
TimePlayed = timePlayed
};
var playableBase = playable as PlayableBase;
if (playableBase != null)
{
entry.ArtistId = playableBase.Artist.Guid;
//entry.TrackId = _trackProvider.Collection.First(x => x.Value == playableBase).Key;
}
HistoryEntries.Insert(0, entry);
}
/// <summary>
/// Plays the video
/// </summary>
/// <param name="button">Button to set styles to</param>
public void Play(Button button, IPlayable playable)
{
this.SwitchButtonStyle(button);
if (CheckException.CheckNull(playable))
{
if (!this.MainScreenInstance.timerForProgress.Enabled)
{
this.MainScreenInstance.timerForProgress.Start();
}
playable.Play();
}
if (this.MainScreenInstance.timerForRF.Enabled)
{
this.MainScreenInstance.timerForRF.Stop();
playable.PlayBackSpeed = 0;
}
}
private void Run()
{
soundManager = new SoundManager(new AudioDevice(), ManagerGlue.JMOD, 1, 30);
soundManager.ContentPath = "Data/Sound/";
soundManager.LoadSounds(true);
playable = soundManager.GetSFX(SFX.SwordSwish1);
//playable = soundManager.GetStream(Stream.MainMenuMusic1);
channel = playable.Play(new Client.Sound.PlayArgs { Looping = true });
//channel.Looping = true;
//channel.PlaybackStopped += new EventHandler(channel_PlaybackStopped);
//channel.PlaybackStopped += (sender, ea) => { Console.WriteLine("Playback ended. Restarting..."); channel = p.Play(); };
float dtime = 1 / 60f;
while (true)
{
soundManager.Update(dtime, Vector3.Zero, Vector3.Zero, Vector3.UnitX, Vector3.UnitZ);
System.Threading.Thread.Sleep((int)(dtime * 1000));
//VolumeTest(dtime / 4f);
//PauseTest(dtime / 4f);
//GlobalMuteTest(dtime / 4f);
}
}
/// <summary>
/// Create a new instance of <see cref="Trigger"/> object in source's Game. During activation, the instance's <see cref="Process(IEntity)"/> subscribes to the events in <see cref="TriggerManager"/>.
/// </summary>
public virtual Trigger Activate(IPlayable source, TriggerActivation activation = TriggerActivation.PLAY, bool cloning = false, bool asAncillary = false)
{
if (source.ActivatedTrigger != null && !IsAncillaryTrigger && !asAncillary)
{
throw new Exceptions.EntityException($"{source} already has an activated trigger.");
}
if (!cloning && activation != TriggerActivation)
{
if (TriggerActivation != TriggerActivation.HAND_OR_PLAY)
{
return(null);
}
if (activation == TriggerActivation.DECK)
{
return(null);
}
}
var instance = new Trigger(this, source);
if (asAncillary)
{
instance.IsAncillaryTrigger = true;
}
else if (!IsAncillaryTrigger)
{
source.ActivatedTrigger = instance;
}
if (_sequenceType != SequenceType.None)
{
source.Game.Triggers.Add(instance);
}
switch (_triggerType)
{
case TriggerType.DEAL_DAMAGE:
source.Game.TriggerManager.DealDamageTrigger += instance._processHandler;
break;
case TriggerType.TAKE_DAMAGE:
if (TriggerSource == TriggerSource.SELF)
{
if (source is Minion m)
{
m.TakeDamageTrigger += instance._processHandler;
}
else
{
throw new NotImplementedException();
}
break;
}
if (TriggerSource == TriggerSource.HERO)
{
source.Controller.Hero.TakeDamageTrigger += instance._processHandler;
break;
}
source.Game.TriggerManager.DamageTrigger += instance._processHandler;
break;
case TriggerType.HEAL:
source.Game.TriggerManager.HealTrigger += instance._processHandler;
break;
case TriggerType.TURN_END:
case TriggerType.WORGEN_TRANSFORM:
source.Game.TriggerManager.EndTurnTrigger += instance._processHandler;
break;
case TriggerType.TURN_START:
source.Game.TriggerManager.TurnStartTrigger += instance._processHandler;
break;
case TriggerType.SUMMON:
source.Game.TriggerManager.SummonTrigger += instance._processHandler;
break;
case TriggerType.AFTER_SUMMON:
source.Game.TriggerManager.AfterSummonTrigger += instance._processHandler;
break;
case TriggerType.ATTACK:
source.Game.TriggerManager.AttackTrigger += instance._processHandler;
break;
case TriggerType.AFTER_ATTACK:
switch (TriggerSource)
{
case TriggerSource.HERO:
source.Controller.Hero.AfterAttackTrigger += instance._processHandler;
break;
case TriggerSource.SELF:
((Minion)source).AfterAttackTrigger += instance._processHandler;
break;
case TriggerSource.ENCHANTMENT_TARGET:
((Minion)((Enchantment)source).Target).AfterAttackTrigger += instance._processHandler;
break;
default:
throw new NotImplementedException();
}
break;
case TriggerType.DEATH:
source.Game.TriggerManager.DeathTrigger += instance._processHandler;
break;
case TriggerType.PLAY_CARD:
source.Game.TriggerManager.PlayCardTrigger += instance._processHandler;
break;
case TriggerType.AFTER_PLAY_CARD:
source.Game.TriggerManager.AfterPlayCardTrigger += instance._processHandler;
break;
case TriggerType.PLAY_MINION:
source.Game.TriggerManager.PlayMinionTrigger += instance._processHandler;
break;
case TriggerType.AFTER_PLAY_MINION:
source.Game.TriggerManager.AfterPlayMinionTrigger += instance._processHandler;
break;
case TriggerType.CAST_SPELL:
source.Game.TriggerManager.CastSpellTrigger += instance._processHandler;
break;
case TriggerType.AFTER_CAST:
source.Game.TriggerManager.AfterCastTrigger += instance._processHandler;
break;
case TriggerType.PREDAMAGE:
switch (TriggerSource)
{
case TriggerSource.HERO:
source.Controller.Hero.PreDamageTrigger += instance._processHandler;
break;
case TriggerSource.SELF:
((Minion)source).PreDamageTrigger += instance._processHandler;
break;
case TriggerSource.ENCHANTMENT_TARGET:
((Minion)((Enchantment)source).Target).PreDamageTrigger += instance._processHandler;
break;
}
break;
case TriggerType.SECRET_REVEALED:
source.Game.TriggerManager.SecretRevealedTrigger += instance._processHandler;
break;
case TriggerType.ZONE:
source.Game.TriggerManager.ZoneTrigger += instance._processHandler;
break;
case TriggerType.DISCARD:
source.Game.TriggerManager.DiscardTrigger += instance._processHandler;
break;
case TriggerType.GAME_START:
source.Game.TriggerManager.GameStartTrigger += instance._processHandler;
break;
case TriggerType.DRAW:
source.Game.TriggerManager.DrawTrigger += instance._processHandler;
break;
case TriggerType.TARGET:
source.Game.TriggerManager.TargetTrigger += instance._processHandler;
break;
case TriggerType.LOSE_DIVINE_SHIELD:
source.Game.TriggerManager.LoseDivineShield += instance._processHandler;
break;
case TriggerType.INSPIRE:
source.Game.TriggerManager.InspireTrigger += instance._processHandler;
break;
case TriggerType.FROZEN:
source.Game.TriggerManager.FreezeTrigger += instance._processHandler;
break;
case TriggerType.ARMOR:
source.Game.TriggerManager.ArmorTrigger += instance._processHandler;
break;
case TriggerType.EQUIP_WEAPON:
source.Game.TriggerManager.EquipWeaponTrigger += instance._processHandler;
break;
case TriggerType.SHUFFLE_INTO_DECK:
source.Game.TriggerManager.ShuffleIntoDeckTrigger += instance._processHandler;
break;
case TriggerType.OVERLOAD:
source.Game.TriggerManager.OverloadTrigger += instance._processHandler;
break;
}
return(instance);
}
public void Execute(ISimpleTask task, Controller controller, IPlayable source, IPlayable target)
{
ISimpleTask clone = task.Clone();
clone.Game = controller.Game;
clone.Controller = controller;
clone.Source = source;
clone.Target = target;
Game.Log(LogLevel.VERBOSE, BlockType.TRIGGER, "TaskQueue", !Game.Logging? "":$"PriorityTask[{clone.Source}]: '{clone.GetType().Name}' is processed!" +
$"'{clone.Source.Card.Text?.Replace("\n", " ")}'");
// power block
if (controller.Game.History)
{
controller.Game.PowerHistory.Add(PowerHistoryBuilder.BlockStart(BlockType.POWER, source.Id, "", -1, target?.Id ?? 0));
}
clone.Process();
if (controller.Game.History)
{
controller.Game.PowerHistory.Add(PowerHistoryBuilder.BlockEnd());
}
Game.TaskStack.Reset();
}
/// <summary>
/// Heal up all taken damage.
/// </summary>
/// <param name="source"></param>
public void TakeFullHeal(IPlayable source)
{
TakeHeal(source, Damage);
}
public override void Init()
{
playable = SoundManager.GetSoundResourceGroup(SoundManager.GetSFX(SFX.BulletHitFlesh1));
}
public void Play(IPlayable wave)
{
lock (mutex)
{
if (wave == current)
{
if (isPaused)
{
sourceVoice.Start();
isPaused = false;
return;
}
}
DisposeWave();
xaudio.CommitChanges();
isPaused = false;
current = wave;
currentStream = wave as IPlayableStream;
if (decodeThread != null)
{
System.Threading.Monitor.Pulse(mutex);
decodeThread = null;
}
if (currentStream == null)
{
sourceVoice = new SourceVoice(xaudio, wave.WaveFormat);
dataStream = new SlimDX.DataStream(wave.WaveData, true, false);
audioBuffer = new SlimDX.XAudio2.AudioBuffer();
audioBuffer.AudioData = dataStream;
audioBuffer.AudioBytes = wave.WaveData.Length;
audioBuffer.Flags = BufferFlags.EndOfStream;
sourceVoice.SubmitSourceBuffer(audioBuffer);
sourceVoice.Start();
}
else
{
streamLength = currentStream.StreamLength;
streamBuffered = 0;
sourceVoice = new SourceVoice(xaudio, wave.WaveFormat);
sourceVoice.BufferEnd += bufferEndCallback;
// Fill buffers initially
bool isDone = false;
for (var i = 0; i < NumStreamingBuffers; i++)
{
isDone = FillBuffer(i, currentStream);
if (isDone)
{
break;
}
}
sourceVoice.Start();
if (!isDone)
{
System.Threading.ParameterizedThreadStart threadProc = DecoderThread;
decodeThread = new System.Threading.Thread(threadProc);
decodeThread.Name = "Vorbis Decoder Thread";
decodeThread.Start(currentStream);
}
}
}
}
private Unit InsertUnit(Vector3 position, IPlayable sound)
{
var unit = new Unit { Position = position, Sound = sound, Cooldown = 2f };
units.Add(unit);
return unit;
}
/// <summary>
/// Loads the specified playlist event.
/// </summary>
/// <param name="playlist">Playlist.</param>
/// <param name="evt">Event.</param>
/// <param name="playing">If set to <c>true</c> playing.</param>
public void LoadPlaylistEvent(PlaylistVM playlist, IPlayable evt, bool playing)
{
Player?.LoadPlaylistEvent(playlist, evt, playing);
}
public TrackFinishedEventArgs(IPlayable currentPlayable)
{
CurrentPlayable = currentPlayable;
}
public EventMetaData(IPlayable source, IPlayable target, int number = 0)
{
EventSource = source;
EventTarget = target;
EventNumber = number;
}
public void Clone(IPlayable clone)
{
Activate(clone);
}
private AddCardTo(IPlayable playable, Card card, EntityType type)
{
Playable = playable;
Card = card;
Type = type;
}
public AddCardTo(IPlayable playable, EntityType type)
{
Playable = playable;
Type = type;
}
public virtual void Launch(IPlayable target)
{
_diesAt = Time.timeSinceLevelLoad + _lifeTime;
_target = target;
}
public override void Clone(IPlayable clone)
{
Activate(clone, true);
}
public Task OpenPlayable(IPlayable playable, IPlaylist playlist)
{
return(OpenPlayable(playable, playlist, true, false, true));
}
public TrackChangedEventArgs(IPlayable track, TimeSpan timePlayed)
{
Track = track;
TimePlayed = timePlayed;
}
public Task OpenPlayable(IPlayable playable, IPlaylist playlist, bool openPlaying)
{
return(OpenPlayable(playable, playlist, openPlaying, false, true));
}
// Use this for initialization
public override void OnEnable () {
base.OnEnable();
//find all playable child nodes and add them to the list
if (transform.childCount > 0)
childNode = transform.GetChild(0).GetComponent<IPlayable>();
#if UNITY_EDITOR
if (!Application.isPlaying)
{
isPlaying = false;
UnityEditor.EditorApplication.update += InvokeRepeater;
}
#endif
}
public override TaskState Process()
{
// get a new class
CardClass randClass = 0;
do
{
randClass = (CardClass)Random.Next(2, 11);
} while (randClass == CardClass.WARLOCK);
// replace Hero Power
Card heroPowerCard = null;
switch (randClass)
{
case CardClass.DRUID:
heroPowerCard = Cards.FromId("CS2_017");
break;
case CardClass.HUNTER:
heroPowerCard = Cards.FromId("DS1h_292");
break;
case CardClass.MAGE:
heroPowerCard = Cards.FromId("CS2_034");
break;
case CardClass.PALADIN:
heroPowerCard = Cards.FromId("CS2_101");
break;
case CardClass.PRIEST:
heroPowerCard = Cards.FromId("CS1h_001");
break;
case CardClass.ROGUE:
heroPowerCard = Cards.FromId("CS2_083b");
break;
case CardClass.SHAMAN:
heroPowerCard = Cards.FromId("CS2_049");
break;
case CardClass.WARRIOR:
heroPowerCard = Cards.FromId("CS2_102");
break;
}
HeroPower heroPower =
(HeroPower)Entity.FromCard(Controller, heroPowerCard, new EntityData.Data
{
{ GameTag.CREATOR, Source.Id },
{ GameTag.ZONE, (int)Zone.PLAY }
});
Controller.SetasideZone.Add(Controller.Hero.HeroPower);
Controller.Hero.HeroPower = heroPower;
var cards = Cards.FormatTypeClassCards(Game.FormatType)[randClass].Where(p => p.Class == randClass && !p.IsQuest).ToArray();
// replace cards in hand
for (int i = 0; i < Controller.HandZone.Count; i++)
{
IPlayable entity = Controller.HandZone[i];
if (entity.Card.Class != CardClass.WARLOCK)
{
continue;
}
Controller.HandZone.Remove(entity);
Controller.SetasideZone.Add(entity);
var tags = new EntityData.Data
{
{ GameTag.ZONE_POSITION, i + 1 },
};
if (Game.History)
{
tags.Add(GameTag.CREATOR, Source.Id);
}
IPlayable newEntity = Entity.FromCard(Controller, Util.Choose(cards), tags, Controller.HandZone, -1, i);
newEntity.NativeTags.Add(GameTag.DISPLAYED_CREATOR, Source.Id);
CostReduceEffect.Apply(newEntity.AuraEffects);
}
// replace cards in deck
for (int i = Controller.DeckZone.Count - 1; i >= 0; i--)
{
IPlayable entity = Controller.DeckZone[i];
if (entity.Card.Class != CardClass.WARLOCK)
{
continue;
}
Card randCard = Util.Choose(cards);
IPlayable newEntity = Entity.FromCard(Controller, randCard, null, Controller.DeckZone);
newEntity.NativeTags.Add(GameTag.DISPLAYED_CREATOR, Source.Id);
//Enchantment.GetInstance(Controller, (IPlayable) Source, newEntity, EnchantmentCard);
Controller.DeckZone.Remove(entity);
Controller.SetasideZone.Add(entity);
CostReduceEffect.Apply(newEntity.AuraEffects);
}
Game.OnRandomHappened(true);
return(TaskState.COMPLETE);
}
public void Play(IPlayable music)
{
var songs = music.GetSongs().ToList();
if (songs.Count == 1)
{
// load other songs from album
}
else if (songs.Count == 0)
{
}
StartPlaying(songs.Select(s => new LightSongModel(s.Path, s.Name, s.Artist)));
AlbumArt = _albumArtCache.GetAlbumArt(songs.First().AlbumId);
OnAlbumArtChanged();
}
public static IList <IPlayable> GetEntities(EntityType type, Controller c, IEntity source,
IEntity target, List <IPlayable> stack)
{
switch (type)
{
case EntityType.STACK:
return(stack);
case EntityType.HAND:
return(c.HandZone.GetAll());
case EntityType.DECK:
return(c.DeckZone.GetAll());
case EntityType.MINIONS:
return(c.BoardZone.GetAll());
case EntityType.SECRETS:
return(c.SecretZone.GetAll());
case EntityType.GRAVEYARD:
return(c.GraveyardZone.ToArray());
case EntityType.OP_HAND:
return(c.Opponent.HandZone.GetAll());
case EntityType.OP_DECK:
return(c.Opponent.DeckZone.GetAll());
case EntityType.OP_MINIONS:
return(c.Opponent.BoardZone.GetAll());
case EntityType.OP_SECRETS:
return(c.Opponent.SecretZone.GetAll());
case EntityType.MINIONS_NOSOURCE:
return(c.BoardZone.GetAll(p => p != source));
case EntityType.ALLMINIONS_NOSOURCE:
{
if (source.Controller == c)
{
Minion[] board = c.BoardZone.GetAll(p => p != source);
Minion[] array = new Minion[board.Length + c.Opponent.BoardZone.CountExceptUntouchables];
board.CopyTo(array, 0);
c.Opponent.BoardZone.CopyTo(array, board.Length);
return(array);
}
else
{
Minion[] board = c.Opponent.BoardZone.GetAll(p => p != source);
Minion[] array = new Minion[board.Length + c.BoardZone.CountExceptUntouchables];
board.CopyTo(array, 0);
c.BoardZone.CopyTo(array, board.Length);
return(array);
}
}
case EntityType.ENEMIES:
{
var arr = new ICharacter[c.Opponent.BoardZone.CountExceptUntouchables + 1];
arr[0] = c.Opponent.Hero;
c.Opponent.BoardZone.CopyTo(arr, 1);
return(arr);
}
case EntityType.TARGET:
return(target == null ? new IPlayable[0] : new [] { (IPlayable)target });
case EntityType.SOURCE:
return(new[] { (IPlayable)source });
case EntityType.HERO:
return(new[] { c.Hero });
case EntityType.HERO_POWER:
return(new[] { c.Hero.HeroPower });
case EntityType.OP_HERO_POWER:
return(new[] { c.Opponent.Hero.HeroPower });
case EntityType.FRIENDS:
{
var arr = new ICharacter[c.BoardZone.CountExceptUntouchables + 1];
arr[0] = c.Hero;
c.BoardZone.CopyTo(arr, 1);
return(arr);
}
case EntityType.OP_HERO:
return(new[] { c.Opponent.Hero });
case EntityType.ENEMIES_NOTARGET:
if (target is Hero)
{
return(c.Opponent.BoardZone.GetAll());
}
else
{
if (c.Opponent.BoardZone.CountExceptUntouchables > 1)
{
var arr = new ICharacter[c.Opponent.BoardZone.CountExceptUntouchables];
arr[0] = c.Opponent.Hero;
Minion[] temp = c.Opponent.BoardZone.GetAll(p => p != target);
Array.Copy(temp, 0, arr, 1, temp.Length);
return(arr);
}
return(new[] { c.Opponent.Hero });
}
case EntityType.ALL:
{
var arr = new IPlayable[c.BoardZone.CountExceptUntouchables + c.Opponent.BoardZone.CountExceptUntouchables + 2];
c.BoardZone.CopyTo(arr, 0);
c.Opponent.BoardZone.CopyTo(arr, c.BoardZone.CountExceptUntouchables);
arr[arr.Length - 2] = c.Hero;
arr[arr.Length - 1] = c.Opponent.Hero;
return(arr);
}
case EntityType.ALL_NOSOURCE:
{
if (source.Zone == null)
{
throw new NotImplementedException();
}
var arr = new IPlayable[c.BoardZone.CountExceptUntouchables + c.Opponent.BoardZone.CountExceptUntouchables + 1];
if (source.Zone == c.BoardZone)
{
c.BoardZone.GetAll(p => p != source).CopyTo(arr, 0);
c.Opponent.BoardZone.CopyTo(arr, c.BoardZone.CountExceptUntouchables - 1);
arr[arr.Length - 2] = c.Hero;
arr[arr.Length - 1] = c.Opponent.Hero;
}
else if (source.Zone == c.Opponent.BoardZone)
{
c.BoardZone.CopyTo(arr, 0);
c.Opponent.BoardZone.GetAll(p => p != source).CopyTo(arr, c.BoardZone.CountExceptUntouchables);
arr[arr.Length - 2] = c.Hero;
arr[arr.Length - 1] = c.Opponent.Hero;
}
else
{
c.BoardZone.CopyTo(arr, 0);
c.Opponent.BoardZone.CopyTo(arr, c.BoardZone.CountExceptUntouchables);
arr[arr.Length - 2] = c.Hero;
arr[arr.Length - 1] = c.Opponent.Hero;
}
return(arr);
}
case EntityType.WEAPON:
return(c.Hero.Weapon == null ? new IPlayable[0] : new[] { c.Hero.Weapon });
case EntityType.OP_WEAPON:
return(c.Opponent.Hero.Weapon == null ? new IPlayable[0] : new[] { c.Opponent.Hero.Weapon });
case EntityType.ALLMINIONS:
{
var arr = new Minion[c.BoardZone.CountExceptUntouchables + c.Opponent.BoardZone.CountExceptUntouchables];
c.BoardZone.CopyTo(arr, 0);
c.Opponent.BoardZone.CopyTo(arr, c.BoardZone.CountExceptUntouchables);
return(arr);
}
case EntityType.HEROES:
return(new[] { c.Hero, c.Opponent.Hero });
case EntityType.TOPCARDFROMDECK:
return(c.DeckZone.Count > 0 ? new[] { c.DeckZone.TopCard } : new IPlayable[0]);
case EntityType.OP_TOPDECK:
return(c.Opponent.DeckZone.Count > 0 ? new[] { c.Opponent.DeckZone.TopCard } : new IPlayable[0]);
default:
throw new NotImplementedException();
}
}
public void AddTrackToQueue(IPlayable playable, TimeSpan duration)
{
QueueItems.Add(new QueueItem { Playable = playable, Duration = duration });
playable.IsQueued = true;
}
Task<IPlayable> IPlaylist.GetNextTrack(IPlayable currentTrack)
{
return GetPlayable(Artist.TopTracks.GetNextObject(currentTrack.Tag));
}
/// <summary>
/// Inflict damage onto this character.
/// The actual amount still needs to be determined by the current
/// state of the game. eg: The presence of immunity effects can cause
/// the damage to be ignored.
/// </summary>
/// <param name="source"></param>
/// <param name="damage"></param>
/// <returns></returns>
public int TakeDamage(IPlayable source, int damage)
{
var hero = this as Hero;
var minion = this as Minion;
if (minion != null && minion.Zone.Type != Enums.Zone.PLAY)
{
return(0);
}
bool fatigue = hero != null && this == source;
if (fatigue)
{
hero.Fatigue = damage;
}
if (minion != null && minion.HasDivineShield)
{
Game.Log(LogLevel.INFO, BlockType.ACTION, "Character", !Game.Logging? "":$"{this} divine shield absorbed incoming damage.");
minion.HasDivineShield = false;
return(0);
}
int armor = hero?.Armor ?? 0;
int amount = hero == null ? damage : armor < damage ? damage - armor : 0;
// added pre damage
PreDamage = amount;
// Predamage triggers (Ice Block)
if (PreDamageTrigger != null)
{
PreDamageTrigger.Invoke(this);
amount = PreDamage;
}
if (IsImmune)
{
Game.Log(LogLevel.INFO, BlockType.ACTION, "Character", !Game.Logging ? "" : $"{this} is immune.");
PreDamage = 0;
return(0);
}
// remove armor first from hero ....
if (armor > 0)
{
hero.Armor = armor < damage ? 0 : armor - damage;
}
// final damage is beeing accumulated
Damage += amount;
Game.Log(LogLevel.INFO, BlockType.ACTION, "Character", !Game.Logging? "":$"{this} took damage for {PreDamage}({damage}). {(fatigue ? "(fatigue)" : "")}");
// reset predamage
PreDamage = 0;
//LastAffectedBy = source.Id; TODO
// Damage event is created
// Collect all the tasks and sort them by order of play
// Death phase and aura update are not emerge here
// place event related data
Game.TaskQueue.StartEvent();
EventMetaData temp = Game.CurrentEventData;
Game.CurrentEventData = new EventMetaData(source, this, amount);
// on-damage triggers
TakeDamageTrigger?.Invoke(this);
Game.TriggerManager.OnDamageTrigger(this);
Game.TriggerManager.OnDealDamageTrigger(source);
Game.ProcessTasks();
Game.TaskQueue.EndEvent();
Game.CurrentEventData = temp;
if (source.HasLifeSteal && !_lifestealChecker)
{
if (_history)
{
Game.PowerHistory.Add(PowerHistoryBuilder.BlockStart(BlockType.TRIGGER, source.Id, source.Card.Id, -1, 0)); // TriggerKeyword=LIFESTEAL
}
Game.Log(LogLevel.VERBOSE, BlockType.ATTACK, "TakeDamage", !_logging ? "" : $"lifesteal source {source} has damaged target for {amount}.");
source.Controller.Hero.TakeHeal(source, amount);
if (_history)
{
Game.PowerHistory.Add(new PowerHistoryBlockEnd());
}
if (source.Controller.Hero.ToBeDestroyed && source.Controller.Hero.Health > 0)
{
source.Controller.Hero.ToBeDestroyed = false;
}
}
return(amount);
}
public EventProxy(IPlayable playable)
{
Playable = playable;
}
public virtual void ApplyEnchantments(EnchantmentActivation activation, Zone zoneType, IPlayable target = null)
{
var removeEnchantments = new List <Enchantment>();
Enchantments.ForEach(p =>
{
if (p.Activation == activation && (Zone == null || Zone.Type == zoneType))
{
p.Activate(Controller, this, target);
if (p.RemoveAfterActivation)
{
removeEnchantments.Add(p);
}
}
});
removeEnchantments.ForEach(p => Enchantments.Remove(p));
}
/// <summary> /// ドローが必要か判定します。 /// </summary> /// <returns>trueの場合はドローする。falseの場合はドローしない。</returns> public abstract bool NeedDraw(IPlayable playable);
public static String SoundResourceGroupID(IPlayable[] playables)
{
String s = "";
for (int i = 0; i < playables.Length; i++)
s += playables[i].Name + "||";
return s;
}
public ConsoleGameUI(Game fifteen)
{
Interface = (IPlayable)fifteen;
}
private void Validate(IEntity source)
{
if (_isSecret && _owner.IsExhausted && _triggerType != TriggerType.TURN_START)
{
return;
}
switch (TriggerSource)
{
case TriggerSource.ALL:
break;
case TriggerSource.FRIENDLY:
if (source.Controller != _owner.Controller)
{
return;
}
break;
case TriggerSource.ENEMY when source.Controller == _owner.Controller: return;
case TriggerSource.SELF:
if (source.Id != _sourceId)
{
return;
}
break;
case TriggerSource.ALL_MINIONS:
if (!(source is Minion))
{
return;
}
break;
case TriggerSource.MINIONS:
if (!(source is Minion) || source.Controller != _owner.Controller)
{
return;
}
break;
case TriggerSource.MINIONS_EXCEPT_SELF:
if (!(source is Minion) || source.Controller != _owner.Controller || source.Id == _sourceId ||
source.Zone.Type != Zone.PLAY)
{
return;
}
break;
case TriggerSource.ALL_MINIONS_EXCEPT_SELF:
if (!(source is Minion) || source == _owner)
{
return;
}
break;
case TriggerSource.OP_MINIONS:
if (!(source is Minion) || source.Controller == _owner.Controller)
{
return;
}
break;
case TriggerSource.HERO:
if (!(source is Hero) || source.Controller != _owner.Controller)
{
return;
}
break;
case TriggerSource.ENCHANTMENT_TARGET:
if (!(_owner is Enchantment e) || e.Target.Id != source.Id)
{
return;
}
break;
case TriggerSource.WEAPON:
if (!(source is Weapon w) || w.Controller != source.Controller)
{
return;
}
break;
case TriggerSource.HERO_POWER:
if (!(source is HeroPower hp) || hp.Controller != source.Controller)
{
return;
}
break;
case TriggerSource.FRIENDLY_SPELL_CASTED_ON_THE_OWNER:
if (!(source is Spell) || source.Controller != _owner.Controller || Game.CurrentEventData?.EventTarget != _owner)
{
return;
}
break;
case TriggerSource.FRIENDLY_SPELL_CASTED_ON_OWN_MINIONS:
if (!(source is Spell) || source.Controller != _owner.Controller || Game.CurrentEventData?.EventTarget?.Controller != _owner.Controller)
{
return;
}
break;
case TriggerSource.FRIENDLY_EVENT_SOURCE:
if (Game.CurrentEventData?.EventSource.Controller != _owner.Controller)
{
return;
}
break;
}
//bool extra = false;
switch (_triggerType)
{
case TriggerType.PLAY_CARD when source.Id == _owner.Id:
case TriggerType.SUMMON when source == _owner:
case TriggerType.AFTER_SUMMON when source.Id == _owner.Id:
case TriggerType.TURN_START when !EitherTurn && source != _owner.Controller:
case TriggerType.DEATH when _owner.ToBeDestroyed:
case TriggerType.INSPIRE when !EitherTurn && Game.CurrentPlayer != _owner.Controller:
case TriggerType.SHUFFLE_INTO_DECK when Game.CurrentEventData?.EventSource.Card.AssetId == 49269:
return;
case TriggerType.TURN_END:
case TriggerType.WORGEN_TRANSFORM:
if (!EitherTurn && source != _owner.Controller)
{
return;
}
//if (!(SingleTask is RemoveEnchantmentTask) && Owner.Controller.ExtraEndTurnEffect)
// extra = true;
break;
}
if (Condition != null)
{
IPlayable s = source as IPlayable ?? _owner;
if (!Condition.Eval(s))
{
return;
}
}
Validated = true;
}
public void IceBlock_EX1_295()
{
var game = new Game(new GameConfig
{
StartPlayer = 1,
Player1HeroClass = CardClass.MAGE,
Player2HeroClass = CardClass.MAGE,
FillDecks = true,
FillDecksPredictably = true
});
game.StartGame();
game.Player1.BaseMana = 10;
game.Player1.Hero.Health = 2;
game.Player2.BaseMana = 10;
IPlayable spell = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Ice Block"));
game.Process(PlayCardTask.Spell(game.CurrentPlayer, spell));
Assert.Equal(1, game.CurrentPlayer.SecretZone.Count);
//Assert.Equal(1, game.CurrentOpponent.Board.Triggers.Count);
game.Process(EndTurnTask.Any(game.CurrentPlayer));
// play 2 charge minions
IPlayable minion1 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Stonetusk Boar"));
IPlayable minion2 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Stonetusk Boar"));
IPlayable minion3 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Bluegill Warrior"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion1));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion2));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion3));
Assert.Equal(3, game.CurrentPlayer.BoardZone.Count);
// minion 1 attacks hero that should NOT proc the secret
game.Process(MinionAttackTask.Any(game.CurrentPlayer, (Minion)minion1, game.CurrentOpponent.Hero));
Assert.Equal(1, game.CurrentOpponent.Hero.Health);
Assert.Equal(1, game.CurrentOpponent.SecretZone.Count);
// adding one armor for next attack
game.Player1.Hero.Armor = 1;
Assert.Equal(1, game.CurrentOpponent.Hero.Armor);
// minion 2 attacks hero that should proc the secret
game.Process(MinionAttackTask.Any(game.CurrentPlayer, (Minion)minion2, game.CurrentOpponent.Hero));
Assert.Equal(0, game.CurrentOpponent.Hero.Armor);
Assert.Equal(1, game.CurrentOpponent.Hero.Health);
Assert.Equal(1, game.CurrentOpponent.SecretZone.Count);
// adding one armor for next attack
game.Player1.Hero.Armor = 1;
Assert.Equal(1, game.CurrentOpponent.Hero.Armor);
// minion 3 attacks hero that should proc the secret
game.Process(MinionAttackTask.Any(game.CurrentPlayer, (Minion)minion3, game.CurrentOpponent.Hero));
Assert.Equal(1, game.CurrentOpponent.Hero.Armor);
Assert.Equal(0, game.CurrentOpponent.SecretZone.Count);
Assert.Equal(1, game.CurrentOpponent.Hero.Health);
game.Process(EndTurnTask.Any(game.CurrentPlayer));
game.Process(EndTurnTask.Any(game.CurrentPlayer));
// minion 2 now kills opponent
game.Process(MinionAttackTask.Any(game.CurrentPlayer, (Minion)minion3, game.CurrentOpponent.Hero));
Assert.True(game.CurrentOpponent.Hero.IsDead);
}
public override void Update()
{
var m = (Minion)Owner;
// Remove this EnrageEffect from the target
if (!On)
{
Game.Auras.Remove(this);
if (!_enraged)
{
return;
}
// Spiteful Smith
if (Type == AuraType.WEAPON)
{
Weapon weapon = m.Controller.Hero.Weapon;
if (weapon == null)
{
return;
}
if (_target != weapon)
{
return;
}
}
foreach (IEffect eff in EnchantmentCard.Power.Enchant.Effects)
{
eff.RemoveFrom(_target);
}
if (_currentInstance != null)
{
_currentInstance.Remove();
foreach (IEffect eff in EnchantmentCard.Power.Enchant.Effects)
{
Game.PowerHistory.Add(PowerHistoryBuilder.TagChange(
m.Id, eff.Tag, m[eff.Tag]));
}
}
//if (_target != null)
// for (int i = 0; i < Effects.Length; i++)
// Effects[i].RemoveFrom(_target.AuraEffects);
}
if (Type == AuraType.WEAPON)
{
Weapon weapon = m.Controller.Hero.Weapon;
if (weapon == null)
{
return;
}
if (_target != weapon)
{
_currentInstance?.Remove();
_currentInstance = null;
_target = weapon;
}
}
if (!_enraged)
{
if (m.Damage == 0)
{
return;
}
//if (_target != null)
// for (int i = 0; i < Effects.Length; i++)
// Effects[i].ApplyTo(_target.AuraEffects);
Generic.AddEnchantmentBlock(Game, EnchantmentCard, m, _target, 0, 0, 0);
if (Game.History)
{
_currentInstance = _target.AppliedEnchantments.Last();
}
_enraged = true;
}
else
{
if (m.Damage != 0)
{
return;
}
for (int i = 0; i < EnchantmentCard.Power.Enchant.Effects.Length; i++)
{
EnchantmentCard.Power.Enchant.Effects[i].RemoveFrom(m);
}
if (_currentInstance != null)
{
_currentInstance.Remove();
foreach (IEffect eff in EnchantmentCard.Power.Enchant.Effects)
{
Game.PowerHistory.Add(PowerHistoryBuilder.TagChange(
_target.Id, eff.Tag, _target[eff.Tag]));
}
}
_enraged = false;
}
}
#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
public override TaskState Process()
{
if (Controller.BoardZone.IsFull)
{
return(TaskState.STOP);
}
IList <IPlayable> entities = IncludeTask.GetEntities(Type, Controller, Source, Target, Playables).ToList();
if (entities.Count < 1)
{
return(TaskState.STOP);
}
// shuffle list randomly if needed
entities = RandomFlag ? entities.OrderBy(x => Util.Random.Next()).ToList() : entities;
if (RandomFlag)
{
Game.OnRandomHappened(true);
}
int space = Controller.BoardZone.MaxSize - Controller.BoardZone.Count;
space = entities.Count > space ? space : entities.Count;
if (entities[0].Zone == null || entities[0].Zone.Type != Enums.Zone.PLAY)
{
for (int i = 0; i < space; i++)
{
// clone task here
var task = new SummonTask(_side, entities[i].Card)
{
Game = Controller.Game,
Controller = Controller,
Source = Source as IPlayable,
Target = Target as IPlayable
};
Controller.Game.TaskQueue.Enqueue(task);
}
}
else
{
for (int i = 0; i < entities.Count; i++)
{
if (Controller.BoardZone.IsFull)
{
break;
}
Minion target = (Minion)entities[i];
var tags = new EntityData.Data((EntityData.Data)target.NativeTags);
if (target.Controller != Controller)
{
tags[GameTag.CONTROLLER] = Controller.PlayerId;
}
IPlayable copy = Entity.FromCard(Controller, target.Card, tags, Controller.BoardZone);
target.AppliedEnchantments?.ForEach(e =>
{
Enchantment instance = Enchantment.GetInstance(Controller, copy, copy, e.Card);
if (e[GameTag.TAG_SCRIPT_DATA_NUM_1] > 0)
{
instance[GameTag.TAG_SCRIPT_DATA_NUM_1] = e[GameTag.TAG_SCRIPT_DATA_NUM_1];
if (e[GameTag.TAG_SCRIPT_DATA_NUM_2] > 0)
{
instance[GameTag.TAG_SCRIPT_DATA_NUM_2] = e[GameTag.TAG_SCRIPT_DATA_NUM_2];
}
}
});
if (target.OngoingEffect != null && copy.OngoingEffect == null)
{
target.OngoingEffect.Clone(copy);
}
if (_addToStack)
{
Playables.Add(copy);
}
}
}
return(TaskState.COMPLETE);
}
public void ActivateTask(PowerActivation activation, IPlayable target = null, int chooseOne = 0, IPlayable source = null)
{
throw new NotImplementedException();
}
private async Task OpenPlayable(IPlayable playable, IPlaylist playlist, bool openPlaying, bool openCrossfading, bool addToTempHistory)
{
_isOpeningTrack = true;
if (CurrentTrack != null)
TrackChanged?.Invoke(this, new TrackChangedEventArgs(CurrentTrack, AudioEngine.TimePlaySourcePlayed));
CurrentTrack = playable;
CurrentPlaylist = playlist;
if (await AudioEngine.OpenTrack(await playable.GetSoundSource(), IsCrossfadeEnabled && openCrossfading, 0))
{
var track = playable as PlayableBase;
if (track != null)
playlist?.GetBackHistory().Add(track);
NewTrackOpened?.Invoke(this, new NewTrackOpenedEventArgs(playable));
if (addToTempHistory && (_tempHistory.Count == 0 || _tempHistory.Last().Item1 != playlist || _tempHistory.Last().Item2 != playable))
_tempHistory.Add(Tuple.Create(playlist, playable));
if (openPlaying && !(IsCrossfadeEnabled && openCrossfading))
await AudioEngine.TogglePlayPause();
}
_isOpeningTrack = false;
}
/////////////// GAME FLOW
public LogicMemory(IPlayable play)
{
this.play = play;
}
public Task OpenPlayable(IPlayable playable, IPlaylist playlist, bool openPlaying)
{
return OpenPlayable(playable, playlist, openPlaying, false, true);
}
protected Unit InsertUnit2(Vector3 position, IPlayable sound, bool is3DSound)
{
return new Unit { Position = position, Sound = sound, Is3DSound = is3DSound };
}
public NewTrackOpenedEventArgs(IPlayable newTrack)
{
NewTrack = newTrack;
}
public void Play(IPlayable playable, IPlayStrategy strategy)
{
_delayStrategy.StopTimer();
if (playable is PlayableFile)
{
var playableFile = playable as PlayableFile;
if (playableFile.File.Type == FileType.Audio)
{
_previousMusicPlayable = playableFile;
} else
{
_previousVideoPlayable = playableFile;
_videoPlayStrategy = strategy;
}
} else
{
_previousVideoPlayable = playable;
_videoPlayStrategy = strategy;
}
playable.Play(strategy, this);
// TODO : Remove this print
Console.WriteLine("Video Player Controller: {0}", playable.Name);
}
public override void Init()
{
playable = SoundManager.GetStream(Stream.ScoreScreenVictoryMusic1);
channel = playable.Play(new PlayArgs { Looping = true, FadeInTime = 1f });
}
private AdaptiveCostEffect(AdaptiveCostEffect prototype, IPlayable owner) : base(prototype, owner)
{
_operator = prototype._operator;
}
private void DisposeWave()
{
lock (mutex)
{
if (dataStream != null)
{
dataStream.Dispose();
dataStream = null;
}
if (audioBuffer != null)
{
audioBuffer.Dispose();
audioBuffer = null;
}
if (sourceVoice != null)
{
if (currentStream != null)
{
sourceVoice.BufferEnd -= bufferEndCallback;
}
sourceVoice.Stop();
sourceVoice.FlushSourceBuffers();
sourceVoice.Dispose();
sourceVoice = null;
}
current = null;
currentStream = null;
}
}
public Task OpenPlayable(IPlayable playable, IPlaylist playlist)
{
return OpenPlayable(playable, playlist, true, false, true);
}
public static PlayerTask KettleOptionToPlayerTask(Game Game, int sendOptionId, int sendOptionMainOption, int sendOptionTarget, int sendOptionPosition, int sendOptionSubOption)
{
SabberStoneCore.Kettle.PowerAllOptions allOptions = Game.AllOptionsMap[sendOptionId];
Console.WriteLine(allOptions.Print());
List <PlayerTask> tasks = allOptions.PlayerTaskList;
SabberStoneCore.Kettle.PowerOption powerOption = allOptions.PowerOptionList[sendOptionMainOption];
OptionType optionType = powerOption.OptionType;
PlayerTask task = null;
switch (optionType)
{
case OptionType.END_TURN:
task = EndTurnTask.Any(Game.CurrentPlayer);
break;
case OptionType.POWER:
SabberStoneCore.Kettle.PowerSubOption mainOption = powerOption.MainOption;
IPlayable source = Game.IdEntityDic[mainOption.EntityId];
ICharacter target = sendOptionTarget > 0 ? (ICharacter)Game.IdEntityDic[sendOptionTarget] : null;
List <SabberStoneCore.Kettle.PowerSubOption> subObtions = powerOption.SubOptions;
if (source.Zone?.Type == Zone.PLAY)
{
task = MinionAttackTask.Any(Game.CurrentPlayer, source, target);
}
else
{
switch (source.Card.Type)
{
case CardType.HERO:
if (target != null)
{
task = HeroAttackTask.Any(Game.CurrentPlayer, target);
}
else
{
task = PlayCardTask.Any(Game.CurrentPlayer, source);
}
break;
case CardType.HERO_POWER:
task = HeroPowerTask.Any(Game.CurrentPlayer, target);
break;
default:
task = PlayCardTask.Any(Game.CurrentPlayer, source, target, sendOptionPosition,
sendOptionSubOption);
break;
}
}
break;
case OptionType.PASS:
break;
default:
throw new NotImplementedException();
}
return(task);
}
public void Play(IPlayable comp)
{
var info = comp.GeneratePlayback();
Play(info);
}
void IAura.Activate(IPlayable owner)
{
ActivateInternal(owner);
}
Task<IPlayable> IPlaylist.GetPreviousTrack(IPlayable currentTrack)
{
return Task.FromResult(Tracks.GetPreviousTrack(currentTrack));
}
public void Clone(IPlayable clone)
{
ActivateInternal(clone, true);
}
public void AddTrackToQueue(IPlayable playable)
{
QueueItems.Add(new QueueItem {Playable = playable });
}
//public List<Game> Splits { get; set; } = new List<Game>();
//public IEnumerable<IEnumerable<IPlayable>> Sets { get; set; }
public virtual List <ISimpleTask> Build(Game game, Controller controller, IPlayable source, IPlayable target)
{
Game = game;
Controller = controller;
Source = source;
Target = target;
return(new List <ISimpleTask> {
this
});
}
public void RemoveTrackFromQueue(IPlayable playable)
{
RemoveQueueItem(QueueItems.First(x => x.Playable == playable));
}
public void BasicHealthAuraTest1()
{
var game =
new Game(new GameConfig
{
StartPlayer = 1,
Player1HeroClass = CardClass.PALADIN,
Player2HeroClass = CardClass.MAGE,
FillDecks = true,
FillDecksPredictably = true
});
game.Player1.BaseMana = 10;
game.Player2.BaseMana = 10;
game.StartGame();
var minion1 = (Minion)Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Stormwind Champion"));
var minion2 = (Minion)Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Stormwind Champion"));
var minion3 = (Minion)Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Shattered Sun Cleric"));
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion1)); // 6/6
game.CurrentPlayer.UsedMana = 0;
game.Process(PlayCardTask.Minion(game.CurrentPlayer, minion2)); // 7/7
game.CurrentPlayer.UsedMana = 0;
game.Process(PlayCardTask.MinionTarget(game.CurrentPlayer, minion3, minion2));
game.CurrentPlayer.UsedMana = 0;
Assert.Equal(7, minion1.AttackDamage);
Assert.Equal(7, minion1.Health);
Assert.Equal(8, minion2.AttackDamage);
Assert.Equal(8, minion2.Health);
Assert.Equal(5, minion3.AttackDamage);
Assert.Equal(4, minion3.Health);
game.Process(EndTurnTask.Any(game.CurrentPlayer)); // (7/7), (8/8), (5/4)
IPlayable spell1 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Flamestrike"));
game.Process(PlayCardTask.Spell(game.CurrentPlayer, spell1)); // (7/3), (8/4)
game.CurrentPlayer.UsedMana = 0;
IPlayable spell2 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Arcane Explosion"));
game.Process(PlayCardTask.Spell(game.CurrentPlayer, spell2));
IPlayable spell3 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Arcane Explosion"));
game.Process(PlayCardTask.Spell(game.CurrentPlayer, spell3));
Assert.Equal(2, ((ICharacter)minion2).Health); // (7/1), (8/2)
IPlayable spell4 = Generic.DrawCard(game.CurrentPlayer, Cards.FromName("Arcane Explosion"));
game.Process(PlayCardTask.Spell(game.CurrentPlayer, spell4));
Assert.Equal(1, ((ICharacter)minion2).Health); // (7/1)
Assert.Equal(Zone.PLAY, ((ICharacter)minion2).Zone.Type);
}
