public DotState(Actor a, GpsASWatcher watcher, FrozenActorLayer frozenLayer)
 {
     Watcher = watcher;
     if (frozenLayer != null)
     {
         FrozenActor = frozenLayer.FromID(a.ActorID);
     }
 }
Example #2
0
 public AISupportPowerManager(HackyAI ai, Player p)
 {
     this.ai             = ai;
     world               = p.World;
     player              = p;
     frozenLayer         = p.PlayerActor.Trait <FrozenActorLayer>();
     supportPowerManager = p.PlayerActor.TraitOrDefault <SupportPowerManager>();
     foreach (var decision in ai.Info.SupportPowerDecisions)
     {
         powerDecisions.Add(decision.OrderName, decision);
     }
 }
Example #3
0
        public void Activate(Player p)
        {
            Player           = p;
            IsEnabled        = true;
            playerPower      = p.PlayerActor.Trait <PowerManager>();
            supportPowerMngr = p.PlayerActor.Trait <SupportPowerManager>();
            playerResource   = p.PlayerActor.Trait <PlayerResources>();
            froenLayer       = p.PlayerActor.Trait <FrozenActorLayer>();


            foreach (var building in Info.BuildingQueues)
            {
                builders.Add(new BaseBuilder(this, building, p, playerPower, playerResource));
            }

            foreach (var defense in Info.DefenseQueues)
            {
                builders.Add(new BaseBuilder(this, defense, p, playerPower, playerResource));
            }

            Random = new MersenneTwister(WarGame.CosmeticRandom.Next());

            //Avoid all AIs trying to rush in the same tick, randomize their initial rush a little.
            var smallFractionOfRushInterval = Info.RushInterval / 20;

            rushTicks = Random.Next(Info.RushInterval - smallFractionOfRushInterval, Info.RushInterval + smallFractionOfRushInterval);

            //Avoid all AIs reevaluating assignments on the same tick, randomize their initial evaluation delay.
            assignRolesTicks         = Random.Next(0, Info.AssignRolesInterval);
            attackForceTicks         = Random.Next(0, Info.AttackForceInterval);
            minAttackForceDelayTicks = Random.Next(0, Info.MinimumAttackForceDelay);
            minCaptureDelayTicks     = Random.Next(0, Info.MinimumCaptureDelay);

            var tileset = World.Map.Rules.TileSet;

            resourceTypeIndices = new BitArray(tileset.TerrainInfo.Length);//Big enough

            foreach (var t in Map.Rules.Actors["world"].TraitInfos <ResourceTypeInfo>())
            {
                resourceTypeIndices.Set(tileset.GetTerrainIndex(t.TerrainType), true);
            }
        }
Example #4
0
        /// <summary>Evaluates the attractiveness of a position according to all considerations</summary>
        public int GetAttractiveness(WPos pos, Player firedBy, FrozenActorLayer frozenLayer)
        {
            var answer     = 0;
            var world      = firedBy.World;
            var targetTile = world.Map.CellContaining(pos);

            if (!world.Map.Contains(targetTile))
            {
                return(0);
            }

            foreach (var consideration in Considerations)
            {
                var radiusToUse = new WDist(consideration.CheckRadius.Length);

                var checkActors = world.FindActorsInCircle(pos, radiusToUse);
                foreach (var scrutinized in checkActors)
                {
                    answer += consideration.GetAttractiveness(scrutinized, firedBy.Stances[scrutinized.Owner], firedBy);
                }

                var delta       = new WVec(radiusToUse, radiusToUse, WDist.Zero);
                var tl          = world.Map.CellContaining(pos - delta);
                var br          = world.Map.CellContaining(pos + delta);
                var checkFrozen = frozenLayer.FrozenActorsInRegion(new CellRegion(world.Map.Grid.Type, tl, br));

                // IsValid check filters out Frozen Actors that have not initizialized their Owner
                foreach (var scrutinized in checkFrozen)
                {
                    if (scrutinized.IsValid)
                    {
                        answer += consideration.GetAttractiveness(scrutinized, firedBy.Stances[scrutinized.Owner], firedBy);
                    }
                }
            }

            return(answer);
        }
Example #5
0
 public Traits(Player player, FrozenUnderFogUpdatedByGps frozenUnderFogUpdatedByGps)
 {
     FrozenActorLayer = player.PlayerActor.TraitOrDefault <FrozenActorLayer>();
     GpsWatcher       = player.PlayerActor.TraitOrDefault <GpsWatcher>();
     GpsWatcher.RegisterForOnGpsRefreshed(frozenUnderFogUpdatedByGps.self, frozenUnderFogUpdatedByGps);
 }
