public EatResponse OnEvent(EventId id, object cookie)
 {
     if (id != EventId.EntityKilled)
     {
         if (id == EventId.BattleEndProcessing)
         {
             NodeList <TrapNode> nodeList = Service.Get <EntityController>().GetNodeList <TrapNode>();
             for (TrapNode trapNode = nodeList.Head; trapNode != null; trapNode = trapNode.Next)
             {
                 if (trapNode.TrapComp.CurrentState == TrapState.Active && trapNode.TrapComp.Type.EventType == TrapEventType.Turret)
                 {
                     this.SwapTurretToTrap((SmartEntity)trapNode.Entity);
                 }
             }
         }
     }
     else
     {
         SmartEntity smartEntity = cookie as SmartEntity;
         if (smartEntity.TrapComp != null)
         {
             TrapTypeVO type = smartEntity.TrapComp.Type;
             this.SetTrapState(smartEntity.TrapComp, TrapState.Spent);
             TrapEventType eventType = type.EventType;
             if (eventType == TrapEventType.Turret)
             {
                 this.SwapTurretToTrap(smartEntity);
             }
         }
     }
     return(EatResponse.NotEaten);
 }
 public bool PlaceTrap(TrapNode temp)
 {
     if (Traps[selected] != null)
     {
         //temp.Slot = Traps[selected];
         return(true);
     }
     return(false);
 }
        public void RegisterTraps(CurrentBattle currentBattle)
        {
            NodeList <TrapNode> nodeList = Service.Get <EntityController>().GetNodeList <TrapNode>();

            for (TrapNode trapNode = nodeList.Head; trapNode != null; trapNode = trapNode.Next)
            {
                if (currentBattle.DisabledBuildings == null || !currentBattle.DisabledBuildings.Contains(trapNode.BuildingComp.BuildingTO.Key))
                {
                    TrapCombatTrigger combatTrigger = new TrapCombatTrigger(trapNode);
                    this.ctm.RegisterTrigger(combatTrigger);
                }
            }
        }
Beispiel #4
0
        public static List <Entity> GetRearmableTraps()
        {
            List <Entity>       list         = new List <Entity>();
            NodeList <TrapNode> trapNodeList = Service.Get <BuildingLookupController>().TrapNodeList;

            for (TrapNode trapNode = trapNodeList.Head; trapNode != null; trapNode = trapNode.Next)
            {
                if (trapNode.TrapComp.CurrentState == TrapState.Spent && !ContractUtils.IsBuildingUpgrading(trapNode.Entity))
                {
                    list.Add(trapNode.Entity);
                }
            }
            return(list);
        }
Beispiel #5
0
        public void StartDefenseMission(CampaignMissionVO mission)
        {
            if (this.activeDefenseBattle)
            {
                Service.Logger.WarnFormat("Mission {0} is already in progress.  Cannot start Mission {1}.", new object[]
                {
                    this.currentMission.Uid,
                    mission.Uid
                });
                return;
            }
            this.troopController     = Service.TroopController;
            this.eventManager        = Service.EventManager;
            this.activeDefenseBattle = true;
            this.autoMoveCamera      = false;
            this.currentMission      = mission;
            this.randomizeWaves      = !mission.FixedWaves;
            this.waves         = DefensiveBattleController.ParseWaves(this.currentMission.Waves);
            this.wavesDeployed = 0;
            this.waveCount     = this.waves.Count;
            this.AllWavesClear = false;
            if (mission.IsRaidDefense())
            {
                Service.RaidDefenseController.OnStartRaidDefenseMission();
            }
            this.eventManager.RegisterObserver(this, EventId.EntityKilled, EventPriority.BeforeDefault);
            this.eventManager.RegisterObserver(this, EventId.UserStartedCameraMove, EventPriority.Default);
            this.eventManager.RegisterObserver(this, EventId.CameraFinishedMoving, EventPriority.Default);
            this.eventManager.RegisterObserver(this, EventId.PreEntityKilled, EventPriority.Default);
            this.eventManager.RegisterObserver(this, EventId.EntityHit, EventPriority.Default);
            TrapViewController  trapViewController = Service.TrapViewController;
            NodeList <TrapNode> trapNodeList       = Service.BuildingLookupController.TrapNodeList;

            for (TrapNode trapNode = trapNodeList.Head; trapNode != null; trapNode = trapNode.Next)
            {
                trapViewController.UpdateTrapVisibility((SmartEntity)trapNode.Entity);
            }
            Vector3 zero = Vector3.zero;

            Service.WorldInitializer.View.ZoomTo(0.7f);
            Service.WorldInitializer.View.PanToLocation(zero);
            this.DeployNextWave(0u, null);
        }
