internal void OnTick(Entity entity, TickMessage tick)
{
// 로그아웃 한 상태에서 Tickable이 남아있는 유저는 Tick을 수행하지 않도록 한다.
if (entity.Has<Player>() && !entity.Get<Player>().Logged)
{
entity.Detach<Tickable>();
return;
}
if (entity.Has<Fightable>())
{
var fightable = entity.Get<Fightable>();
if (fightable.IsAlive)
{
if (++fightable.RecoveryCurrentTick >= fightable.RecoveryTickCount)
{
var recovery = DataCenter.Instance.GetDatum<InteractTemplate>((int)InteractTemplate.Ids.Recovery);
EffectSystem.Affect(entity, recovery);
fightable.RecoveryCurrentTick = 0;
}
}
}
if (entity.Has<Eatable>())
{
}
if (entity.Has<EntityGenerate>())
{
var entityGenerate = entity.Get<EntityGenerate>();
if (entityGenerate.IsGeneratable)
{
if (entityGenerate.Resource >= entityGenerate.NeededResourceToGen)
{
// generate!
entityGenerate.Resource -= entityGenerate.NeededResourceToGen;
}
entityGenerate.Resource += entityGenerate.IncResource;
}
}
// 다음 Tick을 요청한다.
if (entity.Has<Tickable>())
{
var nextMsg = new TickMessage {Id = entity.Id};
nextMsg.ExecuteDelayed(entity, entity.Get<Tickable>().Interval);
}
}
private void AddIfMatch(Entity entity)
{
if (!_entities.ContainsKey(entity))
{
if (_components.Keys.Any(componentClass => !entity.Has(componentClass)))
{
return;
}
var node = _nodePool.Get();
node.Entity = entity;
foreach (var componentClass in _components.Keys)
{
node.SetProperty(_components[componentClass], entity.Get(componentClass));
}
_entities.Add(entity, node);
_nodes.Add(node);
}
}
private void BulletCollision(Entity bullet, Entity other)
{
if (other.IsDestroyed)
{
return;
}
if (!other.Has <Enemy>())
{
return;
}
_world.Destroy(other);
if (bullet.Get <Bullet>().BulletType != BulletType.Laser)
{
_world.Destroy(bullet);
}
var asteroid = other.TryGet <Asteroid>();
if (asteroid == null) // ufo
{
_world
.Get <GameManagementSystem>()
.Score += 150;
}
else
{
SpawnAsteroidParts(other, asteroid);
_world
.Get <GameManagementSystem>()
.Score += 10 * asteroid.Size;
}
_world.Send(new Explosion
{
Position = bullet.Get <Transform>().Position,
Size = asteroid?.Size ?? 4
});
}
public void InitializeEffects(Entity entity)
{
if (entity != null)
{
this.effects.CreateEffect(entity);
}
else
{
NodeList <ShieldGeneratorNode> shieldGeneratorNodeList = Service.BuildingLookupController.ShieldGeneratorNodeList;
for (ShieldGeneratorNode shieldGeneratorNode = shieldGeneratorNodeList.Head; shieldGeneratorNode != null; shieldGeneratorNode = shieldGeneratorNode.Next)
{
this.effects.CreateEffect(shieldGeneratorNode.Entity);
}
}
Entity selectedBuilding = Service.BuildingController.SelectedBuilding;
if (selectedBuilding != null && selectedBuilding.Has <ShieldGeneratorComponent>())
{
this.effects.PlayAllEffects(true);
}
}
internal bool SpawnEntity(Entity admin,
[CommandArgument("생성할 Entity의 TemplateId")] int templateId)
{
var entityTemplate = DataCenter.Instance.GetEntityTemplate(templateId);
if (entityTemplate == null)
{
return(false);
}
var entity = EntityManager.Instance.Create(DataCenter.Instance.GetCreateInfo(entityTemplate));
if (entity.Has <Pos>() && admin.Has <Pos>())
{
entity.Get <Pos>().Assign(admin.Get <Pos>());
PositionSystem.Global.Appear(entity);
}
EntityBinder.Instance.Add(entity);
return(true);
}
public void Broadcast(Entity sender, IMessage message, int exceptEntityId = Entity.InvalidEntityId)
{
if (!sender.Has <Pos>())
{
return;
}
Post(() =>
{
if (!_viewMap.ContainsKey(sender))
{
return;
}
var receiverIds = _viewMap[sender].Select(e => e.Id).Concat(new[] { sender.Id }).Where(e => e != exceptEntityId);
foreach (var peerSession in MessageSessionManager.Instance[receiverIds].Where(e => e != null))
{
peerSession.Send(message);
}
});
}
private void TrySetup(Entity <IUIPool> entity)
{
if (!entity.Has <ViewLink>())
{
Debug.LogError("Unknown issue");
return;
}
var link = entity.Get <ViewLink>();
var view = ViewPool.GetByIdentity(link.Id);
if (!view.InScene())
{
_awaiting.Add(entity);
}
else
{
SetupAttribute(entity, view);//, view.GetObject());
_awaiting.Remove(entity);
}
}
public void LinkTo(Entity?possibleEntity)
{
if (possibleEntity == null)
{
Debug.LogWarning("Not linked!");
return;
}
Entity entity = (Entity)possibleEntity;
ViewComponent view = entity.Has <ViewComponent>()
? entity.Get <ViewComponent>()
: new ViewComponent {
Value = new HashSet <IRenderable>()
};
foreach (IRenderable renderable in gameObject.GetComponentsInChildren <IRenderable>())
{
view.Value.Add(renderable);
}
entity.Set(view);
}
public bool IsBuildingStashed(Entity buildingEntity)
{
GameObjectViewComponent gameObjectViewComponent = buildingEntity.Get <GameObjectViewComponent>();
if (gameObjectViewComponent != null && gameObjectViewComponent.MainTransform.position.y < 0f)
{
return(true);
}
if (this.stashedBuildingMap != null)
{
if (!buildingEntity.Has <BuildingComponent>())
{
return(false);
}
string uid = buildingEntity.Get <BuildingComponent>().BuildingType.Uid;
if (this.stashedBuildingMap.ContainsKey(uid) && this.stashedBuildingMap[uid].Contains(buildingEntity))
{
return(true);
}
}
return(false);
}
public RandomMovement()
{
var world = GameContext.World;
var mapContext = GameContext.Map;
_tree = new BehaviourTreeBuilder()
.Sequence("start")
.Do("check activity", t =>
{
if (entity.Has <BaseAction>())
{
return(BehaviourTreeStatus.Running);
}
return(BehaviourTreeStatus.Success);
})
.Sequence("createPath")
.Do("await", t =>
{
if (_time <= 1)
{
_time += 0.007f;
return(BehaviourTreeStatus.Running);
}
_time = 0;
return(BehaviourTreeStatus.Success);
})
.Do("create", t =>
{
if (!TryGetPoint(out var point, mapContext))
{
return(BehaviourTreeStatus.Success);
}
if (mapContext.PathFinder.TryGetPath(_objectToMove, point, out var first, out var last, 1f))
{
entity.Set <BaseAction>(first);
}
return(BehaviourTreeStatus.Success);
})
internal bool SpawnNpc(Entity admin,
[CommandArgument("Npc의 이름")] string npcName,
[CommandArgument("Npc의 X 위치", 0)] double newX,
[CommandArgument("Npc의 Y 위치", 0)] double newY)
{
if (!admin.Has <Pos>())
{
return(false);
}
var npc = EntityManager.Instance.Create(EntityTemplate.Ids.Npc);
npc.Get <Motion>().Dir = admin.Get <Motion>().Dir;
npc.Get <Nameplate>().Name = npcName;
npc.Get <Pos>().Assign(new Pos {
X = newX, Y = newY
});
PositionSystem.Global.Appear(npc);
EntityBinder.Instance.Add(npc);
return(true);
}
public JumpOverAction(Entity entity, Direction direction)
: base(entity)
{
Contract.Requires <ArgumentException>(entity.Has <Creature>());
// Contract.Requires<ArgumentException>(feature.Get<GameObject>().DistanceTo(entity.Get<GameObject>()) <= 1.5f);
_landedLocation = Entity.Get <GameObject>().Location + direction + direction;
var features = World.CurrentLevel.GetEntitiesAt <Scenery>(entity.Get <GameObject>().Location + direction).OrderByDescending(e => e.Get <Scenery>().JumpHeight);
if (features.IsEmpty())
{
_feature = null;
Logger.InfoFormat("{0} is jumping over nothing.", EntityName);
_apCost = (int)Math.Round(World.OneSecondInAP * direction.Offset.Length);
}
else
{
_feature = features.First();
_apCost = (int)Math.Round(World.OneSecondInAP * direction.Offset.Length * Math.Max(_feature.Get <Scenery>().JumpHeight + 3, 1.0));
}
}
protected override void SetupFor(Entity <IUIPool> entity, XmlElement xml)
{
var isRoot = entity.Has <ScopeType>();
Vector4 result = entity.Get <Anchor>().Value;
AnchorType type;
if (xml.HasEnum("Anchor", out type))
{
result = AnchorTypeVectro4Converter.Convert(type);
}
else
{
LookAtAnchor(xml, ref result);
LookAtStretching(xml, ref result);
LookAtAxis(xml, ref result);
}
var anchor = entity.Need <Anchor>();
anchor.Value = result;
entity.ReplaceInstance(anchor);
}
private static bool InteractRangeSelector(Entity entity, Pos entityPos, Entity peer, Pos peerPos)
{
if (!entity.Has <Motion>())
{
return(false);
}
const int defaultRange = 50;
const int defaultDegree = 30;
var dir = entity.Get <Motion>().Dir;
var ax = Math.Cos(dir);
var ay = Math.Sin(dir);
var sizeOfA = Math.Sqrt(ax * ax + ay * ay);
const double deltaRadian = defaultDegree * Math.PI / 180.0;
const double epsilon = 1.0;
var dx = peerPos.X - entityPos.X;
var dy = peerPos.Y - entityPos.Y;
var sizeOfD = Math.Sqrt(dx * dx + dy * dy);
if (Math.Abs(sizeOfD - 0) < epsilon)
{
return(true);
}
var cross = ax * dx + ay * dy;
var thetaRadian = Math.Acos(cross / (sizeOfA * sizeOfD));
if (!(-deltaRadian <= thetaRadian && thetaRadian <= deltaRadian))
{
return(false);
}
var oppositeDistance = Pos.Distance(entityPos.X, entityPos.Y, peerPos.X, peerPos.Y);
return(!(oppositeDistance > defaultRange));
}
public override void EntityDidHit(Entity entity)
{
if (entity.Has <ProjectileBase>())
{
var projectile = entity.Get <ProjectileBase>();
if (projectile.ShipGuid == ShipGuid)
{
return;
}
var damage = (int)projectile.GetDamage(Entity, this);
this.Update(() =>
{
Health -= damage;
if (Health < 0)
{
base.EntityDidHit(entity);
}
});
return;
}
base.EntityDidHit(entity);
}
public override int FindNeighbors(Entity <Game> entity, Callback callback)
{
if (!entity.Has <Collisions>())
{
return(0);
}
var position = entity.Get <Position>().Value;
var collisions = entity.Get <Collisions>().List;
foreach (var collision in collisions)
{
var other = collision.Other;
var diff = position - entity.Get <Position>().Value;
var dist2 = diff.MagnitudeSqr;
if (MaxDistance <= 0 || dist2 <= MaxDistance * MaxDistance)
{
callback(other, dist2);
}
}
return(collisions.Count);
}
public EatResponse OnEvent(EventId id, object cookie)
{
IState currentState = Service.GameStateMachine.CurrentState;
switch (id)
{
case EventId.BuildingSelected:
{
Entity entity = cookie as Entity;
if (entity.Has <ShieldGeneratorComponent>() && !GameUtils.IsVisitingBase())
{
this.effects.PlayAllEffects(true);
Service.AudioManager.PlayAudio("sfx_shields_power_up");
}
return(EatResponse.NotEaten);
}
case EventId.BuildingSelectedSound:
IL_20:
if (id != EventId.BuildingViewReady)
{
if (id == EventId.EntityHit)
{
Bullet bullet = cookie as Bullet;
ShieldBorderComponent shieldBorderComp = bullet.Target.ShieldBorderComp;
if (shieldBorderComp != null)
{
this.OnDamageShieldBorder(shieldBorderComp.ShieldGeneratorEntity, bullet);
}
return(EatResponse.NotEaten);
}
if (id == EventId.BuildingReplaced)
{
SmartEntity smartEntity = cookie as SmartEntity;
if (smartEntity.ShieldGeneratorComp != null)
{
this.replacedEntities.Add(cookie as Entity);
}
return(EatResponse.NotEaten);
}
if (id == EventId.WorldLoadComplete)
{
this.effects.Cleanup();
this.replacedEntities.Clear();
if (GameUtils.IsVisitingBase())
{
this.effects.PlayAllEffects(true);
}
return(EatResponse.NotEaten);
}
if (id != EventId.ShieldBorderDestroyed)
{
return(EatResponse.NotEaten);
}
ShieldBorderComponent sbc = cookie as ShieldBorderComponent;
this.OnDestroyShieldBorder(sbc);
return(EatResponse.NotEaten);
}
else
{
if (!(currentState is HomeState) && !(currentState is EditBaseState))
{
return(EatResponse.NotEaten);
}
EntityViewParams entityViewParams = cookie as EntityViewParams;
if (this.replacedEntities.Contains(entityViewParams.Entity))
{
this.InitializeEffects(entityViewParams.Entity);
this.replacedEntities.Remove(entityViewParams.Entity);
}
return(EatResponse.NotEaten);
}
break;
case EventId.BuildingDeselected:
{
Entity entity2 = cookie as Entity;
if (entity2.Has <ShieldGeneratorComponent>() && !GameUtils.IsVisitingBase())
{
this.StopAllEffects();
}
return(EatResponse.NotEaten);
}
}
goto IL_20;
}
private void RebuildViewOfEntity(Entity entity)
{
var currentPos = GetCurrentPos(entity);
var viewRange = entity.Has <Player>()
? Math.Max(entity.Get <Player>().ViewRange, DefaultViewRange)
: 0;
if (!_viewMap.ContainsKey(entity))
{
_viewMap.Add(entity, new HashSet <Entity>());
}
var observers = _viewMap[entity];
foreach (var peer in _viewMap.Keys.Where(e => e.Has <Player>()))
{
if (peer == entity)
{
continue;
}
var peerViewRange = Math.Max(peer.Get <Player>().ViewRange, DefaultViewRange);
var peerPos = GetCurrentPos(peer);
var distance = Pos.Distance(currentPos, peerPos);
Logger.Write("{0} <-> {1} : {2}", currentPos, peerPos, distance);
if (distance <= peerViewRange)
{
if (!observers.Contains(peer))
{
observers.Add(peer);
SendSpawnMessage(peer, entity);
}
}
else
{
if (observers.Contains(peer))
{
observers.Remove(peer);
SendDespawnMessage(peer, entity);
}
}
var peerObservers = _viewMap[peer];
if (distance < viewRange)
{
if (!peerObservers.Contains(entity))
{
peerObservers.Add(entity);
SendSpawnMessage(entity, peer);
}
}
else
{
if (peerObservers.Contains(entity))
{
peerObservers.Remove(entity);
SendDespawnMessage(entity, peer);
}
}
}
}
public bool CheckConstraints(Entity entity)
{
return(entity.Has <SkeletonSquadComponent>() &&
entity.Get <SkeletonSquadComponent>().Value.Count < GameConfig.Instance.MaxSkeletonsCount);
}
public void UnstashBuildingByUID(string buildingUID, bool returnToOriginalPosition, bool stampable, bool panToBuilding, bool playLoweredSound)
{
if (this.stashedBuildingMap == null)
{
return;
}
if (!this.stashedBuildingMap.ContainsKey(buildingUID) || this.stashedBuildingMap[buildingUID].Count < 1)
{
Service.Get <StaRTSLogger>().Error("Can't unstash! No buildings of : " + buildingUID + " currently stashed");
return;
}
List <Entity> list = this.stashedBuildingMap[buildingUID];
Entity entity = list[0];
BuildingComponent buildingComponent = entity.Get <BuildingComponent>();
bool flag = false;
if (stampable && this.IsBuildingStampable(entity))
{
flag = true;
}
Position pos = null;
if (returnToOriginalPosition)
{
pos = this.lastSavedMap.GetPosition(buildingComponent.BuildingTO.Key);
if (flag)
{
flag = false;
Service.Get <StaRTSLogger>().Warn("No stamping while reverting!!");
}
}
BuildingController buildingController = Service.Get <BuildingController>();
GameObjectViewComponent gameObjectViewComponent = entity.Get <GameObjectViewComponent>();
TransformComponent transformComponent = entity.Get <TransformComponent>();
if (gameObjectViewComponent != null)
{
gameObjectViewComponent.SetXYZ(Units.BoardToWorldX(transformComponent.CenterX()), 0f, Units.BoardToWorldZ(transformComponent.CenterZ()));
}
if (entity.Has <HealthViewComponent>())
{
HealthViewComponent healthViewComponent = entity.Get <HealthViewComponent>();
healthViewComponent.SetupElements();
}
List <Entity> list2 = this.stashedBuildingMap[buildingUID];
if (list2.Contains(entity))
{
list2.Remove(entity);
if (!buildingController.PositionUnstashedBuilding(entity, pos, flag, panToBuilding, playLoweredSound))
{
Service.Get <StaRTSLogger>().ErrorFormat("Unable to place building from stash. Building {0} {1}", new object[]
{
entity.Get <BuildingComponent>().BuildingTO.Key,
entity.Get <BuildingComponent>().BuildingType.Uid
});
Service.Get <UXController>().MiscElementsManager.ShowPlayerInstructionsError(Service.Get <Lang>().Get("NO_VALID_POSITION_FOR_UNSTASH", new object[0]));
this.StashBuilding(entity);
}
}
}
public bool CheckConstraints(Entity entity)
{
return(entity.Has <SkeletonSquadComponent>());
}
public override ActionResult OnProcess()
{
var rangeWeapon = weapon.Get <RangeComponent>();
var ammunition = ammo.Get <Item>();
// first we unload all ammos currently in the gun to the group, semi-simulating dropping the magazine
if (rangeWeapon.SwapClips && rangeWeapon.ShotsRemaining > (rangeWeapon.OneInTheChamber ? 1 : 0))
{
var droppedAmmo = ammo.Copy();
// todo cocking the gun takes more AP
if (rangeWeapon.OneInTheChamber)
{
droppedAmmo.Get <Item>().Amount = rangeWeapon.ShotsRemaining - 1;
rangeWeapon.ShotsRemaining = 1;
}
else
{
// probably will never be used except for bugs, what weapon do we swap clips and not have a closed-chamber?
droppedAmmo.Get <Item>().Amount = rangeWeapon.ShotsRemaining;
rangeWeapon.ShotsRemaining = 0;
}
if (droppedAmmo.Has <VisibleComponent>())
{
droppedAmmo.Get <VisibleComponent>().Reset();
}
Log.NormalFormat("{0} removes the magazine, dropping all excess ammo.", EntityName);
}
// inserting ammo
if (rangeWeapon.SwapClips)
{
if (ammunition.StackType == StackType.Hard)
{
if (ammunition.Amount >= rangeWeapon.Shots)
{
ammunition.Amount -= rangeWeapon.Shots;
rangeWeapon.ShotsRemaining += rangeWeapon.Shots;
}
else
{
rangeWeapon.ShotsRemaining += ammunition.Amount;
ammunition.Amount -= weapon.Get <Item>().Amount;
if (Entity.Has <ItemContainerComponent>())
{
Entity.Get <ItemContainerComponent>().Remove(ammo);
}
World.EntityManager.Remove(ammo);
}
Log.NormalFormat("{0} reloads {1} with {2}.", EntityName, Identifier.GetNameOrId(weapon), Identifier.GetNameOrId(ammo));
}
else
{
rangeWeapon.ShotsRemaining++;
if (Entity.Has <ItemContainerComponent>())
{
Entity.Get <ItemContainerComponent>().Remove(ammo);
}
World.EntityManager.Remove(ammo);
}
}
else
{
if (rangeWeapon.ShotsRemaining == (rangeWeapon.Shots + (rangeWeapon.OneInTheChamber ? 1 : 0)))
{
return(ActionResult.Aborted);
}
// we are inserting individual bullets
rangeWeapon.ShotsRemaining++;
if (ammunition.StackType == StackType.Hard)
{
if (ammunition.Amount > 1)
{
ammunition.Amount--;
}
else
{
if (Entity.Has <ItemContainerComponent>())
{
Entity.Get <ItemContainerComponent>().Remove(ammo);
}
World.EntityManager.Remove(ammo);
}
}
else
{
if (Entity.Has <ItemContainerComponent>())
{
Entity.Get <ItemContainerComponent>().Remove(ammo);
}
World.EntityManager.Remove(ammo);
}
if (rangeWeapon.ShotsRemaining < rangeWeapon.Shots + (rangeWeapon.OneInTheChamber ? 1 : 0))
{
var ammos = Entity.Get <ItemContainerComponent>().Items.FilteredBy <Item, AmmoComponent>().Where(e => e.Get <AmmoComponent>().Caliber == rangeWeapon.AmmoCaliber);
var enumerator = ammos.GetEnumerator();
while (enumerator.MoveNext())
{
Entity.Get <ControllerComponent>().Enqueue(new ReloadAction(Entity, weapon, enumerator.Current));
}
}
}
return(ActionResult.Success);
}
public EatResponse OnEvent(EventId id, object cookie)
{
if (id <= EventId.BuildingReplaced)
{
if (id <= EventId.BuildingCancelled)
{
if (id != EventId.BuildingViewReady)
{
if (id != EventId.BuildingCancelled)
{
return(EatResponse.NotEaten);
}
}
else
{
EntityViewParams entityViewParams = (EntityViewParams)cookie;
if (entityViewParams.Entity.Has <ScoutTowerComponent>())
{
this.CreateScoutHolo();
return(EatResponse.NotEaten);
}
return(EatResponse.NotEaten);
}
}
else if (id != EventId.EntityKilled)
{
if (id != EventId.BuildingConstructed)
{
if (id != EventId.BuildingReplaced)
{
return(EatResponse.NotEaten);
}
Entity entity = cookie as Entity;
if (entity.Has <ScoutTowerComponent>())
{
this.CreateScoutHolo();
return(EatResponse.NotEaten);
}
return(EatResponse.NotEaten);
}
}
else
{
SmartEntity smartEntity = (SmartEntity)cookie;
if (smartEntity.BuildingComp == null)
{
return(EatResponse.NotEaten);
}
BuildingType type = smartEntity.BuildingComp.BuildingType.Type;
if (!this.raidDefenseTrainerBindings.Contains(type))
{
return(EatResponse.NotEaten);
}
UXController uXController = Service.Get <UXController>();
Lang lang = Service.Get <Lang>();
switch (type)
{
case BuildingType.FleetCommand:
Service.Get <DeployerController>().SpecialAttackDeployer.ExitMode();
uXController.HUD.DisableSpecialAttacks();
uXController.MiscElementsManager.ShowPlayerInstructions(lang.Get("STARSHIP_TRAINER_DESTROYED", new object[0]));
return(EatResponse.NotEaten);
case BuildingType.HeroMobilizer:
Service.Get <DeployerController>().HeroDeployer.ExitMode();
uXController.HUD.DisableHeroDeploys();
uXController.MiscElementsManager.ShowPlayerInstructions(lang.Get("HERO_TRAINER_DESTROYED", new object[0]));
return(EatResponse.NotEaten);
case BuildingType.ChampionPlatform:
case BuildingType.Housing:
return(EatResponse.NotEaten);
case BuildingType.Squad:
Service.Get <DeployerController>().SquadTroopDeployer.ExitMode();
uXController.HUD.DisableSquadDeploy();
uXController.MiscElementsManager.ShowPlayerInstructions(lang.Get("SQUAD_CENTER_DESTROYED", new object[0]));
return(EatResponse.NotEaten);
default:
return(EatResponse.NotEaten);
}
}
ContractEventData contractEventData = (ContractEventData)cookie;
if (contractEventData.BuildingVO.Type == BuildingType.ScoutTower)
{
this.SendRaidDefenseUpdate();
}
}
else
{
if (id <= EventId.ContractStarted)
{
if (id != EventId.WorldLoadComplete)
{
if (id == EventId.WorldReset)
{
this.DestroyScoutHolo();
return(EatResponse.NotEaten);
}
if (id != EventId.ContractStarted)
{
return(EatResponse.NotEaten);
}
}
else
{
IState currentState = Service.Get <GameStateMachine>().CurrentState;
if (currentState is HomeState && this.RaidCompleteDidAwardCrate())
{
GameUtils.ShowCrateAwardModal(this.lastAwardedCrateUid);
this.lastAwardedCrateUid = null;
Service.Get <EventManager>().UnregisterObserver(this, EventId.WorldLoadComplete);
return(EatResponse.NotEaten);
}
return(EatResponse.NotEaten);
}
}
else if (id != EventId.ContractContinued)
{
if (id == EventId.HeroDeployed)
{
EntityController entityController = Service.Get <EntityController>();
NodeList <OffensiveTroopNode> nodeList = entityController.GetNodeList <OffensiveTroopNode>();
TroopAttackController troopAttackController = Service.Get <TroopAttackController>();
for (OffensiveTroopNode offensiveTroopNode = nodeList.Head; offensiveTroopNode != null; offensiveTroopNode = offensiveTroopNode.Next)
{
troopAttackController.RefreshTarget((SmartEntity)offensiveTroopNode.Entity);
}
return(EatResponse.NotEaten);
}
if (id != EventId.PlanetRelocateStarted)
{
return(EatResponse.NotEaten);
}
if (this.AreRaidsAccessible())
{
this.SendRaidDefenseUpdate();
return(EatResponse.NotEaten);
}
return(EatResponse.NotEaten);
}
ContractEventData contractEventData2 = (ContractEventData)cookie;
if (contractEventData2.BuildingVO.Type == BuildingType.ScoutTower)
{
this.DestroyScoutHolo();
}
}
return(EatResponse.NotEaten);
}
public CloseDoorAction(Entity entity, Entity feature) : base(entity, feature)
{
Contract.Requires <ArgumentException>(feature.Has <Opening>());
}
public void Update()
{
var playerActor = _player.Get <ControllerComponent>();
while (playerActor.AP.Updateable && playerActor.Controller.HasActionsQueued)
{
var action = _player.Get <ControllerComponent>().NextAction();
var result = action.OnProcess();
if (result == ActionResult.Failed || result == ActionResult.Success)
{
playerActor.AP.ActionPoints -= action.APCost;
if (_player.Has <ConditionHolder>())
{
foreach (var c in _player.Get <ConditionHolder>().Effects)
{
c.Update(action.APCost);
}
}
_world.OnActionProcessed();
}
}
if (!playerActor.AP.Updateable)
{
playerActor.AP.Gain();
foreach (var entity in _entities)
{
if (entity == _player)
{
continue;
}
var entityActor = entity.Get <ControllerComponent>();
entityActor.AP.Gain();
while (entityActor.AP.Updateable)
{
var action = entity.Get <ControllerComponent>().NextAction();
var result = action.OnProcess();
if (result == ActionResult.Failed || result == ActionResult.Success)
{
entityActor.AP.ActionPoints -= action.APCost;
if (entity.Has <ConditionHolder>())
{
foreach (var c in entity.Get <ConditionHolder>().Effects)
{
c.Update(action.APCost);
}
}
_world.OnActionProcessed();
}
}
}
}
}
public static bool Match(Entity entity) => entity.Has <T>();
public bool CheckConstraints(Entity entity)
{
return(entity.Has <SkeletonComponent>() && entity.Has <PositionComponent>());
}
public static string GetNameOrId(Entity e)
{
Contract.Requires <ArgumentNullException>(e != null, "e");
return(e.Has <Identifier>() ? e.Get <Identifier>().Name : e.Id.ToString());
}
protected LoggedAction(Entity entity) : base(entity)
{
Contract.Requires <ArgumentException>(entity.Has <GameObject>());
}
public void HasComponentIsFalseIfComponentTypeNotPresent()
{
_entity.Add(new MockComponent2());
Assert.IsFalse(_entity.Has(typeof(MockComponent)));
}
public RangeAttackAction(Entity attacker, Entity defender, Entity weapon, DefendComponent.AttackablePart bodyPartTargetted, bool targettingPenalty = false)
: base(attacker, defender, weapon, bodyPartTargetted, targettingPenalty)
{
Contract.Requires <ArgumentException>(weapon.Has <RangeComponent>(), "weapon cannot range attack");
}
public EatResponse OnEvent(EventId id, object cookie)
{
if (id <= EventId.BuildingReplaced)
{
if (id <= EventId.BuildingCancelled)
{
if (id != EventId.BuildingViewReady)
{
if (id != EventId.BuildingCancelled)
{
return(EatResponse.NotEaten);
}
}
else
{
EntityViewParams entityViewParams = (EntityViewParams)cookie;
if (this.effectsByEntityId != null && this.effectsByEntityId.ContainsKey(entityViewParams.Entity.ID))
{
BuildingHoloEffect buildingHoloEffect = this.effectsByEntityId[entityViewParams.Entity.ID];
if (buildingHoloEffect.WaitingForBuildingView)
{
buildingHoloEffect.UpdateEffect();
}
}
if (this.effectsByEntityId != null && entityViewParams.Entity.Has <NavigationCenterComponent>())
{
this.AddNavigationCenterHolo(entityViewParams.Entity);
return(EatResponse.NotEaten);
}
return(EatResponse.NotEaten);
}
}
else
{
switch (id)
{
case EventId.StarshipMobilized:
case EventId.HeroMobilized:
this.OnUnitMobilized((ContractEventData)cookie);
return(EatResponse.NotEaten);
case EventId.StarshipMobilizedFromPrize:
{
Entity entity = Service.Get <BuildingLookupController>().FleetCommandNodeList.Head.Entity;
this.CreateEffect(entity, (string)cookie, true, false);
return(EatResponse.NotEaten);
}
case EventId.HeroMobilizedFromPrize:
{
Entity entity2 = Service.Get <BuildingLookupController>().TacticalCommandNodeList.Head.Entity;
this.CreateEffect(entity2, (string)cookie, false, false);
return(EatResponse.NotEaten);
}
default:
if (id != EventId.BuildingConstructed)
{
if (id != EventId.BuildingReplaced)
{
return(EatResponse.NotEaten);
}
Entity entity3 = cookie as Entity;
if (entity3.Has <NavigationCenterComponent>())
{
this.AddNavigationCenterHolo(entity3);
return(EatResponse.NotEaten);
}
return(EatResponse.NotEaten);
}
break;
}
}
ContractEventData contractEventData = (ContractEventData)cookie;
if (contractEventData.BuildingVO.Type == BuildingType.NavigationCenter)
{
this.AddNavigationCenterHolo();
}
}
else if (id <= EventId.WorldReset)
{
if (id != EventId.WorldLoadComplete)
{
if (id == EventId.WorldReset)
{
this.RemoveAllEffects();
}
}
else
{
IState currentState = Service.Get <GameStateMachine>().CurrentState;
if (currentState is ApplicationLoadState || currentState is HomeState || currentState is WarBoardState)
{
this.AddAllEffects(false);
}
}
}
else if (id != EventId.ContractStarted && id != EventId.ContractContinued)
{
if (id == EventId.ContractCanceled)
{
this.OnContractCanceled((ContractEventData)cookie);
}
}
else
{
this.OnContractStarted((ContractEventData)cookie);
}
return(EatResponse.NotEaten);
}
