//敌人通用组件
public void InitEnemyCommomAbility(BasicEntity entity)
{
AbilityComponent ability = entity.GetComponent <AbilityComponent> ();
ability.m_residentAbility.Add(ComponentType.Monitor);
ability.m_residentAbility.Add(ComponentType.AI);
}
private static IEnumerable <GameEntity> GetActivatedEffects(
GameEntity effectEntity, AbilityComponent ability, GameManager manager)
{
var effect = effectEntity.Effect;
if (effect.EffectType != EffectType.Activate)
{
return(new[] { effectEntity });
}
var activatableEntity = manager.FindEntity(effect.TargetEntityId);
if (activatableEntity.HasComponent(EntityComponent.Ability))
{
return(manager.EffectsToContainingAbilityRelationship[activatableEntity.Id]
.SelectMany(e => GetActivatedEffects(e, ability, manager)));
}
var trigger = ability.Trigger == ActivationType.Default
? AbilityActivationSystem.GetTrigger(ability)
: ability.Trigger;
var triggeredAbility = AbilityActivationSystem
.GetTriggeredAbilities(activatableEntity.Id, trigger, manager)
.FirstOrDefault();
if (triggeredAbility == null)
{
return(Enumerable.Empty <GameEntity>());
}
return(manager.EffectsToContainingAbilityRelationship[triggeredAbility.Id]
.SelectMany(e => GetActivatedEffects(e, ability, manager)));
}
private void LaunchAbilityPosition()
{
Vector3 spawnPos = Vector3.zero;
GameObject projectileObj = null;
switch (m_ability.AbilityBase.SkillShotType)
{
case ESkillShotType.FrontSkill:
spawnPos = m_attacker.GetTransformPosition(m_ability.AbilityBase.LaunchPos).transform.position;
break;
case ESkillShotType.FloorSkill:
if (m_ability.AbilityBase.LaunchPos == EEntityTransform.Floor)
{
spawnPos = Utils.Vector2ToVector3(m_targetPos);
}
else
{
spawnPos = m_attacker.GetTransformPosition(m_ability.AbilityBase.LaunchPos).transform.position;
}
break;
default:
break;
}
projectileObj = SpawnManager.instance.InstantiatePool(m_ability.AbilityBase.ProjectileIdentifier, spawnPos, m_attacker.GetTransformPosition(m_ability.AbilityBase.LaunchPos).transform.rotation);
AbilityComponent projectile = projectileObj.GetComponent <AbilityComponent>();
projectile.Initialize(m_attacker, Utils.Vector2ToVector3(m_targetPos), m_ability, m_attacker.EntityAbilities.ServerAbilityHit);
int projectileInstanceID = projectile.gameObject.GetInstanceID();
projectile.ServerInstanceId = m_ability.AbilityBase.ProjectileIdentifier + "_" + projectileInstanceID;
m_attacker.EntityAbilities.CacheActiveAbility(projectile);
m_attacker.EntityAbilities.RpcSpawnPositionProjectile(m_attacker.transform.rotation, m_ability.AbilityBase.ProjectileIdentifier, projectile.ServerInstanceId, projectile.Ability.AbilityBase.Identifier, Utils.Vector2ToVector3(m_targetPos), NetworkTime.Instance.ServerStep());
}
//每帧都会调用对应的实体
public override void Execute(List <BasicEntity> entities)
{
foreach (BasicEntity e in entities)
{
AttackComponent attack = e.GetComponent <AttackComponent> ();
VoxelBlocks map = GameObject.Find("Voxel Map").transform.GetComponent <VoxelBlocks> ();
AbilityComponent ab = e.GetComponent <AbilityComponent> ();
InputComponent input = e.GetComponent <InputComponent> ();
StateComponent ap = e.GetComponent <StateComponent> ();
int i = AiToInput.GetAbilityCount(e, M_LinkedType);
//检测是否按下攻击键
if (i >= ab.m_temporaryAbility.Count || i != input.currentKey)
{
continue;
}
//若无攻击对象则获取周围可攻击对象
if (attack.enemy == null)
{
attack.enemy = GetEnemyAround(e);
if (attack.enemy == null)
{
return;
}
}
List <Vector3> el = new List <Vector3> ();
foreach (var enemy in attack.enemy)
{
el.Add(enemy.GetComponent <BlockInfoComponent> ().m_logicPosition);
}
UISimple ui = GameObject.Find("UI").GetComponent <UISimple> ();
ui.ShowUI(el, 2);
//左键攻击
if (input.leftButtonDown)
{
BasicEntity enemy = map.GetBlockByLogicPos(input.currentPos).entity;
//检测当前选中敌人是否处于攻击范围内
List <BasicEntity> list = GetEnemyAround(e);
if (list != null && !list.Contains(enemy))
{
attack.enemy = list;
return;
}
//扣除敌人HP值
DeadComponent dead = enemy.GetComponent <DeadComponent> ();
StateComponent state = e.GetComponent <StateComponent> ();
dead.hp -= attack.STR;
state.m_actionPoint -= 1;
state.Invoke("AnimationEnd", 1);
state.AnimationStart();
//播放攻击动画
//播放敌人受击动画
//减少AP
}
}
}
/// Use as a constructor to init local variables
protected virtual void EnterState(Enemy owner, GameObject lastInfluence)
{
this.owner = owner;
lastThreat = lastInfluence;
spawn = owner.Spawn;
abilComponent = owner.abilityComponent;
}
public AIActingState(Unit Owner,
List <PathfindingData> tilesInRange, PathfindingData targetTile) : base(Owner)
{
this.tilesInRange = tilesInRange;
this.targetTile = targetTile;
this.abilityComponent = Owner.AbilityComponent;
}
public void AddHereticAbility(BasicEntity entity)
{
AbilityComponent ability = entity.GetComponent <AbilityComponent> ();
ability.m_temporaryAbility.Add(ComponentType.Move);
ability.m_temporaryAbility.Add(ComponentType.Attack);
ability.m_temporaryAbility.Add(ComponentType.Input);
}
public void ServerAbilityHit(AbilityComponent projectile, bool abilityHit)
{
SpawnManager.instance.DestroyPool(projectile.gameObject);
if (m_activeAbilities.ContainsKey(projectile.ServerInstanceId))
{
m_activeAbilities.Remove(projectile.ServerInstanceId);
}
RpcAbilityHitOnClient(projectile.ServerInstanceId, NetworkTime.Instance.ServerStep(), abilityHit);
}
public void SpawnPlayer(Vector2 position)
{
if (pool == null)
{
pool = ObjectPool.instance;
}
if (Player != null)
{
PositionComponent posComp = (PositionComponent)Player.GetEntityComponent(ComponentID.Position);
posComp.moveData = new MoveData(position.x, position.y);
EntityGOMap[Player].transform.position = position;
Player.ChangeActiveStatus(true);
EntityActionManager.instance.EntityOnTileChanged(Player, posComp.moveData);
return;
}
EntityPrototype proto = GetProtoType("Player");//EntityProtoMap["Player"];
EntityComponent[] components = ReadProtoComponents(proto.components);
GameObject entityGO = pool.GetObjectForType("Player", true, position);
if (entityGO == null)
{
// Make a new one?
return;
}
Player = new Entity(proto.Name, proto.entityType, components, isPlayer: true);
PositionComponent posC = (PositionComponent)Player.GetEntityComponent(ComponentID.Position);
posC.moveData = new MoveData(position.x, position.y);
Player.InitComponent(entityGO);
AbilityComponent abilityComponent = (AbilityComponent)Player.GetEntityComponent(ComponentID.Abilities);
abilityComponent.AddAbility(AbilityID.Blood_For_Light, true, "25% HP");
//InventoryComponent inventoryComponent = (InventoryComponent)Player.GetEntityComponent(ComponentID.Inventory);
//PlayerInputSystem.instance.AddDynamicKeys(() => inventoryComponent.Drop(0), "t");
Player.ChangeActiveStatus(true);
EntityGOMap.Add(Player, entityGO);
Player.CanEndTurnCB = CanPlayerEndTurn;
// Register input callbacks
PlayerInputSystem.instance.RegisterOnMoveInputCB((data) => posC.Move(data));
GetPlayerPositionData += posC.GetPositionData;
}
//通用组件
public void InitCommomAbility(BasicEntity entity)
{
//增加ability组件
AbilityComponent ability = (AbilityComponent)entity.AddComponent(ComponentType.Ability);
ability.m_residentAbility.Add(ComponentType.State);
ability.m_residentAbility.Add(ComponentType.Dead);
ability.m_residentAbility.Add(ComponentType.Hide);
ability.m_residentAbility.Add(ComponentType.UI);
}
protected void AddEffects(ISet <Effect> effects, AbilityComponent ability, GameManager manager)
{
if (effects != null)
{
foreach (var effect in effects)
{
effect.AddToAbility(ability, manager);
}
}
}
public void Setting_component_property_fires_events()
{
var manager = TestHelper.CreateGameManager();
using (var entityReference = manager.CreateEntity())
{
var component = manager.CreateComponent <AbilityComponent>(EntityComponent.Ability);
AbilityComponent expectedCurrentValue = null;
var expectedNewValue = component;
var entity = entityReference.Referenced;
var propertyChangingCalled = false;
entity.PropertyChanging += (s, e) =>
{
propertyChangingCalled = true;
Assert.Equal(nameof(GameEntity.Ability), e.PropertyName);
Assert.Equal(expectedCurrentValue, ((GameEntity)s).Ability);
};
var propertyChangedCalled = false;
entity.PropertyChanged += (s, e) =>
{
propertyChangedCalled = true;
Assert.Equal(nameof(GameEntity.Ability), e.PropertyName);
Assert.Equal(expectedNewValue, ((GameEntity)s).Ability);
};
entity.Ability = null;
Assert.False(propertyChangingCalled);
Assert.False(propertyChangedCalled);
entity.Ability = component;
Assert.True(propertyChangingCalled);
Assert.True(propertyChangedCalled);
Assert.Same(component, entity.FindComponent((int)EntityComponent.Ability));
Assert.True(entity.HasComponent(EntityComponent.Ability));
propertyChangingCalled = false;
propertyChangedCalled = false;
expectedCurrentValue = component;
expectedNewValue = null;
entity.Ability = null;
Assert.True(propertyChangingCalled);
Assert.True(propertyChangedCalled);
Assert.Null(entity.FindComponent((int)EntityComponent.Ability));
Assert.False(entity.HasComponent(EntityComponent.Ability));
}
}
public override void Execute(List <BasicEntity> entities)
{
foreach (var entity in entities)
{
KnockComponent knock = entity.gameObject.GetComponent <KnockComponent>();
AbilityComponent ab = entity.GetComponent <AbilityComponent>();
InputComponent input = entity.GetComponent <InputComponent>();
StateComponent ap = entity.GetComponent <StateComponent>();
int i = AiToInput.GetAbilityCount(entity, M_LinkedType);
if (i >= ab.m_temporaryAbility.Count || i != input.currentKey)
{
knock.m_area = null;
continue;
}
//获取影响范围
if (knock.m_area == null)
{
knock.m_area = FindPath.GetArea(knock.GetComponent <BlockInfoComponent>().m_logicPosition, knock.m_ridus);
}
UISimple ui = GameObject.Find("UI").GetComponent <UISimple>();
ui.ShowUI(knock.m_area, 3);
VoxelBlocks map = GameObject.Find("Voxel Map").GetComponent <VoxelBlocks>();
List <BasicEntity> enemy = new List <BasicEntity>();
//获取影响范围内的敌人
foreach (var pos in knock.m_area)
{
var e = map.GetBlockByLogicPos(pos).entity;
if (e != null)
{
if (e.GetComponent <BlockInfoComponent>().m_blockType == BlockType.Enemy)
{
enemy.Add(e);
}
}
}
//UI显示范围与敌人
if (input.leftButtonDown)
{
foreach (var e in enemy)
{
Debug.Log(e.name);
e.GetComponent <MonitorComponent>().m_voice.Add(entity.GetComponent <BlockInfoComponent>().m_logicPosition);
}
ui.ShowUI(null, 3);
StateComponent state = entity.GetComponent <StateComponent>();
state.m_actionPoint -= 1;
state.AnimationStart();
state.Invoke("AnimationEnd", 1);
}
}
}
public bool RemoveAbility(BasicEntity entity, ComponentType type)
{
AbilityComponent ability = entity.GetComponent <AbilityComponent> ();
if (ability == null)
{
return(false);
}
ability.m_temporaryAbility.Remove(type);
return(true);
}
public void AddVeteranAbility(BasicEntity entity)
{
AbilityComponent ability = entity.GetComponent <AbilityComponent> ();
ability.m_temporaryAbility.Add(ComponentType.Move);
ability.m_temporaryAbility.Add(ComponentType.Attack);
ability.m_temporaryAbility.Add(ComponentType.Knock);
ability.m_temporaryAbility.Add(ComponentType.CheerUp);
ability.m_temporaryAbility.Add(ComponentType.Input);
ability.m_temporaryAbility.Add(ComponentType.Item);
}
public void AddHackerAbility(BasicEntity entity)
{
AbilityComponent ability = entity.GetComponent <AbilityComponent> ();
// ability.m_temporaryAbility.Add (ComponentType.Drone);
ability.m_temporaryAbility.Add(ComponentType.Move);
ability.m_temporaryAbility.Add(ComponentType.Attack);
ability.m_temporaryAbility.Add(ComponentType.Knock);
ability.m_temporaryAbility.Add(ComponentType.Input);
ability.m_temporaryAbility.Add(ComponentType.Item);
}
public override void Render()
{
if (targetItem == null)
{
return;
}
SerializedPropertyX contextTypeProp = rootProperty["contextType"];
Type selectedType;
if (typePopUp.DrawPopup("Context Type", contextTypeProp.GetValue <Type>(), out selectedType))
{
SerializedPropertyX componentsProp = rootProperty["components"];
SerializedPropertyX requirementsProp = rootProperty["requirements"];
List <SerializedPropertyX> nukeList = new List <SerializedPropertyX>();
for (int i = 0; i < componentsProp.ChildCount; i++)
{
AbilityComponent component = componentsProp.GetChildAt(i).Value as AbilityComponent;
if (!selectedType.IsAssignableFrom(component.GetContextType()))
{
nukeList.Add(componentsProp.GetChildAt(i));
}
}
for (int i = 0; i < requirementsProp.ChildCount; i++)
{
Requirement requirement = requirementsProp.GetChildAt(i).Value as Requirement;
if (!selectedType.IsAssignableFrom(requirement.GetContextType()))
{
nukeList.Add(requirementsProp.GetChildAt(i));
}
}
if (nukeList.Count > 0)
{
if (ShouldNuke(nukeList, selectedType))
{
for (int i = 0; i < nukeList.Count; i++)
{
SerializedPropertyX toNuke = nukeList[i];
int reqChildIndex = requirementsProp.GetChildIndex(toNuke);
int comChildIndex = componentsProp.GetChildIndex(toNuke);
requirementsProp.DeleteArrayElementAt(reqChildIndex);
componentsProp.DeleteArrayElementAt(comChildIndex);
}
contextTypeProp.Value = selectedType;
}
}
else
{
contextTypeProp.Value = selectedType;
}
}
}
//增加临时组件
public bool AddTemporaryComponent(BasicEntity entity)
{
AbilityComponent ability = entity.GetComponent <AbilityComponent> ();
if (ability == null)
{
return(false);
}
foreach (ComponentType c in ability.m_temporaryAbility)
{
entity.AddComponent(c);
}
return(true);
}
public override void Run()
{
m_attacker.transform.rotation = m_entityRotation;
AbilityBase abilityBase = AbilityManager.instance.GetAbilityBase(m_abilityIdentifier);
Ability ability = m_attacker.EntityAbilities.GetAbility(abilityBase.AttackType);
EntityTransform launchPos = m_attacker.GetTransformPosition(abilityBase.LaunchPos);
GameObject projectileObj = SpawnManager.instance.InstantiatePool(m_projectileIdentifier + "Client", launchPos.transform.position, launchPos.transform.rotation);
AbilityComponent abilityComponent = projectileObj.GetComponent <AbilityComponent>();
abilityComponent.ServerInstanceId = m_instanceId;
abilityComponent.Initialize(m_attacker, m_targetPos, ability);
m_attacker.EntityAbilities.CacheActiveAbility(abilityComponent);
}
private static void TrySlot(AbilityComponent ability, GameManager manager)
{
var owner = ability.OwnerEntity;
if (owner.AI == null ||
(ability.Activation & ActivationType.Slottable) == 0 ||
ability.Slot != null ||
!ability.IsUsable ||
ability.Template?.Type == AbilityType.DefaultAttack)
{
return;
}
for (var i = 0; i < owner.Being.AbilitySlotCount; i++)
{
if (manager.SlottedAbilitiesIndex[(owner.Id, i)] != null)
static public int GetAbilityCount(BasicEntity entity, ComponentType type)
{
AbilityComponent ability = entity.GetComponent <AbilityComponent> ();
if (ability == null || ability.m_coldDown.ContainsKey(type))
{
return(-1);
}
int i;
for (i = 0; i < ability.m_temporaryAbility.Count; i++)
{
if (ability.m_temporaryAbility [i] == type)
{
return(i + 1);
}
}
return(-1);
}
public void ClientAbilityHit(string instanceId, bool abilityHit)
{
if (m_activeAbilities.ContainsKey(instanceId))
{
AbilityComponent AbilityComponent = m_activeAbilities[instanceId];
AbilityBase abilityBase = AbilityComponent.Ability.AbilityBase;
SpawnManager.instance.DestroyPool(AbilityComponent.gameObject);
m_activeAbilities.Remove(AbilityComponent.ServerInstanceId);
if (abilityHit && AbilityComponent.Ability.AbilityBase.ImpactParticleIdentifier != "")
{
SpawnManager.instance.InstantiatePool(abilityBase.ImpactParticleIdentifier, AbilityComponent.transform.position, AbilityComponent.transform.rotation);
}
if (abilityHit && !string.IsNullOrEmpty(abilityBase.ImpactSoundIdentifier))
{
AudioManager.instance.Play3dSound(abilityBase.ImpactSoundIdentifier, abilityBase.ImpactSoundVolume, AbilityComponent.transform.position);
}
}
}
private void LaunchAbilityTarget()
{
switch (m_ability.AbilityBase.Processor)
{
case AbilityProcessorType.DamageImpact:
foreach (MobaEntity entity in m_targets)
{
new DamageProcess(m_attacker, entity, m_ability);
if (m_ability.AbilityBase.ImpactParticleIdentifier != "")
{
EntityTransform impactTarget = entity.GetTransformPosition(m_ability.AbilityBase.LaunchPos);
SpawnManager.instance.InstantiatePool(m_ability.AbilityBase.ImpactParticleIdentifier, impactTarget.transform.position, impactTarget.transform.rotation);
entity.EntityAbilities.RpcSpawnImpactParticle(m_ability.AbilityBase.ImpactParticleIdentifier, (int)EEntityTransform.Center);
}
}
break;
case AbilityProcessorType.LaunchAbility:
foreach (MobaEntity targetEntity in m_targets)
{
EntityTransform spawnPos = m_attacker.GetTransformPosition(m_ability.AbilityBase.LaunchPos);
GameObject projectileObj = SpawnManager.instance.InstantiatePool(m_ability.AbilityBase.ProjectileIdentifier, spawnPos.transform.position, spawnPos.transform.rotation);
AbilityComponent projectile = projectileObj.GetComponent <AbilityComponent>();
projectile.Initialize(m_attacker, targetEntity, m_ability, m_attacker.EntityAbilities.ServerAbilityHit);
int projectileInstanceID = projectile.gameObject.GetInstanceID();
projectile.ServerInstanceId = m_ability.AbilityBase.ProjectileIdentifier + "_" + projectileInstanceID;
m_attacker.EntityAbilities.CacheActiveAbility(projectile);
m_attacker.EntityAbilities.RpcSpawnTargetProjectile(m_attacker.transform.rotation, m_ability.AbilityBase.ProjectileIdentifier, projectile.ServerInstanceId, projectile.Ability.AbilityBase.Identifier, targetEntity.InstanceId, NetworkTime.Instance.ServerStep());
}
break;
case AbilityProcessorType.CastSideEffectsOnly:
foreach (MobaEntity targetEntity in m_targets)
{
targetEntity.EntityAbilities.ApplyAbilityEffects(m_ability, m_attacker);
}
break;
default:
break;
}
}
/*
* private void InitActionPoint ()
* {
* //如果所有的心动数值状态都是0，那么就重置行动点
* bool needReset = true;
* foreach (BasicEntity e in playerActionList) {
* StateComponent state = (StateComponent)e.GetSpecicalComponent (ComponentType.State);
* if (state.m_actionPoint > 0) {
* needReset = false;
* }
* }
* foreach (BasicEntity e in enemyActionList) {
* StateComponent state = (StateComponent)e.GetSpecicalComponent (ComponentType.State);
* if (state.m_actionPoint > 0) {
* needReset = false;
* }
* }
* //todo:需要根据不同的规则计算行动点
* if (needReset) {
* foreach (BasicEntity e in playerActionList) {
* StateComponent state = (StateComponent)e.GetSpecicalComponent (ComponentType.State);
* state.m_actionPoint = 5;
*
* }
* foreach (BasicEntity e in enemyActionList) {
* StateComponent state = (StateComponent)e.GetSpecicalComponent (ComponentType.State);
* state.m_actionPoint = 5;
* }
* }
* }
*/
private void InitActionPoint(List <BasicEntity> actionList)
{
foreach (BasicEntity e in actionList)
{
StateComponent state = (StateComponent)e.GetSpecicalComponent(ComponentType.State);
AbilityComponent ability = (AbilityComponent)e.GetSpecicalComponent(ComponentType.Ability);
state.m_actionPoint = e.GetComponent <PropertyComponent> ().AP;
//减少CD
foreach (ComponentType ct in ability.m_temporaryAbility)
{
if (ability.m_coldDown.ContainsKey(ct))
{
ability.m_coldDown [ct]--;
if (ability.m_coldDown [ct] < 0)
{
ability.m_coldDown.Remove(ct);
}
}
}
}
}
public EffectComponent AddToAbility(AbilityComponent ability, GameManager manager)
{
var continuous = (ability.Activation & ActivationType.Continuous) != 0;
using (var effectEntityReference = manager.CreateEntity())
{
var effect = manager.CreateComponent <EffectComponent>(EntityComponent.Effect);
effect.ContainingAbilityId = ability.EntityId;
effect.ShouldTargetActivator = TargetActivator;
effectEntityReference.Referenced.Effect = effect;
ConfigureEffect(effect);
if (continuous &&
effect.Duration == EffectDuration.Instant)
{
effect.Duration = EffectDuration.Infinite;
}
return(effect);
}
}
public override void Execute(List <BasicEntity> entities)
{
foreach (BasicEntity entity in entities)
{
AbilityComponent ab = entity.GetComponent <AbilityComponent>();
InputComponent input = entity.GetComponent <InputComponent>();
StateComponent ap = entity.GetComponent <StateComponent>();
CheerUpComponent cu = entity.GetComponent <CheerUpComponent>();
int i = AiToInput.GetAbilityCount(entity, M_LinkedType);
if (i >= ab.m_temporaryAbility.Count || i != input.currentKey)
{
continue;
}
ap.AnimationStart();
ap.m_actionPoint += cu.m_addAp;
if (!ab.m_coldDown.ContainsKey(M_LinkedType))
{
ab.m_coldDown.Add(M_LinkedType, cu.m_coldDown);
}
ap.Invoke("AnimationEnd", 1);
}
}
public void CacheActiveAbility(AbilityComponent projectile)
{
m_activeAbilities.Add(projectile.ServerInstanceId, projectile);
}
protected Brain(Unit owner)
{
this.owner = owner;
this.abilityComponent = owner.AbilityComponent;
this.board = owner.Board;
}
public PlayerPrepState(Unit Owner) : base(Owner)
{
this.abilityComponent = Owner.AbilityComponent;
indicatorList = new List <Tile> ();
}
//玩家通用组件
public void InitPlayerCommomAbility(BasicEntity entity)
{
AbilityComponent ability = entity.GetComponent <AbilityComponent> ();
}
