protected override void OnExecuteEvent(VEntity entity) { DeathEventComponent ecDeath = VEntityComponentSystemManager.GetVComponent <DeathEventComponent>(entity); VEntity dyingEntity = ecsManager.GetVEntityById(ecDeath.id); if (dyingEntity != null) { HealthComponent h = dyingEntity.GetVComponent <HealthComponent>(); if (h != null && h.currHealth > 0) { return; } ecsManager.MarkRemovalEntity(dyingEntity); // remove the entity from all relevant things UnitsList unitsList = ecsManager.GetVSingletonComponent <UnitsList>(); unitsList.unitIds.Remove(dyingEntity.id); PositionTrackSystem positionTrackSystem = ecsManager.GetSystem <PositionTrackSystem>(); positionTrackSystem.Untrack(dyingEntity.id); ecsManager.QueueAnimationEvent("DeathAnimation", component: new DeathAnimationEvent { deathTransform = dyingEntity.GetVComponent <PositionDisplayComponent>().mainTransform, dyingEntityId = dyingEntity.id }); } }
protected override void OnBeforeEvent(VEntity entity) { LowLevelDealDamageEvent dealDamage = entity.GetVComponent <LowLevelDealDamageEvent>(); VEntity blockingEntity = ecsManager.GetVEntityById(dealDamage.receiverId); BlockBuffComponent block = blockingEntity.GetVComponent <BlockBuffComponent>(); if (block != null) { int blockDeduct = Math.Min(block.blockAmount, dealDamage.damageAmount); block.blockAmount -= blockDeduct; dealDamage.damageAmount -= blockDeduct; if (blockingEntity.HasVComponent <BlockDisplayComponent>()) { int newBlockAmount = block.blockAmount; NumberedIconDisplay blockDisplay = blockingEntity.GetVComponent <BlockDisplayComponent>().blockDisplay; ecsManager.QueueAnimationEvent("blockRemoveEvent", component: new GenericBlockingAnimationEvent { a = (passedEcsManager) => { blockDisplay.transform.DOShakePosition(.5f, .1f); blockDisplay.SetValue(newBlockAmount); }, duration = 0.5f }); } } }
protected override void OnExecuteEvent(VEntity entity) { LowLevelDealDamageEvent damageEvent = entity.GetVComponent <LowLevelDealDamageEvent>(); if (damageEvent.damageAmount <= 0) { return; } VEntity damageDealtEntity = ecsManager.GetVEntityById(damageEvent.receiverId); HealthComponent h = VEntityComponentSystemManager.GetVComponent <HealthComponent>(damageDealtEntity); h.currHealth -= damageEvent.damageAmount; if (h.currHealth <= 0) { h.currHealth = 0; ecsManager.CreateEvent("unitDeath", component: new DeathEventComponent { id = damageDealtEntity.id }); } ecsManager.QueueAnimationEvent("setHealth", components: new VComponent[] { new HealthSetAnimationEvent { targetEntity = damageDealtEntity.id, currHealth = h.currHealth, maxHealth = h.maxHealth }, new UnitDamagedAnimationEvent { targetEntity = damageDealtEntity.id } }); }
public override void DoImmediateAnimation(VEntity entity) { VEntity targetEntity = ecsManager.GetVEntityByIdIncludingRemoved(entity.GetVComponent <EntityAppearEvent>().entityId); HealthDisplayComponent healthDisplay = ecsManager.GetVEntityById(entity.GetVComponent <EntityAppearEvent>().entityId).GetVComponent <HealthDisplayComponent>(); healthDisplay.healthBarDisplay = HealthBarDisplay.Instantiate(healthBarDisplayPrefab); HealthComponent h = targetEntity.GetVComponent <HealthComponent>(); Assert.IsNotNull(h); healthDisplay.healthBarDisplay.Init(h.maxHealth); healthDisplay.healthBarDisplay.SetValue(h.currHealth); var positionDisplay = targetEntity.GetVComponent <PositionDisplayComponent>(); healthDisplay.healthBarDisplay.transform.position = positionDisplay.mainTransform.position; healthDisplay.healthBarDisplay.transform.SetParent(positionDisplay.mainTransform); }
protected override void OnPlayerTurnStart(VEntity entity) { PlayerHandComponent playerHandComponent = entity.GetVComponent <PlayerHandComponent>(); ecsManager.CreateEvent("StartTurnDraw", component: new CardDrawEvent { numCards = playerHandComponent.startTurnDrawCount }); }
public override IEnumerator StartAnimation(VEntity entity, Action yieldAnimation) { MovementAnimationEvent moveEvent = entity.GetVComponent <MovementAnimationEvent>(); Tween myTween = ecsManager.GetVEntityById(moveEvent.entityToMove).GetVComponent <PositionDisplayComponent>().mainTransform.DOMove(ecsManager.GetSystem <PositionWorldConversionSystem>().GetTransformFromCoord(moveEvent.to), 0.5f); yield return(myTween.WaitForCompletion()); yieldAnimation(); }
public override IEnumerator StartAnimation(VEntity entity, Action yieldAnimation) { GenericBlockingAnimationEvent genericAnim = entity.GetVComponent <GenericBlockingAnimationEvent>(); genericAnim.a(ecsManager); yield return(new WaitForSeconds(genericAnim.duration)); yieldAnimation(); }
private void UpdateBoardForSelectCardState() { if (currTargetingState.cardHoveringId != prevTargetingState.cardHoveringId || currTargetingState.state != prevTargetingState.state) { // ClearCellMarks(VCellSelectedState.GREEN); //Un-outline all cells. //Remove all ValidSpace marks. //Remove all GroupTarget marks. ecsManager.GetAnimationSystem <HighlightDisplaySystem>().Remove(null, new string[] { "Outline", "ValidSpace", "GroupTarget" }); IEnumerable <VEntity> characters = ecsManager.GetSystem <UnitFinderSystem>().GetAllPlayerUnits(); foreach (VEntity c in characters) { GetList(targetingSpaces, c.id).Clear(); } if (currTargetingState.cardHoveringId != "") { VEntity card = ecsManager.GetVEntityById(currTargetingState.cardHoveringId); CardClassComponent cardClass = card.GetVComponent <CardClassComponent>(); TargetingComponent cardTargeter = card.GetVComponent <TargetingComponent>(); foreach (VEntity character in characters) { CharacterClassComponent characterClass = character.GetVComponent <CharacterClassComponent>(); PositionComponent characterPosition = character.GetVComponent <PositionComponent>(); if (cardClass.cardType == characterClass.cardType || cardClass.cardType == CardType.NEUTRAL) { foreach (TargetingMethod targetingMethod in cardTargeter.targetingMethods) { List <Coord> newCoords = targetingMethod.SelectCoords(characterPosition.position, ecsManager); foreach (Coord coord in newCoords) { ProcessCoord(character, coord, cardTargeter); } } } } } } }
public override bool ValidateCoord(Coord loc, VEntityComponentSystemManager boardState) { VEntity unit = boardState.GetSystem <UnitFinderSystem>().GetUnitAtCoord(loc); if (unit != null) { return(unit.GetVComponent <TeamComponent>().team == team); } return(false); }
public override void DoImmediateAnimation(VEntity entity) { HealthSetAnimationEvent healthSetEvent = entity.GetVComponent <HealthSetAnimationEvent>(); VEntity targetEntity = ecsManager.GetVEntityByIdIncludingRemoved(healthSetEvent.targetEntity); HealthDisplayComponent healthDisplay = targetEntity.GetVComponent <HealthDisplayComponent>(); if (healthDisplay != null) { healthDisplay.healthBarDisplay.SetValue(healthSetEvent.currHealth); } }
public void InitializeFromEntity(VEntity entity) { cardEntityId = entity.id; cost = entity.GetVComponent <ManaCostComponent>().cost; effect = entity.GetVComponent <EffectTextComponent>().effect; cardType = entity.GetVComponent <CardClassComponent>().cardType; nameText.text = entity.GetVComponent <CardNameComponent>().name; costText.text = cost.ToString(); effectText.text = effect; classText.text = StringUtils.ClassEnumToString(cardType); cardBacks.Add(CardType.NEUTRAL, neutralQuad); cardBacks.Add(CardType.ORION, orionQuad); cardBacks.Add(CardType.OPHELIA, opheliaQuad); foreach (CardType t in cardBacks.Keys) { cardBacks[t].SetActive(false); } cardBacks[cardType].SetActive(true); }
public override void DoImmediateAnimation(VEntity entity) { UnitDamagedAnimationEvent unitDamagedEvent = entity.GetVComponent <UnitDamagedAnimationEvent>(); VEntity targetEntity = ecsManager.GetVEntityByIdIncludingRemoved(unitDamagedEvent.targetEntity); UnitDisplayComponent unitDisplay = targetEntity.GetVComponent <UnitDisplayComponent>(); if (unitDisplay != null) { var tween = unitDisplay.unitDisplayGameObject.GetSpriteRenderer().DOColor(Color.red, 0.1f).SetLoops(4, LoopType.Yoyo); } }
protected override void OnBeforeEvent(VEntity eventEntity) { CardPlayEvent cardPlayEvent = eventEntity.GetVComponent <CardPlayEvent>(); VEntity card = ecsManager.GetVEntityById(cardPlayEvent.cardId); //ecsManager.ExecuteImmediateEvent("cardMoveInPlay", component: new CardZoneMoveEvent //{ // source = Zone.HAND, // destination = Zone.INPLAY, // card = card.id, //}); }
protected override void OnPlayerTurnStart(VEntity entity) { PlayerManaComponent playerMana = entity.GetVComponent <PlayerManaComponent>(); int oldMana = playerMana.currMana; playerMana.currMana = playerMana.maxMana; ecsManager.QueueAnimationEvent("ManaAnimation", component: new PlayerManaSetAnimation { oldMana = oldMana, newMana = playerMana.currMana, maxMana = playerMana.maxMana }); }
protected override void OnBeforeEvent(VEntity eventEntity) { CardPlayEvent cardPlayEvent = eventEntity.GetVComponent <CardPlayEvent>(); VEntity card = ecsManager.GetVEntityById(cardPlayEvent.cardId); PlayerManaComponent playerMana = ecsManager.GetVSingletonComponent <PlayerManaComponent>(); int prevMana = playerMana.currMana; playerMana.currMana -= card.GetVComponent <ManaCostComponent>().cost; ecsManager.QueueAnimationEvent("cardPlayedManaDrain", component: new PlayerManaSetAnimation { maxMana = playerMana.maxMana, newMana = playerMana.currMana, oldMana = prevMana, }); }
public override void DoImmediateAnimation(VEntity entity) { DeathAnimationEvent deathAnimationEvent = entity.GetVComponent <DeathAnimationEvent>(); if (deathAnimationEvent.deathTransform != null) { deathAnimationEvent.deathTransform.gameObject.SetActive(false); GameObject.Destroy(deathAnimationEvent.deathTransform.gameObject); } ecsManager.GetAnimationSystem <HighlightDisplaySystem>().Remove(null, new string[] { deathAnimationEvent.dyingEntityId }); }
protected override void OnExecuteEvent(VEntity eventEntity) { BlockApplyEffectEvent blockEvent = eventEntity.GetVComponent <BlockApplyEffectEvent>(); VEntity blockingEntity = ecsManager.GetVEntityById(blockEvent.sourceId); if (!blockingEntity.HasVComponent <BlockBuffComponent>()) { ecsManager.AddComponent(blockingEntity, new BlockBuffComponent { }); ecsManager.AddComponent(blockingEntity, new BlockDisplayComponent { blockDisplay = NumberedIconDisplay.Instantiate(iconDisplayPrefab) }); NumberedIconDisplay blockDisplayForAppear = blockingEntity.GetVComponent <BlockDisplayComponent>().blockDisplay; blockDisplayForAppear.gameObject.transform.SetParent(blockingEntity.GetVComponent <PositionDisplayComponent>().mainTransform); blockDisplayForAppear.gameObject.transform.localPosition = new Vector3(.1f, .1f, 0.0f); ecsManager.QueueAnimationEvent("blockAppearAnim", component: new GenericImmediateAnimationEvent { a = (passedEcsManager) => { blockDisplayForAppear.Appear(); } }); } BlockBuffComponent blockComponent = blockingEntity.GetVComponent <BlockBuffComponent>(); blockComponent.blockAmount += (blockEvent.blockAmount); string blockAmountString = blockComponent.blockAmount.ToString(); NumberedIconDisplay blockDisplay = blockingEntity.GetVComponent <BlockDisplayComponent>().blockDisplay; ecsManager.QueueAnimationEvent("blockIncrement", component: new GenericImmediateAnimationEvent { a = (passedEcsManager) => { blockDisplay.SetValue(blockAmountString); } }); }
protected override void OnEnemyActionsResolve(VEntity entity) { QueuedActionComponent queuedAction = entity.GetVComponent <QueuedActionComponent>(); List <VComponent> effectComponentList = ecsManager.CloneComponents(queuedAction.effects.Cast <VComponent>().ToList()); PositionComponent entityPosition = entity.GetVComponent <PositionComponent>(); Coord[] targetedCoords = Coord.ResolveRelativeCoords(queuedAction.relativeTargetedCoords, entityPosition.position); // fill in the components with the right data foreach (VComponent component in effectComponentList) { if (component is CardEffectComponent c) { c.sourceId = entity.id; c.targetCoord = Coord.nullCoord; c.groupTargetCoords = new List <Coord>(targetedCoords); } } ecsManager.ExecuteImmediateEvent("CardEffect", components: effectComponentList); ecsManager.RemoveComponent <QueuedActionComponent>(entity); //handle de highlight animation ecsManager.QueueAnimationEvent("wait", component: new GenericBlockingAnimationEvent { a = (passedEcsManager) => { }, duration = 0.5f, }); ecsManager.QueueAnimationEvent("dehighlight", component: new GenericImmediateAnimationEvent { a = (passedEcsManager) => { passedEcsManager.GetAnimationSystem <HighlightDisplaySystem>().Remove(targetedCoords, new List <string> { entity.id }); } }); }
protected override void OnEnemyActionsEnd(VEntity entity) { ecsManager.RemoveComponent <BlockBuffComponent>(entity); if (entity.HasVComponent <BlockDisplayComponent>()) { NumberedIconDisplay blockDisplay = entity.GetVComponent <BlockDisplayComponent>().blockDisplay; ecsManager.RemoveComponent <BlockDisplayComponent>(entity); ecsManager.QueueAnimationEvent("blockRemoveEvent", component: new GenericImmediateAnimationEvent { a = (passedEcsManager) => { blockDisplay.Break(); } }); } }
protected override void OnExecuteEvent(VEntity entity) { CardDrawEvent cardDraw = entity.GetVComponent <CardDrawEvent>(); CardZoneDataComponent zoneData = ecsManager.GetVSingletonComponent <CardZoneDataComponent>(); PlayerHandComponent PlayerHandComponent = ecsManager.GetVSingletonComponent <PlayerHandComponent>(); for (int cardDrawIndex = 0; cardDrawIndex < cardDraw.numCards; ++cardDrawIndex) { // get top card of deck //If deck is empty, shuffle discard into deck if (zoneData.zones[Zone.DECK].Count == 0) { //If there is no discard pile, draw fizzles. if (zoneData.zones[Zone.DISCARD].Count == 0) { return; } for (int i = zoneData.zones[Zone.DISCARD].Count - 1; i >= 0; i--) { ecsManager.ExecuteImmediateEvent("moveZone", component: new CardZoneMoveEvent { source = Zone.DISCARD, destination = Zone.DECK, card = zoneData.zones[Zone.DISCARD][i] }); } DeckHelper.Shuffle(zoneData.zones[Zone.DECK]); } string cardToDraw = zoneData.zones[Zone.DECK][0]; //If there's space, draw, else discard. if (zoneData.zones[Zone.HAND].Count < PlayerHandComponent.maxHandSize) { ecsManager.ExecuteImmediateEvent("moveZone", component: new CardZoneMoveEvent { source = Zone.DECK, destination = Zone.HAND, card = cardToDraw }); } else { ecsManager.ExecuteImmediateEvent("moveZone", component: new CardZoneMoveEvent { source = Zone.DECK, destination = Zone.DISCARD, card = cardToDraw }); } } }
private void UpdateBoardForSelectSpaceState() { if (currTargetingState.boardSpaceHovering != prevTargetingState.boardSpaceHovering || currTargetingState.state != prevTargetingState.state) { IEnumerable <VEntity> characters = ecsManager.GetSystem <UnitFinderSystem>().GetAllPlayerUnits(); foreach (VEntity c in characters) { GetList(groupTargetingSpaces, c.id).Clear(); } //Re-enable all ValidSpace marks. ecsManager.GetAnimationSystem <HighlightDisplaySystem>().SetEnable(null, new string[] { "ValidSpace" }, true); //Remove all GroupTarget marks. ecsManager.GetAnimationSystem <HighlightDisplaySystem>().Remove(null, new string[] { "GroupTarget" }); if (currTargetingState.boardSpaceHovering != Coord.nullCoord) { foreach (VEntity character in characters) { PositionComponent characterPosition = character.GetVComponent <PositionComponent>(); if (GetList(targetingSpaces, character.id).Contains(currTargetingState.boardSpaceHovering)) { VEntity card = ecsManager.GetVEntityById(currTargetingState.cardSelectedId); foreach (GroupTargetingMethod groupTargeting in card.GetVComponent <TargetingComponent>().groupTargetingMethods) { List <Coord> newCoords = groupTargeting.SelectGroupCoords(currTargetingState.boardSpaceHovering, characterPosition.position, ecsManager); Debug.Log("Group Targeting Method Coords: " + newCoords.Count); GetList(groupTargetingSpaces, character.id).AddRange(newCoords); //Highlight c. Tag it with GroupTarget, color based on the effectType //Disable ValidSpace mark, if it has one. ecsManager.GetAnimationSystem <HighlightDisplaySystem>().CreateHighlightsWithTags(newCoords, new string[] { "GroupTarget" }, ColorFromEffectType(groupTargeting.effectType)); //Debug.Log(ColorFromEffectType(groupTargeting.effectType)); ecsManager.GetAnimationSystem <HighlightDisplaySystem>().SetEnable(GetList(groupTargetingSpaces, character.id), new string[] { "ValidSpace" }, false); } } } } } }
protected override void OnExecuteEvent(VEntity entity) { DamageEffectEventComponent damageComponent = VEntityComponentSystemManager.GetVComponent <DamageEffectEventComponent>(entity); VEntity damageDealingEnitty = ecsManager.GetVEntityById(damageComponent.sourceId); foreach (Coord c in damageComponent.groupTargetCoords) { VEntity damageDealtEntity = ecsManager.GetSystem <UnitFinderSystem>().GetUnitAtCoord(c); if (damageDealtEntity != null && damageDealtEntity.GetVComponent <TeamComponent>().team != damageDealingEnitty.GetVComponent <TeamComponent>().team) { ecsManager.ExecuteImmediateEvent("lowLevelDamageEvent", component: new LowLevelDealDamageEvent { damageAmount = damageComponent.damageAmount, sourceId = damageComponent.sourceId, receiverId = damageDealtEntity.id }); } } }
protected override void OnExecuteEvent(VEntity entity) { CardDiscardEvent discardedCards = entity.GetVComponent <CardDiscardEvent>(); CardZoneDataComponent zoneData = ecsManager.GetVSingletonComponent <CardZoneDataComponent>(); PlayerHandComponent PlayerHandComponent = ecsManager.GetVSingletonComponent <PlayerHandComponent>(); foreach (string cardToDiscard in zoneData.zones[Zone.HAND].ToArray()) { if (Array.IndexOf(discardedCards.cardIds, cardToDiscard) >= 0) { ecsManager.ExecuteImmediateEvent("moveZone", component: new CardZoneMoveEvent { source = Zone.HAND, destination = Zone.DISCARD, card = cardToDiscard }); } } }
protected override void OnExecuteEvent(VEntity eventEntity) { CardPlayEvent cardPlayEvent = eventEntity.GetVComponent <CardPlayEvent>(); VEntity caster = ecsManager.GetVEntityById(cardPlayEvent.casterId); VEntity card = ecsManager.GetVEntityById(cardPlayEvent.cardId); Coord dest = cardPlayEvent.targetSpace; Dictionary <CardEffectType, List <Coord> > groupTargetCoords = cardPlayEvent.groupTargetingSpaces; foreach (CardEffectType t in groupTargetCoords.Keys) { Debug.Log("Type Key: " + t); } // create a new event entity with all the card actions GameplayEffectComponent effects = card.GetVComponent <GameplayEffectComponent>(); List <VComponent> effectComponentList = ecsManager.CloneComponents(effects.effectEvents.Cast <VComponent>().ToList()); // fill in the components with the right data foreach (VComponent component in effectComponentList) { if (component is CardEffectComponent c) { c.sourceId = caster.id; c.targetCoord = dest; c.groupTargetCoords = groupTargetCoords[EffectComponentToEffectTypeHelper(c)]; if (c is DamageEffectEventComponent d) { Debug.Log("Doing damage to " + c.groupTargetCoords.Count + " spaces."); } } } ecsManager.ExecuteImmediateEvent("CardEffect", components: effectComponentList); // move the card from the hand to the deck. ecsManager.ExecuteImmediateEvent("cardMoveToDiscard", component: new CardZoneMoveEvent { source = Zone.HAND, destination = Zone.DISCARD, card = card.id, }); }
void FinishPlayingCard(CardGameObject card, Coord space, VEntity caster) { Debug.Log("Finish playing card"); cardSelected.locked = false; cardSelected = null; VEntity cardPlayed = boardState.GetVEntityById(card.cardEntityId); TargetingComponent targeting = VEntityComponentSystemManager.GetVComponent <TargetingComponent>(cardPlayed); Dictionary <CardEffectType, List <Coord> > mapping = new Dictionary <CardEffectType, List <Coord> >(); foreach (GroupTargetingMethod m in targeting.groupTargetingMethods) { if (!mapping.ContainsKey(m.effectType)) { mapping[m.effectType] = new List <Coord>(); } mapping[m.effectType].AddRange(m.SelectGroupCoords(space, caster.GetVComponent <PositionComponent>().position, boardState)); } foreach (CardEffectType t in mapping.Keys) { Debug.Log("Type Key: " + t); } boardState.CreateEvent("playCard", component: new CardPlayEvent { cardId = card.cardEntityId, targetSpace = space, casterId = caster.id, groupTargetingSpaces = mapping }); if (card.cantrip) { boardState.CreateEvent("cantripUsed", component: new CantripUseEvent { }); } spaceSelected = Coord.nullCoord; State = InputState.SELECTCARD; cardController.MyHandState = HandState.IDLE; }
protected override void OnAfterEvent(VEntity eventEntity) { MovementEvent movement = eventEntity.GetVComponent <MovementEvent>(); VEntity movedEntity = ecsManager.GetVEntityById(movement.sourceId); QueuedActionComponent queuedAction = movedEntity.GetVComponent <QueuedActionComponent>(); if (queuedAction != null) { // update the view with animation event Coord[] targetedCoords = Coord.ResolveRelativeCoords(queuedAction.relativeTargetedCoords, movedEntity.GetVComponent <PositionComponent>().position); ecsManager.QueueAnimationEvent("highlight", component: new GenericImmediateAnimationEvent { a = (passedEcsManager) => { passedEcsManager.GetAnimationSystem <HighlightDisplaySystem>().CreateHighlightsWithTags(targetedCoords, new List <string> { "EnemyAttack", movedEntity.id }, passedEcsManager.GetAnimationSystem <HighlightDisplaySystem>().redColor); } }); } }
protected override void OnBeforeEvent(VEntity eventEntity) { MovementEvent movement = eventEntity.GetVComponent <MovementEvent>(); VEntity movedEntity = ecsManager.GetVEntityById(movement.sourceId); QueuedActionComponent queuedAction = movedEntity.GetVComponent <QueuedActionComponent>(); if (queuedAction != null) { Debug.Log("removing old highlights"); // update the view with animation event Coord[] targetedCoords = Coord.ResolveRelativeCoords(queuedAction.relativeTargetedCoords, movedEntity.GetVComponent <PositionComponent>().position); ecsManager.QueueAnimationEvent("highlight", component: new GenericImmediateAnimationEvent { a = (passedEcsManager) => { passedEcsManager.GetAnimationSystem <HighlightDisplaySystem>().Remove(null, new List <string> { movedEntity.id }); } }); } }
protected override void OnExecuteEvent(VEntity eventEntity) { QueueActionEvent queueActionEvent = eventEntity.GetVComponent <QueueActionEvent>(); VEntity queuer = ecsManager.GetVEntityById(queueActionEvent.entityId); ecsManager.AddComponent(queuer, new QueuedActionComponent { relativeTargetedCoords = Coord.cardinalCoords, effects = new List <CardEffectComponent> { new DamageEffectEventComponent { damageAmount = 5 } } }); Coord[] targetedCoords = Coord.ResolveRelativeCoords(queuer.GetVComponent <QueuedActionComponent>().relativeTargetedCoords, queuer.GetVComponent <PositionComponent>().position); ecsManager.QueueAnimationEvent("highlight", component: new GenericImmediateAnimationEvent { a = (passedEcsManager) => { passedEcsManager.GetAnimationSystem <HighlightDisplaySystem>().CreateHighlightsWithTags(targetedCoords, new List <string> { "EnemyAttack", queuer.id }, passedEcsManager.GetAnimationSystem <HighlightDisplaySystem>().redColor); } }); }
public Coord Resolve(RelativePositionComponent cRelativePosition) { VEntity eOrigin = ecsManager.GetVEntityById(cRelativePosition.relativeEntityId); return(eOrigin.GetVComponent <PositionComponent>().position + cRelativePosition.delta); }
public override bool ShouldOperate(VEntity entity) { EntityAppearEvent e = entity.GetVComponent <EntityAppearEvent>(); return(e != null && (ecsManager.GetVEntityById(e.entityId).GetVComponent <UnitDisplayComponent>() != null)); }