Example #6
0
        public Player(World world, Session.Client client, PlayerReference pr, MersenneTwister playerRandom)
        {
            World           = world;
            InternalName    = pr.Name;
            PlayerReference = pr;

            inMissionMap = world.Map.Visibility.HasFlag(MapVisibility.MissionSelector);

            // Real player or host-created bot
            if (client != null)
            {
                ClientIndex = client.Index;
                Color       = client.Color;
                PlayerName  = ResolvePlayerName(client, world.LobbyInfo.Clients, world.Map.Rules.Actors["player"].TraitInfos <IBotInfo>());

                BotType        = client.Bot;
                Faction        = ResolveFaction(world, client.Faction, playerRandom, !pr.LockFaction);
                DisplayFaction = ResolveDisplayFaction(world, client.Faction);

                var assignSpawnPoints = world.WorldActor.TraitOrDefault <IAssignSpawnPoints>();
                HomeLocation      = assignSpawnPoints?.AssignHomeLocation(world, client, playerRandom) ?? pr.HomeLocation;
                SpawnPoint        = assignSpawnPoints?.SpawnPointForPlayer(this) ?? client.SpawnPoint;
                DisplaySpawnPoint = client.SpawnPoint;

                Handicap = client.Handicap;
            }
            else
            {
                // Map player
                ClientIndex    = 0;              // Owned by the host (TODO: fix this)
                Color          = pr.Color;
                PlayerName     = pr.Name;
                NonCombatant   = pr.NonCombatant;
                Playable       = pr.Playable;
                spectating     = pr.Spectating;
                BotType        = pr.Bot;
                Faction        = ResolveFaction(world, pr.Faction, playerRandom, false);
                DisplayFaction = ResolveDisplayFaction(world, pr.Faction);
                HomeLocation   = pr.HomeLocation;
                SpawnPoint     = DisplaySpawnPoint = 0;
                Handicap       = pr.Handicap;
            }

            if (!spectating)
            {
                PlayerMask = new LongBitSet <PlayerBitMask>(InternalName);
            }

            // Set this property before running any Created callbacks on the player actor
            IsBot = BotType != null;

            // Special case handling is required for the Player actor:
            // Since Actor.Created would be called before PlayerActor is assigned here
            // querying player traits in INotifyCreated.Created would crash.
            // Therefore assign the uninitialized actor and run the Created callbacks
            // by calling Initialize ourselves.
            var playerActorType = world.Type == WorldType.Editor ? EditorPlayerActorType : PlayerActorType;

            PlayerActor = new Actor(world, playerActorType, new TypeDictionary {
                new OwnerInit(this)
            });
            PlayerActor.Initialize(true);

            Shroud           = PlayerActor.Trait <Shroud>();
            FrozenActorLayer = PlayerActor.TraitOrDefault <FrozenActorLayer>();

            // Enable the bot logic on the host
            if (IsBot && Game.IsHost)
            {
                var logic = PlayerActor.TraitsImplementing <IBot>().FirstOrDefault(b => b.Info.Type == BotType);
                if (logic == null)
                {
                    Log.Write("debug", "Invalid bot type: {0}", BotType);
                }
                else
                {
                    logic.Activate(this);
                }
            }

            stanceColors.Self     = ChromeMetrics.Get <Color>("PlayerStanceColorSelf");
            stanceColors.Allies   = ChromeMetrics.Get <Color>("PlayerStanceColorAllies");
            stanceColors.Enemies  = ChromeMetrics.Get <Color>("PlayerStanceColorEnemies");
            stanceColors.Neutrals = ChromeMetrics.Get <Color>("PlayerStanceColorNeutrals");

            unlockRenderPlayer = PlayerActor.TraitsImplementing <IUnlocksRenderPlayer>().ToArray();
        }
Example #7
0
        public Player(World world, Session.Client client, PlayerReference pr)
        {
            World           = world;
            InternalName    = pr.Name;
            PlayerReference = pr;

            inMissionMap = world.Map.Visibility.HasFlag(MapVisibility.MissionSelector);

            // Real player or host-created bot
            if (client != null)
            {
                ClientIndex = client.Index;
                Color       = client.Color;
                if (client.Bot != null)
                {
                    var botInfo        = world.Map.Rules.Actors["player"].TraitInfos <IBotInfo>().First(b => b.Type == client.Bot);
                    var botsOfSameType = world.LobbyInfo.Clients.Where(c => c.Bot == client.Bot).ToArray();
                    PlayerName = botsOfSameType.Length == 1 ? botInfo.Name : "{0} {1}".F(botInfo.Name, botsOfSameType.IndexOf(client) + 1);
                }
                else
                {
                    PlayerName = client.Name;
                }

                BotType        = client.Bot;
                Faction        = ChooseFaction(world, client.Faction, !pr.LockFaction);
                DisplayFaction = ChooseDisplayFaction(world, client.Faction);
            }
            else
            {
                // Map player
                ClientIndex    = 0;              // Owned by the host (TODO: fix this)
                Color          = pr.Color;
                PlayerName     = pr.Name;
                NonCombatant   = pr.NonCombatant;
                Playable       = pr.Playable;
                Spectating     = pr.Spectating;
                BotType        = pr.Bot;
                Faction        = ChooseFaction(world, pr.Faction, false);
                DisplayFaction = ChooseDisplayFaction(world, pr.Faction);
            }

            var playerActorType = world.Type == WorldType.Editor ? "EditorPlayer" : "Player";

            PlayerActor = world.CreateActor(playerActorType, new TypeDictionary {
                new OwnerInit(this)
            });
            Shroud           = PlayerActor.Trait <Shroud>();
            FrozenActorLayer = PlayerActor.TraitOrDefault <FrozenActorLayer>();

            // Enable the bot logic on the host
            IsBot = BotType != null;
            if (IsBot && Game.IsHost)
            {
                var logic = PlayerActor.TraitsImplementing <IBot>().FirstOrDefault(b => b.Info.Type == BotType);
                if (logic == null)
                {
                    Log.Write("debug", "Invalid bot type: {0}", BotType);
                }
                else
                {
                    logic.Activate(this);
                }
            }

            stanceColors.Self     = ChromeMetrics.Get <Color>("PlayerStanceColorSelf");
            stanceColors.Allies   = ChromeMetrics.Get <Color>("PlayerStanceColorAllies");
            stanceColors.Enemies  = ChromeMetrics.Get <Color>("PlayerStanceColorEnemies");
            stanceColors.Neutrals = ChromeMetrics.Get <Color>("PlayerStanceColorNeutrals");

            unlockRenderPlayer = PlayerActor.TraitsImplementing <IUnlocksRenderPlayer>().ToArray();
        }