Beispiel #6
0
        public void OnViewFrameTime(float dt)
        {
            bool flag = true;
            NodeList <TrapNode> trapNodeList = Service.BuildingLookupController.TrapNodeList;

            for (TrapNode trapNode = trapNodeList.Head; trapNode != null; trapNode = trapNode.Next)
            {
                if (trapNode.TrapViewComp.PendingStates.Count > 0)
                {
                    flag = false;
                    TrapState value = trapNode.TrapViewComp.PendingStates[0];
                    trapNode.TrapViewComp.PendingStates.RemoveAt(0);
                    trapNode.TrapViewComp.Anim.SetInteger("trapAnimState", (int)value);
                }
            }
            if (flag)
            {
                this.observing = false;
                Service.ViewTimeEngine.UnregisterFrameTimeObserver(this);
            }
        }
Beispiel #7
0
        public TrapCombatTrigger(TrapNode node)
        {
            this.controller        = Service.Get <TrapController>();
            this.comp              = node.TrapComp;
            this.transform         = node.TransformComp;
            this.health            = node.HealthComp;
            this.Owner             = node.Entity;
            this.Type              = CombatTriggerType.Area;
            this.AreaRadius        = 0u;
            this.triggerConditions = node.TrapComp.Type.ParsedTrapConditions;
            int i     = 0;
            int count = this.triggerConditions.Count;

            while (i < count)
            {
                if (this.triggerConditions[i] is RadiusTrapCondition)
                {
                    this.Type       = CombatTriggerType.Area;
                    this.AreaRadius = ((RadiusTrapCondition)this.triggerConditions[i]).Radius;
                }
                i++;
            }
        }
