// 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); }