public void UpdateGlobalWorldMap(GlobalWorldMap globalWorldMap)
{
lock (globalWorldMap.teammateLocationList)
{
foreach (var robotLoc in globalWorldMap.teammateLocationList)
{
UpdateRobotLocation(robotLoc.Key, robotLoc.Value);
}
}
lock (globalWorldMap.opponentLocationList)
{
int i = 0;
foreach (var opponentLocation in globalWorldMap.opponentLocationList)
{
if (globalWorldMap.TeamId == (int)TeamId.Team1)
{
UpdateOpponentsLocation((int)TeamId.Team2 + i, opponentLocation);
}
else if (globalWorldMap.TeamId == (int)TeamId.Team2)
{
UpdateOpponentsLocation((int)TeamId.Team1 + i, opponentLocation);
}
i++;
}
}
UpdateBallLocation(globalWorldMap.ballLocation);
}
//************************ Events reçus ************************************************/
//public abstract void OnRefBoxMsgReceived(object sender, WorldMap.RefBoxMessageArgs e);
/// Evènement envoyé par le module de gestion de la LocalWorldMap
public void OnGlobalWorldMapReceived(object sender, GlobalWorldMapArgs e)
{
//On récupère la nouvelle worldMap
lock (globalWorldMap)
{
globalWorldMap = e.GlobalWorldMap;
}
}
public virtual void OnGlobalWorldMap(GlobalWorldMap map)
{
var handler = OnGlobalWorldMapEvent;
if (handler != null)
{
handler(this, new GlobalWorldMapArgs {
GlobalWorldMap = map
});
}
}
public StrategyEurobot2021(int robotId, int teamId, string teamIpAddress) : base(robotId, teamId, teamIpAddress)
{
//this.teamId = teamId;
//this.robotId = robotId;
globalWorldMap = new GlobalWorldMap();
InitHeatMap();
//timerStrategy = new Timer();
//timerStrategy.Interval = 50;
//timerStrategy.Elapsed += TimerStrategy_Elapsed;
//timerStrategy.Start();
}
public StrategyGenerique(int robotId, int teamId, string teamIpAddress)
{
this.teamId = teamId;
this.robotId = robotId;
this.teamIpAddress = teamIpAddress;
globalWorldMap = new GlobalWorldMap();
timerStrategy = new System.Timers.Timer();
timerStrategy.Interval = 50;
timerStrategy.Elapsed += TimerStrategy_Elapsed;
timerStrategy.Start();
}
//Event de récupération d'une GlobalWorldMap mise à jour
public void OnGlobalWorldMapReceived(object sender, GlobalWorldMapArgs e)
{
//On récupère le gameState avant arrivée de la nouvelle worldMap
//GameState gameState_1 = globalWorldMap.gameState;
//On récupère la nouvelle worldMap
lock (globalWorldMap)
{
globalWorldMap = e.GlobalWorldMap;
}
//On regarde si le gamestate a changé
//if (globalWorldMap.gameState != gameState_1)
//{
// //Le gameState a changé, on envoie un event
// OnGameStateChanged(robotId, globalWorldMap.gameState);
//}
}
public void OnGlobalWorldMapReceived(object sender, GlobalWorldMapArgs e)
{
//On récupère le gameState avant arrivée de la nouvelle worldMap
GameState gameState_1 = globalWorldMap.gameState;
//On écupère la nouvelle worldMap
globalWorldMap = e.GlobalWorldMap;
//On regarde si le gamestate a changé
if (globalWorldMap.gameState != gameState_1)
{
//Le gameState a changé, on envoie un event
OnGameStateChanged(robotId, globalWorldMap.gameState);
}
//Le joueur détermine sa stratégie
SetRobotRole();
SetRobotDestination(robotRole);
ProcessStrategy();
}
//bool replayModeActivated = false;
public PerceptionManager(int id, GameMode compet)
{
robotId = id;
competition = compet;
globalWorldMap = new GlobalWorldMap();
robotPerception = new Perception();
physicalObjectList = new List <LocationExtended>();
//Chainage des modules composant le Perception Manager
absolutePositionEstimator = new AbsolutePositionEstimator(robotId);
lidarProcessor = new LidarProcessor.LidarProcessor(robotId, competition);
lidarProcessor.OnLidarBalisesListExtractedEvent += absolutePositionEstimator.OnLidarBalisesListExtractedEvent;
lidarProcessor.OnLidarBalisePointListForDebugEvent += OnLidarBalisePointListForDebugReceived;
lidarProcessor.OnLidarObjectProcessedEvent += OnLidarObjectsReceived;
lidarProcessor.OnLidarProcessedEvent += OnLidarProcessedData;
absolutePositionEstimator.OnAbsolutePositionCalculatedEvent += OnAbsolutePositionCalculatedEvent;
PerceptionMonitor.swPerception.Start();
}
void Start()
{
GlobalItens.Init();
GlobalCharacter.Init();
GlobalWorldMap.Init();
GlobalQuests.Init();
GlobalMap.Init();
GlobalInput.Init();
_itens = new ArrayList();
_npcs = new ArrayList();
AddItemToMap(GlobalItens.generateAlchemy(AlchemyType.HealLife), new Vector3(64, 96, -5));
GameCharacter test = GlobalCharacter.generetaChar();
test.name = "ERRROR";
test.sprite = 5;
AddCharacterToMap(test, new Vector3(32, 32, -10));
}
public void UpdateGlobalWorldMap(GlobalWorldMap globalWorldMap)
{
lock (globalWorldMap.teammateLocationList)
{
foreach (var robotLoc in globalWorldMap.teammateLocationList)
{
UpdateRobotLocation(robotLoc.Key, robotLoc.Value);
}
}
lock (globalWorldMap.teammateRoleList)
{
foreach (var robotRole in globalWorldMap.teammateRoleList)
{
UpdateRobotRole(robotRole.Key, robotRole.Value);
}
}
lock (globalWorldMap.teammateDisplayMessageList)
{
foreach (var messageDisplay in globalWorldMap.teammateDisplayMessageList)
{
UpdateDisplayMessage(messageDisplay.Key, messageDisplay.Value);
}
}
lock (globalWorldMap.teammatePlayingSideList)
{
foreach (var playingSide in globalWorldMap.teammatePlayingSideList)
{
UpdatePlayingSide(playingSide.Key, playingSide.Value);
}
}
lock (globalWorldMap.teammateGhostLocationList)
{
foreach (var robotGhostLoc in globalWorldMap.teammateGhostLocationList)
{
UpdateRobotGhostLocation(robotGhostLoc.Key, robotGhostLoc.Value);
}
}
lock (globalWorldMap.teammateDestinationLocationList)
{
foreach (var robotDest in globalWorldMap.teammateDestinationLocationList)
{
UpdateRobotDestination(robotDest.Key, robotDest.Value);
}
}
lock (globalWorldMap.teammateWayPointList)
{
foreach (var robotWayPointt in globalWorldMap.teammateWayPointList)
{
UpdateRobotWaypoint(robotWayPointt.Key, robotWayPointt.Value);
}
}
lock (globalWorldMap.obstacleLocationList)
{
int i = 0;
foreach (var opponentLocation in globalWorldMap.obstacleLocationList)
{
if (globalWorldMap.TeamId == (int)TeamId.Team1)
{
UpdateOpponentLocation((int)TeamId.Team2 + i, new Location(opponentLocation.X, opponentLocation.Y, 0, 0, 0, 0));
}
else if (globalWorldMap.TeamId == (int)TeamId.Team2)
{
UpdateOpponentLocation((int)TeamId.Team1 + i, new Location(opponentLocation.X, opponentLocation.Y, 0, 0, 0, 0));
}
i++;
}
}
UpdateBallLocationList(globalWorldMap.ballLocationList);
}
private void MergeLocalWorldMaps()
{
//Fusion des World Map locales pour construire la world map globale
//Génération de la carte fusionnée à partir des perceptions des robots de l'équipe
//La fusion porte avant tout sur la balle et sur les adversaires.
//TODO : faire un algo de fusion robuste pour la balle
globalWorldMap = new WorldMap.GlobalWorldMap(TeamId);
//Pour l'instant on prend la position de balle vue par le robot 1 comme vérité, mais c'est à améliorer !
if (localWorldMapDictionary.Count > 0)
{
globalWorldMap.ballLocationList = localWorldMapDictionary.First().Value.ballLocationList;
}
globalWorldMap.teammateLocationList = new Dictionary <int, Location>();
globalWorldMap.teammateGhostLocationList = new Dictionary <int, Location>();
globalWorldMap.teammateDestinationLocationList = new Dictionary <int, Location>();
globalWorldMap.teammateBallHandlingStateList = new Dictionary <int, BallHandlingState>();
globalWorldMap.teammateWayPointList = new Dictionary <int, Location>();
globalWorldMap.opponentLocationList = new List <Location>();
globalWorldMap.obstacleLocationList = new List <LocationExtended>();
globalWorldMap.teammateRoleList = new Dictionary <int, RoboCupRobotRole>();
globalWorldMap.teammateDisplayMessageList = new Dictionary <int, string>();
globalWorldMap.teammatePlayingSideList = new Dictionary <int, PlayingSide>();
//On place tous les robots de l'équipe dans la global map
foreach (var localMap in localWorldMapDictionary)
{
//On ajoute la position des robots de l'équipe dans la WorldMap
globalWorldMap.teammateLocationList.Add(localMap.Key, localMap.Value.robotLocation);
//On ajoute le rôle des robots de l'équipe dans la WorldMap
globalWorldMap.teammateRoleList.Add(localMap.Key, localMap.Value.robotRole);
//On ajoute l'état de Ball Handling des robots de l'équipe dans la WorldMap
globalWorldMap.teammateBallHandlingStateList.Add(localMap.Key, localMap.Value.ballHandlingState);
//On ajoute le message à afficher des robots de l'équipe dans la WorldMap
globalWorldMap.teammateDisplayMessageList.Add(localMap.Key, localMap.Value.messageDisplay);
//On ajoute le playing Side des robots de l'équipe dans la WorldMap
globalWorldMap.teammatePlayingSideList.Add(localMap.Key, localMap.Value.playingSide);
//On ajoute le ghost (position théorique) des robots de l'équipe dans la WorldMap
globalWorldMap.teammateGhostLocationList.Add(localMap.Key, localMap.Value.robotGhostLocation);
//On ajoute la destination des robots de l'équipe dans la WorldMap
globalWorldMap.teammateDestinationLocationList.Add(localMap.Key, localMap.Value.destinationLocation);
//On ajoute le waypoint courant des robots de l'équipe dans la WorldMap
globalWorldMap.teammateWayPointList.Add(localMap.Key, localMap.Value.waypointLocation);
}
try
{
//TODO : Fusion des obstacles vus par chacun des robots
foreach (var localMap in localWorldMapDictionary)
{
foreach (var obstacle in localMap.Value.obstaclesLocationList)
{
if (obstacle != null)
{
bool skipNext = false;
/// On itère sur chacun des obstacles perçus par chacun des robots
/// On commence regarde pour chaque obstacle perçu si il ne correspond pas à une position de robot de l'équipe
/// Si c'est le cas, on abandonne cet obstacle
/// Si ce n'est pas le cas, on regarde si il ne correspond pas à un obstacle déjà présent dans la liste des obstacles
/// Si ce n'est pas le cas, on l'ajoute à la liste des obtacles
/// Si c'est le cas, on le fusionne en moyennant ses coordonnées de manière pondérée
/// et on renforce le poids de cet obstacle
foreach (var teamMateRobot in globalWorldMap.teammateLocationList)
{
if (Toolbox.Distance(new PointD(obstacle.X, obstacle.Y), new PointD(teamMateRobot.Value.X, teamMateRobot.Value.Y)) < distanceMaxFusionTeamMate)
{
/// L'obstacle est un robot, on abandonne
skipNext = true;
break;
}
}
if (skipNext == false)
{
/// Si on arrive ici c'est que l'obstacle n'est pas un robot de l'équipe
foreach (var obstacleConnu in globalWorldMap.obstacleLocationList)
{
if (Toolbox.Distance(new PointD(obstacle.X, obstacle.Y), new PointD(obstacleConnu.X, obstacleConnu.Y)) < distanceMaxFusionObstacle)
{
//L'obstacle est déjà connu, on le fusionne /TODO : améliorer la fusion avec pondération
obstacleConnu.X = (obstacleConnu.X + obstacle.X) / 2;
obstacleConnu.Y = (obstacleConnu.Y + obstacle.Y) / 2;
skipNext = true;
break;
}
}
}
if (skipNext == false)
{
/// Si on arrive ici, c'est que l'obstacle n'était pas connu, on l'ajoute
globalWorldMap.obstacleLocationList.Add(obstacle);
}
}
}
}
}
catch { }
/// Transfert de la globalworldmap via le Multicast UDP
var s = ZeroFormatterSerializer.Serialize <WorldMap.ZeroFormatterMsg>(globalWorldMap);
OnGlobalWorldMap(globalWorldMap);
//OnMulticastSendGlobalWorldMap(s);
//GWMEmiseMonitoring.GWMEmiseMonitor(s.Length);
}
public void OnMulticastDataReceived(object sender, EventArgsLibrary.DataReceivedArgs e)
{
lock (e.Data)
{
var deserialization = ZeroFormatterSerializer.Deserialize <ZeroFormatterMsg>(e.Data);
switch (deserialization.Type)
{
case ZeroFormatterMsgType.LocalWM:
LocalWorldMap lwm = (LocalWorldMap)deserialization;
//if (Id == lwm.RobotId)
{
OnLocalWorldMap(lwm);
//UdpMonitor.LWMReceived(e.Data.Length);
}
break;
case ZeroFormatterMsgType.GlobalWM:
GlobalWorldMap gwm = (GlobalWorldMap)deserialization;
//UdpMonitor.GWMReceived(e.Data.Length);
OnGlobalWorldMap(gwm);
break;
case ZeroFormatterMsgType.RefBoxMsg:
RefBoxMessage refBoxMsg = (RefBoxMessage)deserialization;
OnRefBoxMessage(refBoxMsg);
break;
default:
break;
}
//var compressedData = e.Data;
//Console.WriteLine(string.Format("Received bytes: {0}", compressedData.Length));
//string uncompressedTextData = "";// Zip.UnzipText(compressedData);
// //Console.WriteLine(string.Format("Decompressed bytes: {0}", uncompressedTextData.Length));
//JObject obj = JObject.Parse(Encoding.Default.GetString(e.Data));
//try
//{
// switch ((int)obj["Type"])
// {
// case (int)WorldMapType.LocalWM:
// LocalWorldMap lwm = obj.ToObject<LocalWorldMap>();
// OnLocalWorldMap(lwm);
// break;
// case (int)WorldMapType.GlobalWM:
// GlobalWorldMap gwm = obj.ToObject<GlobalWorldMap>();
// OnGlobalWorldMap(gwm);
// break;
// default:
// break;
// }
//}
//catch
//{
// Console.WriteLine("Exception Message non décodable en json : UdpMulticastInterpreter");
//}
}
}
public void OnGlobalWorldMapReceived(object sender, GlobalWorldMapArgs e)
{
globalWorldMap = e.GlobalWorldMap;
}
private void MergeLocalWorldMaps()
{
//Fusion des World Map locales pour construire la world map globale
lock (localWorldMapDictionary)
{
//On rassemble les infos issues des cartes locales de chacun des robots
foreach (var localMap in localWorldMapDictionary)
{
globalWorldMapStorage.AddOrUpdateRobotLocation(localMap.Key, localMap.Value.robotLocation);
globalWorldMapStorage.AddOrUpdateBallLocation(localMap.Key, localMap.Value.ballLocation);
globalWorldMapStorage.AddOrUpdateRobotDestination(localMap.Key, localMap.Value.destinationLocation);
globalWorldMapStorage.AddOrUpdateRobotWayPoint(localMap.Key, localMap.Value.waypointLocation);
globalWorldMapStorage.AddOrUpdateObstaclesList(localMap.Key, localMap.Value.obstaclesLocationList);
}
//Génération de la carte fusionnée à partir des perceptions des robots de l'équipe
//La fusion porte avant tout sur la balle et sur les adversaires.
//TODO : faire un algo de fusion robuste pour la balle
globalWorldMap = new WorldMap.GlobalWorldMap(TeamId);
//Pour l'instant on prend la position de balle vue par le robot 1 comme vérité, mais c'est à améliorer !
if (localWorldMapDictionary.Count > 0)
{
globalWorldMap.ballLocation = localWorldMapDictionary.First().Value.ballLocation;
}
globalWorldMap.teammateLocationList = new Dictionary <int, PerceptionManagement.Location>();
globalWorldMap.opponentLocationList = new List <PerceptionManagement.Location>();
//On place tous les robots de l'équipe dans la global map
foreach (var localMap in localWorldMapDictionary)
{
//On ajoute la position des robots de l'équipe dans la WorldMap
globalWorldMap.teammateLocationList.Add(localMap.Key, localMap.Value.robotLocation);
}
//On établit une liste des emplacements d'adversaires potentiels afin de les fusionner si possible
List <Location> AdversairesPotentielsList = new List <Location>();
List <int> AdversairesPotentielsMatchOccurenceList = new List <int>();
foreach (var localMap in localWorldMapDictionary)
{
//On tente de transformer les objets vus et ne correspondant pas à des robots alliés en des adversaires
List <Location> obstacleLocationList = new List <Location>();
try
{
obstacleLocationList = localMap.Value.obstaclesLocationList.ToList();
}
catch { }
foreach (var obstacleLocation in obstacleLocationList)
{
bool isTeamMate = false;
bool isAlreadyPresentInOpponentList = false;
//On regarde si l'obstacle est un coéquipier ou pas
foreach (var robotTeamLocation in globalWorldMap.teammateLocationList.Values)
{
if (obstacleLocation != null && robotTeamLocation != null)
{
if (Toolbox.Distance(obstacleLocation.X, obstacleLocation.Y, robotTeamLocation.X, robotTeamLocation.Y) < 0.4)
{
isTeamMate = true;
}
}
}
//On regarde si l'obstacle existe dans la liste des adversaires potentiels ou pas
foreach (var opponentLocation in AdversairesPotentielsList)
{
if (obstacleLocation != null && opponentLocation != null)
{
if (Toolbox.Distance(obstacleLocation.X, obstacleLocation.Y, opponentLocation.X, opponentLocation.Y) < 0.4)
{
isAlreadyPresentInOpponentList = true;
var index = AdversairesPotentielsList.IndexOf(opponentLocation);
AdversairesPotentielsMatchOccurenceList[index]++;
}
}
}
//Si un obstacle n'est ni un coéquipier, ni un adversaire potentiel déjà trouvé, c'est un nouvel adversaire potentiel
if (!isTeamMate && !isAlreadyPresentInOpponentList)
{
AdversairesPotentielsList.Add(obstacleLocation);
AdversairesPotentielsMatchOccurenceList.Add(1);
}
}
}
//On valide les adversaires potentiels si ils ont été perçus plus d'une fois par les robots
for (int i = 0; i < AdversairesPotentielsList.Count; i++)
{
if (AdversairesPotentielsMatchOccurenceList[i] >= 2)
{
var opponentLocation = AdversairesPotentielsList[i];
globalWorldMap.opponentLocationList.Add(opponentLocation);
}
}
}
OnGlobalWorldMap(globalWorldMap);
}
public void OnGlobalWorldMapReceived(object sender, GlobalWorldMapArgs e)
{
globalWorldMap = e.GlobalWorldMap;
ProcessStrategy();
}