private async Task Receiver()
{
Response response;
var tasks = new List <Task>();
do
{
response = await _connectionService.ReceiveRequestAsync();
if (response.HasObservation)
{
ResponseObservation = response.Observation;
if (MapManager == null)
{
MapManager = GetMapManager();
}
await _workerManager.BuildWorkerIfEmptyQueue(ResponseObservation.Observation);
await _buildQueue.Act(ResponseObservation.Observation);
}
if (response.HasData)
{
ResponseData = response.Data;
}
if (response.HasGameInfo)
{
ResponseGameInfo = response.GameInfo;
}
} while (response.Status != Status.Ended || response.Status != Status.Quit);
}
public void OnStart(ResponseGameInfo gameInfo, ResponseData data, ResponseObservation observation, uint playerId)
{
if (realTime)
{
sw = new Stopwatch();
sw.Start();
}
GameInfo = gameInfo;
Data = data;
Observation = observation;
PlayerId = (int)playerId - 1;
OppenentsPlayerId = PlayerId == 1 ? 0 : 1;
Race = GameInfo.PlayerInfo[PlayerId].RaceActual;
OpponentsRace = GameInfo.PlayerInfo[OppenentsPlayerId].RaceActual;
Units.LoadData();
StateManager = new StateManager();
StateManager.OnFrame();
Map = new MapAnalyser();
Map.Analyse(this);
Build = new RoachAllIn();
if (test)
{
Build = new Testzerg();
}
Build.OnStart();
TaskManager = new TaskManager();
}
public override void OnStart(ResponseGameInfo gameInfo, ResponseData data, ResponsePing pingResponse, ResponseObservation observation, uint playerId, string opponentId)
{
GetPlayerInfo(gameInfo, playerId, opponentId);
if (EnemyPlayerService.Tournament.Enabled)
{
foreach (var buildSequence in EnemyPlayerService.Tournament.BuildSequences)
{
BuildChoices[ActualRace].BuildSequences[buildSequence.Key] = buildSequence.Value;
}
}
var buildSequences = BuildChoices[ActualRace].BuildSequences[EnemyRace.ToString()];
if (!string.IsNullOrWhiteSpace(EnemyPlayer.Name) && BuildChoices[ActualRace].BuildSequences.ContainsKey(EnemyPlayer.Name))
{
buildSequences = BuildChoices[ActualRace].BuildSequences[EnemyPlayer.Name];
}
MapName = gameInfo.MapName;
BuildSequence = BuildDecisionService.GetBestBuild(EnemyPlayer, buildSequences, MapName, EnemyPlayerService.Enemies, EnemyRace);
BuildHistory = new Dictionary <int, string>();
SwitchBuild(BuildSequence.First(), 0);
}
public Map(ResponseGameInfo gameInfo, uint playerID)
{
this.name = gameInfo.MapName;
this.checksum = GetCheckSum(Path.Combine(GameConnection.starcraftMaps, gameInfo.LocalMapPath));
this.fn = Path.Combine(location, name + " on " + DateTime.UtcNow.ToString("yyyy-MM-dd HH.mm.ss.ffff") + ".json").Replace("\\", "/");
foreach (var playerInfo in gameInfo.PlayerInfo)
{
if (playerInfo.PlayerId != playerID)
{
if (playerInfo.RaceRequested == Race.Protoss)
{
this.enemyRace = "Protoss";
}
else if (playerInfo.RaceRequested == Race.Terran)
{
this.enemyRace = "Terran";
}
else if (playerInfo.RaceRequested == Race.Zerg)
{
this.enemyRace = "Zerg";
}
else if (playerInfo.RaceRequested == Race.Random)
{
this.enemyRace = "Random";
}
break;
}
}
}
public RobotAi(ResponseGameInfo gameInfoResponse, ResponseData data)
{
this.gameInfo = gameInfoResponse;
dataInfo = data;
game = new Game(data);
}
public override void OnStart(ResponseGameInfo gameInfo, ResponseData data, ResponsePing pingResponse, ResponseObservation observation, uint playerId, string opponentId)
{
var placementGrid = gameInfo.StartRaw.PlacementGrid;
var heightGrid = gameInfo.StartRaw.TerrainHeight;
var pathingGrid = gameInfo.StartRaw.PathingGrid;
MapData.MapWidth = pathingGrid.Size.X;
MapData.MapHeight = pathingGrid.Size.Y;
MapData.Map = new Dictionary <int, Dictionary <int, MapCell> >();
for (var x = 0; x < pathingGrid.Size.X; x++)
{
var row = new Dictionary <int, MapCell>();
for (var y = 0; y < pathingGrid.Size.Y; y++)
{
var walkable = GetDataValueBit(pathingGrid, x, y);
var height = GetDataValueByte(heightGrid, x, y);
var placeable = GetDataValueBit(placementGrid, x, y);
row[y] = new MapCell {
X = x, Y = y, Walkable = walkable, TerrainHeight = height, Buildable = placeable, HasCreep = false, CurrentlyBuildable = placeable, EnemyAirDpsInRange = 0, EnemyGroundDpsInRange = 0, InEnemyVision = false, InSelfVision = false, InEnemyDetection = false, Visibility = 0, LastFrameVisibility = 0, NumberOfAllies = 0, NumberOfEnemies = 0, PoweredBySelfPylon = false, SelfAirDpsInRange = 0, SelfGroundDpsInRange = 0, LastFrameAlliesTouched = 0, PathBlocked = false
};
}
MapData.Map[x] = row;
}
MapData.PartialWallData = WallDataService.GetPartialWallData(gameInfo.MapName);
MapData.BlockWallData = WallDataService.GetBlockWallData(gameInfo.MapName);
MapData.MapName = gameInfo.MapName;
}
public void UpdateGame(ResponseGameInfo gameInfo, IReadOnlyCollection <SC2APIProtocol.Unit> sc2Units)
{
if (latestGameInfo == null)
{
return;
}
latestGameInfo = gameInfo;
Resources.Update(sc2Units);
Enemy.Update(sc2Units);
Self.Update(sc2Units);
foreach (var cc in Self.Buildings.LocateAll <ControlAbleBuilding>())
{
cc.Train(Terran.CommandCenter.Units.Scv);
}
Self.Units.First().SetupHighOrder(new HighLevelOrder()
{
Goal = Goal.Scout, Duration = Duration.AsLongAsPossible, Area = MapArea.EnemyBase
});
}
public IEnumerable <SC2APIProtocol.Action> OnFrame(ResponseGameInfo gameInfo, ResponseObservation obs)
{
Controller.OpenFrame(gameInfo, obs);
if (Controller.frame == 0)
{
Logger.Info("Initializing AviloBot");
Logger.Info("--------------------------------------");
Logger.Info("Map: {0}", gameInfo.MapName);
Logger.Info("--------------------------------------");
mapData = new Map(gameInfo, Controller.playerID);
}
Chatterer.Act(gameInfo, obs);
General.Act(gameInfo, obs);
Commander.Act(gameInfo, obs);
//hack, because LadderManager doesn't deliver Result
//if (Controller.After(60 * 5) && (Controller.Each(10)))
// OnGameEnded();
return(Controller.CloseFrame());
}
public override void OnStart(ResponseGameInfo gameInfo, ResponseData data, ResponsePing pingResponse, ResponseObservation observation, uint playerId, string opponentId)
{
foreach (var location in gameInfo.StartRaw.StartLocations)
{
TargetingData.AttackPoint = location;
TargetingData.EnemyMainBasePoint = location;
}
foreach (var unit in observation.Observation.RawData.Units.Where(u => u.Alliance == Alliance.Self && SharkyUnitData.UnitData[(UnitTypes)u.UnitType].Attributes.Contains(SC2APIProtocol.Attribute.Structure)))
{
TargetingData.MainDefensePoint = new Point2D {
X = unit.Pos.X, Y = unit.Pos.Y
};
var chokePoint = ChokePointService.FindDefensiveChokePoint(new Point2D {
X = unit.Pos.X + 4, Y = unit.Pos.Y + 4
}, TargetingData.AttackPoint, 0);
if (chokePoint != null)
{
TargetingData.ForwardDefensePoint = chokePoint;
var chokePoints = ChokePointService.GetEntireChokePoint(chokePoint);
if (chokePoints != null)
{
var wallPoints = ChokePointService.GetWallOffPoints(chokePoints);
if (wallPoints != null)
{
TargetingData.ForwardDefenseWallOffPoints = wallPoints;
}
}
}
else
{
TargetingData.ForwardDefensePoint = new Point2D {
X = unit.Pos.X, Y = unit.Pos.Y
};
}
if (MapData.PartialWallData != null)
{
var wallData = MapData.PartialWallData.FirstOrDefault(b => b.BasePosition.X == unit.Pos.X && b.BasePosition.Y == unit.Pos.Y);
if (wallData != null && wallData.Door != null)
{
TargetingData.ForwardDefensePoint = wallData.Door;
}
}
TargetingData.SelfMainBasePoint = new Point2D {
X = unit.Pos.X, Y = unit.Pos.Y
};
var naturalBaseLocation = BaseData.BaseLocations.Skip(1).Take(1).FirstOrDefault();
if (naturalBaseLocation != null)
{
TargetingData.NaturalBasePoint = naturalBaseLocation.Location;
}
return;
}
}
public override void OnStart(ResponseGameInfo gameInfo, ResponseData data, ResponsePing pingResponse, ResponseObservation observation, uint playerId, string opponentId)
{
foreach (var playerInfo in gameInfo.PlayerInfo)
{
if (playerInfo.PlayerId != playerId)
{
EnemyData.EnemyRace = playerInfo.RaceRequested;
}
}
}
public void LeaveGame()
{
Call(new Request {
LeaveGame = new RequestLeaveGame()
}).Wait();
gameInfo = null;
unitTypes = null;
abilities = null;
translator = null;
}
public void OnStart(ResponseGameInfo gameInfo, ResponseData data, ResponseObservation observation, uint playerId, string opponentID)
{
Observation = observation;
GameInfo = gameInfo;
PlayerId = playerId;
Data = data;
UnitTypes.LoadData(data);
MyRace = GameInfo.PlayerInfo[(int)Observation.Observation.PlayerCommon.PlayerId - 1].RaceActual;
EnemyRace = GameInfo.PlayerInfo[2 - (int)Observation.Observation.PlayerCommon.PlayerId].RaceRequested;
System.Console.WriteLine("MyRace: " + MyRace);
if (AllowWritingFiles)
{
File.AppendAllLines(Directory.GetCurrentDirectory() + "/Data/Tyr/Tyr.log", new string[] { "Game started on map: " + GameInfo.MapName });
File.AppendAllLines(Directory.GetCurrentDirectory() + "/Data/Tyr/Tyr.log", new string[] { "Enemy race: " + EnemyRace });
}
if (opponentID == null)
{
ResultsFile = Directory.GetCurrentDirectory() + "/Data/Tyr/" + EnemyRace + ".txt";
}
else
{
ResultsFile = Directory.GetCurrentDirectory() + "/Data/Tyr/" + opponentID + ".txt";
}
if (AllowWritingFiles && !File.Exists(ResultsFile))
{
File.Create(ResultsFile).Close();
}
MapAnalyzer.Analyze(this);
TargetManager.OnStart(this);
BaseManager.OnStart(this);
Build = DetermineBuild();
Build.InitializeTasks();
Build.OnStart(this);
Register("started " + EnemyRace + " " + Build.Name());
Managers.Add(UnitManager);
Managers.Add(EnemyManager);
Managers.Add(BaseManager);
Managers.Add(TargetManager);
Managers.Add(TaskManager);
Managers.Add(EffectManager);
if (GameInfo.PlayerInfo[(int)Observation.Observation.PlayerCommon.PlayerId - 1].RaceActual == Race.Protoss)
{
Managers.Add(NexusAbilityManager);
}
}
public void OnStart(ResponseGameInfo gameInfo, ResponseData data, ResponsePing pingResponse, ResponseObservation observation, uint playerId, string opponentID)
{
Observation = observation;
GameInfo = gameInfo;
PlayerId = playerId;
Data = data;
UnitTypes.LoadData(data);
GameVersion = pingResponse.GameVersion;
OldMapData = SC2Util.IsVersionBefore("4.9.3");
DebugUtil.WriteLine("Game version: " + pingResponse.GameVersion);
OpponentID = opponentID;
MyRace = GameInfo.PlayerInfo[(int)Observation.Observation.PlayerCommon.PlayerId - 1].RaceActual;
EnemyRace = GameInfo.PlayerInfo[2 - (int)Observation.Observation.PlayerCommon.PlayerId].RaceActual;
DebugUtil.WriteLine("MyRace: " + MyRace);
DebugUtil.WriteLine("EnemyRace: " + EnemyRace);
DebugUtil.WriteLine("Game started on map: " + GameInfo.MapName);
FileUtil.Log("Game started on map: " + GameInfo.MapName);
FileUtil.Log("Enemy race: " + EnemyRace);
MapAnalyzer.Analyze(this);
TargetManager.OnStart(this);
BaseManager.OnStart(this);
Build = DetermineBuild();
Build.InitializeTasks();
Build.OnStart(this);
FileUtil.Register("started " + EnemyRace + " " + Build.Name());
Managers.Add(UnitManager);
Managers.Add(EnemyManager);
Managers.Add(BaseManager);
Managers.Add(TargetManager);
Managers.Add(TaskManager);
Managers.Add(EffectManager);
Managers.Add(EnemyMineManager);
Managers.Add(EnemyTankManager);
Managers.Add(EnemyCycloneManager);
Managers.Add(EnemyBansheesManager);
if (GameInfo.PlayerInfo[(int)Observation.Observation.PlayerCommon.PlayerId - 1].RaceActual == Race.Protoss)
{
Managers.Add(NexusAbilityManager);
}
if (GameInfo.PlayerInfo[(int)Observation.Observation.PlayerCommon.PlayerId - 1].RaceActual == Race.Terran)
{
Managers.Add(OrbitalAbilityManager);
}
}
public SC2GameState(GameState gameState)
{
NewObservation = gameState.NewObservation;
GameInfo = gameState.GameInfo;
LastActions = gameState.LastActions.ToList();
if (gameState.LastObservation != null)
{
LastObservation = gameState.LastObservation.Value;
}
CurrentAction = new SC2APIProtocol.Action();
}
public override void OnStart(ResponseGameInfo gameInfo, ResponseData data, ResponsePing pingResponse, ResponseObservation observation, uint playerId, string opponentId)
{
foreach (UnitTypeData unitType in data.Units)
{
SharkyUnitData.UnitData.Add((UnitTypes)unitType.UnitId, unitType);
if (unitType.AbilityId != 0)
{
SharkyUnitData.UnitAbilities.Add((Abilities)unitType.AbilityId, (UnitTypes)unitType.UnitId);
}
}
}
public void OnStart(ResponseGameInfo gameInfo, ResponseData data, ResponsePing pingResponse, ResponseObservation observation, uint playerId, string opponentID)
{
GameTime = Stopwatch.StartNew();
GameInfo = gameInfo;
CustomActionList.Add(new BotActin(true, new Action {
ActionChat = new ActionChat {
Message = "good luck have fun and... not enouph minerals"
}
}, 5));
//CustomActionList.Add(new BotActin(true, new Action { ActionRaw = new ActionRaw()
}
public override void OnStart(ResponseGameInfo gameInfo, ResponseData data, ResponsePing pingResponse, ResponseObservation observation, uint playerId, string opponentId)
{
foreach (var playerInfo in gameInfo.PlayerInfo)
{
if (playerInfo.PlayerId == playerId)
{
MacroData.Race = playerInfo.RaceActual;
}
}
MacroSetup.SetupMacro(MacroData);
}
public void Initialize(ResponseGameInfo info, IIntelManager intelManager)
{
PlacementGrid = MapHandler.Instantiate(info.StartRaw.PlacementGrid);
NonPathable = MapHandler.Instantiate(info.StartRaw.PathingGrid);
TerrainHeight = MapHandler.Instantiate(info.StartRaw.TerrainHeight);
BlockedGrid = MapHandler.Instantiate(PlacementGrid.Width, PlacementGrid.Height);
NaturalGrid = MapHandler.Instantiate(PlacementGrid.Width, PlacementGrid.Height);
Power = MapHandler.Instantiate(PlacementGrid.Width, PlacementGrid.Height);
Creep = MapHandler.Instantiate(PlacementGrid.Width, PlacementGrid.Height);
Explored = MapHandler.Instantiate(PlacementGrid.Width, PlacementGrid.Height);
intelManager.Handler.RegisterHandler(Case.StructureAddedSelf, u => EventUnitAdded(u));
intelManager.Handler.RegisterHandler(Case.StructureDestroyed, u => EventUnitDestroyed(u));
}
public GameState(
ResponseGameInfo gameInfo,
ResponseObservation observation,
Map map,
Dictionary <uint, UnitTypeData> unitTypes,
Dictionary <uint, AbilityData> abilities,
Dictionary <uint, BuffData> buffs,
Translator translator,
params object[] mapData)
{
this.GameInfo = gameInfo;
this.Response = observation;
this.Map = map;
this.UnitTypes = unitTypes;
this.Abilities = abilities;
this.Translator = translator;
this.Buffs = buffs;
this.mapData = mapData.ToDictionary(m => m.GetType());
var unitsByAlliance = this.Response.Observation.RawData.Units.GroupBy(u => u.Alliance);
foreach (var grouping in unitsByAlliance)
{
if (grouping.Key == Alliance.Self)
{
this.Units = grouping.Select(translator.ConvertUnit).ToList();
}
else if (grouping.Key == Alliance.Ally)
{
this.AlliedUnits = grouping.Select(translator.ConvertUnit).ToList();
}
else if (grouping.Key == Alliance.Enemy)
{
this.EnemyUnits = grouping.Select(translator.ConvertUnit).ToList();
}
else if (grouping.Key == Alliance.Neutral)
{
this.NeutralUnits = grouping.Select(translator.ConvertUnit).ToList();
}
}
this.Units = this.Units ?? new List <Unit>();
this.AlliedUnits = this.AlliedUnits ?? new List <Unit>();
this.EnemyUnits = this.EnemyUnits ?? new List <Unit>();
this.NeutralUnits = this.NeutralUnits ?? new List <Unit>();
this.AllUnits = this.Units.Concat(this.AlliedUnits).Concat(this.EnemyUnits).Concat(this.NeutralUnits).ToList();
}
public static void Act(ResponseGameInfo gameInfo, ResponseObservation obs)
{
if (Controller.frame == 0)
{
Chat("hello", chatHello);
}
if ((Controller.ownUnits.structures.Count == 1) && (Controller.ownUnits.structures[0].integrity < 0.35f))
{
Chat("gg", chatGG);
}
if (Controller.At(10 * 60))
{
if (Controller.score > 10000)
{
Chat("winning1", winning1);
}
else
{
Chat("losing1", losing1);
}
}
if (Controller.At(15 * 60))
{
if (Controller.score > 15000)
{
Chat("winning2", winning2);
}
else
{
Chat("losing1", losing1);
}
}
if (Controller.At(20 * 60))
{
if (Controller.score > 25000)
{
Chat("winning2", winning3);
}
else
{
Chat("losing1", losing1);
}
}
}
public GameState GetGameState()
{
gameInfo = gameInfo ?? Call(new Request {
GameInfo = new RequestGameInfo()
}, r => r?.GameInfo != null).Result.GameInfo;
unitTypes = unitTypes ?? Call(new Request {
Data = new RequestData {
UnitTypeId = true
}
}, r => (r?.Data?.Units).NotNullOrEmpty()).Result.Data.Units.ToDictionary(unitType => unitType.UnitId);
abilities = abilities ?? Call(new Request {
Data = new RequestData {
AbilityId = true
}
}, r => (r?.Data?.Abilities).NotNullOrEmpty()).Result.Data.Abilities.ToDictionary(ability => ability.AbilityId);
buffs = buffs ?? Call(new Request {
Data = new RequestData {
BuffId = true
}
}, r => (r?.Data?.Buffs).NotNullOrEmpty()).Result.Data.Buffs.ToDictionary(b => b.BuffId);
translator = translator ?? new Translator(abilities, unitTypes, buffs);
map = map ?? new Map(gameInfo.StartRaw);
var response = Call(new Request {
Observation = new RequestObservation()
}, r => r?.Observation != null);
var observation = response.Result.Observation;
var units = observation.Observation.RawData.Units.Select(u => translator.ConvertUnit(u)).ToList();
map = new Map(map, units, translator, unitTypes, observation.Observation.RawData.MapState.Creep);
foreach (var mapDataType in mapAnalyzers.Keys)
{
var method = typeof(SynchronousApiClient).GetMethod("InvokeAnalyzer", BindingFlags.NonPublic | BindingFlags.Instance).MakeGenericMethod(mapDataType);
method.Invoke(this, new object[] { map });
}
var mapDataArray = mapData.Values.ToArray();
lastGameState = new GameState(gameInfo, response.Result.Observation, map, unitTypes, abilities, buffs, translator, mapDataArray);
return(lastGameState);
}
public void OnStart(ResponseGameInfo gameInfo, ResponseData data, ResponsePing pingResponse, ResponseObservation observation, uint playerId, string opponentId)
{
Console.WriteLine($"Game Version: {pingResponse.GameVersion}");
var stopwatch = new Stopwatch();
stopwatch.Start();
foreach (var manager in Managers)
{
manager.OnStart(gameInfo, data, pingResponse, observation, playerId, opponentId);
}
stopwatch.Stop();
Console.WriteLine($"OnStart: {stopwatch.ElapsedMilliseconds} ms");
TotalFrameTime = 0;
}
public void OpenFrame(ResponseGameInfo gameInfo, ResponseObservation obs)
{
this.obs = obs;
this.gameInfo = gameInfo;
this.actions = new List <SC2APIProtocol.Action>();
if (obs == null)
{
Logger.Info("ResponseObservation is null! The application will terminate.");
Pause();
Environment.Exit(0);
}
foreach (var chat in obs.Chat)
{
this.chatLog.Add(chat.Message);
}
this.frame = obs.Observation.GameLoop;
this.currentSupply = obs.Observation.PlayerCommon.FoodUsed;
this.maxSupply = obs.Observation.PlayerCommon.FoodCap;
this.minerals = obs.Observation.PlayerCommon.Minerals;
this.vespene = obs.Observation.PlayerCommon.Vespene;
PopulateInventory();
if (frame == 0)
{
var rcPosition = GetPosition(units.resourceCenters[0]);
foreach (var startLocation in gameInfo.StartRaw.StartLocations)
{
var enemyLocation = new Vector3(startLocation.X, startLocation.Y, 0);
var distance = GetDistance(enemyLocation, rcPosition);
if (distance > 30)
{
enemyLocations.Add(enemyLocation);
}
}
}
if (frameDelay > 0)
{
System.Threading.Thread.Sleep(frameDelay);
}
}
public IEnumerable <Action> GetActions(ResponseObservation observation, ResponseGameInfo giResponseGameInfo)
{
var actions = new List <Action>();
if (observation?.Observation?.RawData == null)
{
return(actions);
}
game.UpdateGame(giResponseGameInfo, observation.Observation.RawData.Units);
actions.AddRange(game.CollectOrders());
return(actions);
}
public void Setup()
{
// From AcropolisLE.SC2Map
var mapSize = new Size2DI {
X = 176, Y = 184
};
_gameInfo = new ResponseGameInfo
{
StartRaw = new StartRaw
{
MapSize = mapSize,
PathingGrid = new ImageData
{
BitsPerPixel = 1,
Size = mapSize,
Data = ByteString.FromBase64(PathingGridBitmap)
},
PlacementGrid = new ImageData
{
BitsPerPixel = 1,
Size = mapSize,
Data = ByteString.FromBase64(PlacementGridBitmap)
},
PlayableArea = new RectangleI
{
P0 = new PointI {
X = 18, Y = 18
},
P1 = new PointI {
X = 156, Y = 153
}
}
}
};
// Test grid setup
GridConverter.GetDataValueBit(_gameInfo.StartRaw.PathingGrid, 22, 131).Should().Be(1);
GridConverter.GetDataValueBit(_gameInfo.StartRaw.PlacementGrid, 22, 131).Should().Be(1);
GridConverter.GetDataValueBit(_gameInfo.StartRaw.PathingGrid, 40, 124).Should().Be(1);
GridConverter.GetDataValueBit(_gameInfo.StartRaw.PlacementGrid, 40, 123).Should().Be(0);
}
public override void OnStart(ResponseGameInfo gameInfo, ResponseData data, ResponsePing pingResponse, ResponseObservation observation, uint playerId, string opponentId)
{
ActiveChatData.TimeModulation = 1;
LastFrameTime = 0;
RuntimeFrameRate = SharkyOptions.FramesPerSecond;
GreetingSent = false;
ActiveChatData.ChatActions = new List <Action>();
Self = gameInfo.PlayerInfo[(int)observation.Observation.PlayerCommon.PlayerId - 1];
Enemy = gameInfo.PlayerInfo[2 - (int)observation.Observation.PlayerCommon.PlayerId];
ConversationName = $"starcraft-{Enemy.PlayerId}-{DateTimeOffset.Now.ToUnixTimeMilliseconds()}";
ActiveChatData.EnemyName = EnemyNameService.GetEnemyNameFromId(opponentId, EnemyPlayerManager.Enemies);
ChatHistory.EnemyChatHistory = new Dictionary <int, string>();
ChatHistory.MyChatHistory = new Dictionary <int, string>();
}
public void LoadFrom(Stream s)
{
BinaryReader bw = new BinaryReader(s);
NewObservation = new ResponseObservation();
NewObservation.Load(bw);
GameInfo = new ResponseGameInfo();
GameInfo.Load(bw);
LastObservation = new ResponseObservation();
LastObservation.Load(bw);
int num = bw.ReadInt32();
LastActions = new List <SC2APIProtocol.Action>();
for (int i = 0; i < num; i++)
{
SC2APIProtocol.Action a = new SC2APIProtocol.Action();
a.Load(bw);
LastActions.Add(a);
}
CurrentAction = new SC2APIProtocol.Action();
CurrentAction.Load(bw);
AIActions.Load(bw);
}
protected void GetPlayerInfo(ResponseGameInfo gameInfo, uint playerId, string opponentId)
{
string enemyName = string.Empty;
foreach (var playerInfo in gameInfo.PlayerInfo)
{
if (playerInfo.PlayerId == playerId)
{
ActualRace = playerInfo.RaceActual;
SelectedRace = playerInfo.RaceRequested;
}
else
{
if (playerInfo.PlayerName != null)
{
enemyName = playerInfo.PlayerName;
}
EnemyRace = playerInfo.RaceRequested;
EnemySelectedRace = playerInfo.RaceRequested;
}
}
EnemyPlayer = EnemyPlayerService.Enemies.FirstOrDefault(e => e.Id == opponentId);
if (opponentId == "test" && EnemyPlayer == null)
{
EnemyPlayer = new EnemyPlayer.EnemyPlayer {
ChatMatches = new List <string>(), Games = new List <Game>(), Id = opponentId, Name = "test"
};
}
if (EnemyPlayer == null)
{
EnemyPlayer = new EnemyPlayer.EnemyPlayer {
ChatMatches = new List <string>(), Games = new List <Game>(), Id = opponentId, Name = enemyName
};
}
}
public IEnumerable <SC2APIProtocol.Action> onFrame(ResponseGameInfo gameInfo, ResponseObservation observation, uint playerId)
{
List <SC2APIProtocol.Action> actions = new List <SC2APIProtocol.Action>();
return(actions);
}
public virtual void OnStart(ResponseGameInfo gameInfo, ResponseData data, ResponsePing pingResponse, ResponseObservation observation, uint playerId, string opponentId)
{
}
