public DotState(Actor a, GpsASWatcher watcher, FrozenActorLayer frozenLayer)
{
Watcher = watcher;
if (frozenLayer != null)
{
FrozenActor = frozenLayer.FromID(a.ActorID);
}
}
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);
}
}
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);
}
}
/// <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);
}
public Traits(Player player, FrozenUnderFogUpdatedByGps frozenUnderFogUpdatedByGps)
{
FrozenActorLayer = player.PlayerActor.TraitOrDefault <FrozenActorLayer>();
GpsWatcher = player.PlayerActor.TraitOrDefault <GpsWatcher>();
GpsWatcher.RegisterForOnGpsRefreshed(frozenUnderFogUpdatedByGps.self, frozenUnderFogUpdatedByGps);
}
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();
}
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();
}