Beispiel #8
0
        public bool HasConstructedBuilding(BuildingTypeVO reqBuilding)
        {
            int lvl = reqBuilding.Lvl;

            switch (reqBuilding.Type)
            {
            case BuildingType.HQ:
                for (HQNode hQNode = this.HQNodeList.Head; hQNode != null; hQNode = hQNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)hQNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Barracks:
                for (BarracksNode barracksNode = this.BarracksNodeList.Head; barracksNode != null; barracksNode = barracksNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)barracksNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Factory:
                for (FactoryNode factoryNode = this.FactoryNodeList.Head; factoryNode != null; factoryNode = factoryNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)factoryNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.FleetCommand:
                for (FleetCommandNode fleetCommandNode = this.FleetCommandNodeList.Head; fleetCommandNode != null; fleetCommandNode = fleetCommandNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)fleetCommandNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.HeroMobilizer:
                for (TacticalCommandNode tacticalCommandNode = this.TacticalCommandNodeList.Head; tacticalCommandNode != null; tacticalCommandNode = tacticalCommandNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)tacticalCommandNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.ChampionPlatform:
                for (ChampionPlatformNode championPlatformNode = this.ChampionPlatformNodeList.Head; championPlatformNode != null; championPlatformNode = championPlatformNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)championPlatformNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Housing:
                for (HousingNode housingNode = this.HousingNodeList.Head; housingNode != null; housingNode = housingNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)housingNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Squad:
                for (SquadBuildingNode squadBuildingNode = this.SquadBuildingNodeList.Head; squadBuildingNode != null; squadBuildingNode = squadBuildingNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)squadBuildingNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Starport:
                for (StarportNode starportNode = this.StarportNodeList.Head; starportNode != null; starportNode = starportNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)starportNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.DroidHut:
                for (DroidHutNode droidHutNode = this.DroidHutNodeList.Head; droidHutNode != null; droidHutNode = droidHutNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)droidHutNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Wall:
                for (WallNode wallNode = this.WallNodeList.Head; wallNode != null; wallNode = wallNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)wallNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Turret:
                for (TurretBuildingNode turretBuildingNode = this.TurretBuildingNodeList.Head; turretBuildingNode != null; turretBuildingNode = turretBuildingNode.Next)
                {
                    if (turretBuildingNode.BuildingComp.BuildingType.UpgradeGroup == reqBuilding.UpgradeGroup && GameUtils.GetBuildingEffectiveLevel((SmartEntity)turretBuildingNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.TroopResearch:
                for (OffenseLabNode offenseLabNode = this.OffenseLabNodeList.Head; offenseLabNode != null; offenseLabNode = offenseLabNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)offenseLabNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.DefenseResearch:
                for (DefenseLabNode defenseLabNode = this.DefenseLabNodeList.Head; defenseLabNode != null; defenseLabNode = defenseLabNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)defenseLabNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Resource:
                for (GeneratorNode generatorNode = this.GeneratorNodeList.Head; generatorNode != null; generatorNode = generatorNode.Next)
                {
                    if (generatorNode.BuildingComp.BuildingType.Currency == reqBuilding.Currency && GameUtils.GetBuildingEffectiveLevel((SmartEntity)generatorNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Storage:
                for (StorageNode storageNode = this.StorageNodeList.Head; storageNode != null; storageNode = storageNode.Next)
                {
                    if (storageNode.BuildingComp.BuildingType.Currency == reqBuilding.Currency && GameUtils.GetBuildingEffectiveLevel((SmartEntity)storageNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Trap:
                for (TrapNode trapNode = this.TrapNodeList.Head; trapNode != null; trapNode = trapNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)trapNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Cantina:
                for (CantinaNode cantinaNode = this.CantinaNodeList.Head; cantinaNode != null; cantinaNode = cantinaNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)cantinaNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.NavigationCenter:
                for (NavigationCenterNode navigationCenterNode = this.NavigationCenterNodeList.Head; navigationCenterNode != null; navigationCenterNode = navigationCenterNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)navigationCenterNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.ScoutTower:
                for (ScoutTowerNode scoutTowerNode = this.ScoutTowerNodeList.Head; scoutTowerNode != null; scoutTowerNode = scoutTowerNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)scoutTowerNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);

            case BuildingType.Armory:
                for (ArmoryNode armoryNode = this.ArmoryNodeList.Head; armoryNode != null; armoryNode = armoryNode.Next)
                {
                    if (GameUtils.GetBuildingEffectiveLevel((SmartEntity)armoryNode.BuildingComp.Entity) >= lvl)
                    {
                        return(true);
                    }
                }
                return(false);
            }
            Service.Logger.Warn("Unknown reqBuilding type for level: " + reqBuilding.Uid);
            return(false);
        }
Beispiel #9
0
        private void FillBuildingListByType(List <SmartEntity> list, BuildingType type)
        {
            switch (type)
            {
            case BuildingType.Any:
            {
                NodeList <BuildingNode> nodeList = this.entityController.GetNodeList <BuildingNode>();
                for (BuildingNode buildingNode = nodeList.Head; buildingNode != null; buildingNode = buildingNode.Next)
                {
                    list.Add((SmartEntity)buildingNode.Entity);
                }
                return;
            }

            case BuildingType.HQ:
                for (HQNode hQNode = this.HQNodeList.Head; hQNode != null; hQNode = hQNode.Next)
                {
                    list.Add((SmartEntity)hQNode.Entity);
                }
                return;

            case BuildingType.Barracks:
                for (BarracksNode barracksNode = this.BarracksNodeList.Head; barracksNode != null; barracksNode = barracksNode.Next)
                {
                    list.Add((SmartEntity)barracksNode.Entity);
                }
                return;

            case BuildingType.Factory:
                for (FactoryNode factoryNode = this.FactoryNodeList.Head; factoryNode != null; factoryNode = factoryNode.Next)
                {
                    list.Add((SmartEntity)factoryNode.Entity);
                }
                return;

            case BuildingType.FleetCommand:
                for (FleetCommandNode fleetCommandNode = this.FleetCommandNodeList.Head; fleetCommandNode != null; fleetCommandNode = fleetCommandNode.Next)
                {
                    list.Add((SmartEntity)fleetCommandNode.Entity);
                }
                return;

            case BuildingType.HeroMobilizer:
                for (TacticalCommandNode tacticalCommandNode = this.TacticalCommandNodeList.Head; tacticalCommandNode != null; tacticalCommandNode = tacticalCommandNode.Next)
                {
                    list.Add((SmartEntity)tacticalCommandNode.Entity);
                }
                return;

            case BuildingType.ChampionPlatform:
                for (ChampionPlatformNode championPlatformNode = this.ChampionPlatformNodeList.Head; championPlatformNode != null; championPlatformNode = championPlatformNode.Next)
                {
                    list.Add((SmartEntity)championPlatformNode.Entity);
                }
                return;

            case BuildingType.Housing:
                for (HousingNode housingNode = this.HousingNodeList.Head; housingNode != null; housingNode = housingNode.Next)
                {
                    list.Add((SmartEntity)housingNode.Entity);
                }
                return;

            case BuildingType.Squad:
                for (SquadBuildingNode squadBuildingNode = this.SquadBuildingNodeList.Head; squadBuildingNode != null; squadBuildingNode = squadBuildingNode.Next)
                {
                    list.Add((SmartEntity)squadBuildingNode.Entity);
                }
                return;

            case BuildingType.Starport:
                for (StarportNode starportNode = this.StarportNodeList.Head; starportNode != null; starportNode = starportNode.Next)
                {
                    list.Add((SmartEntity)starportNode.Entity);
                }
                return;

            case BuildingType.DroidHut:
                for (DroidHutNode droidHutNode = this.DroidHutNodeList.Head; droidHutNode != null; droidHutNode = droidHutNode.Next)
                {
                    list.Add((SmartEntity)droidHutNode.Entity);
                }
                return;

            case BuildingType.Wall:
                for (WallNode wallNode = this.WallNodeList.Head; wallNode != null; wallNode = wallNode.Next)
                {
                    list.Add((SmartEntity)wallNode.Entity);
                }
                return;

            case BuildingType.Turret:
                for (TurretBuildingNode turretBuildingNode = this.TurretBuildingNodeList.Head; turretBuildingNode != null; turretBuildingNode = turretBuildingNode.Next)
                {
                    list.Add((SmartEntity)turretBuildingNode.Entity);
                }
                return;

            case BuildingType.TroopResearch:
                for (OffenseLabNode offenseLabNode = this.OffenseLabNodeList.Head; offenseLabNode != null; offenseLabNode = offenseLabNode.Next)
                {
                    list.Add((SmartEntity)offenseLabNode.Entity);
                }
                return;

            case BuildingType.DefenseResearch:
                for (DefenseLabNode defenseLabNode = this.DefenseLabNodeList.Head; defenseLabNode != null; defenseLabNode = defenseLabNode.Next)
                {
                    list.Add((SmartEntity)defenseLabNode.Entity);
                }
                return;

            case BuildingType.Resource:
                for (GeneratorNode generatorNode = this.GeneratorNodeList.Head; generatorNode != null; generatorNode = generatorNode.Next)
                {
                    list.Add((SmartEntity)generatorNode.Entity);
                }
                return;

            case BuildingType.Storage:
                for (StorageNode storageNode = this.StorageNodeList.Head; storageNode != null; storageNode = storageNode.Next)
                {
                    list.Add((SmartEntity)storageNode.Entity);
                }
                return;

            case BuildingType.ShieldGenerator:
                for (ShieldGeneratorNode shieldGeneratorNode = this.ShieldGeneratorNodeList.Head; shieldGeneratorNode != null; shieldGeneratorNode = shieldGeneratorNode.Next)
                {
                    list.Add((SmartEntity)shieldGeneratorNode.Entity);
                }
                return;

            case BuildingType.Clearable:
                for (ClearableNode clearableNode = this.ClearableNodeList.Head; clearableNode != null; clearableNode = clearableNode.Next)
                {
                    list.Add((SmartEntity)clearableNode.Entity);
                }
                return;

            case BuildingType.Trap:
                for (TrapNode trapNode = this.TrapNodeList.Head; trapNode != null; trapNode = trapNode.Next)
                {
                    list.Add((SmartEntity)trapNode.Entity);
                }
                return;

            case BuildingType.Cantina:
                for (CantinaNode cantinaNode = this.CantinaNodeList.Head; cantinaNode != null; cantinaNode = cantinaNode.Next)
                {
                    list.Add((SmartEntity)cantinaNode.Entity);
                }
                return;

            case BuildingType.NavigationCenter:
                for (NavigationCenterNode navigationCenterNode = this.NavigationCenterNodeList.Head; navigationCenterNode != null; navigationCenterNode = navigationCenterNode.Next)
                {
                    list.Add((SmartEntity)navigationCenterNode.Entity);
                }
                return;

            case BuildingType.ScoutTower:
                for (ScoutTowerNode scoutTowerNode = this.ScoutTowerNodeList.Head; scoutTowerNode != null; scoutTowerNode = scoutTowerNode.Next)
                {
                    list.Add((SmartEntity)scoutTowerNode.Entity);
                }
                return;

            case BuildingType.Armory:
                for (ArmoryNode armoryNode = this.ArmoryNodeList.Head; armoryNode != null; armoryNode = armoryNode.Next)
                {
                    list.Add((SmartEntity)armoryNode.Entity);
                }
                return;
            }
            Service.Logger.Warn("Unknown building type " + type);
        }