// Update is called once per frame
void Update()
{
if (gs.isGameOver)
{
StopAllCoroutines();
return;
}
if (!gameStarted)
{
return;
}
//echap pour mettre le jeu en pause
if (Input.GetKeyDown(KeyCode.Escape))
{
if (gs.isPaused == false)
{
gs.isPaused = true;
IMS.Pause(gs.isPaused);
}
else
{
gs.isPaused = false;
IMS.Pause(gs.isPaused);
}
}
if (gs.isPaused)
{
return;
}
IMS.UpdateScore(gs.playerScore1, gs.playerScore2);
if (gs.playerScore1 >= 3 || gs.playerScore2 >= 3)
{
IMS.FinDePartie();
gs.isGameOver = true;
}
PlayerView1.position = gs.playerPosition1;
PlayerView2.position = gs.playerPosition2;
frisbeeView.position = gs.frisbeePosition;
Rules.Step(ref gs, agentJ1.Act(ref gs, Rules.GetAvailableActions1(ref gs)), agentJ2.Act(ref gs, Rules.GetAvailableActions2(ref gs)));
}
public void Execute()
{
var epochs = 10;
var agent = rdmAgent;
var gsCopy = Rules.Clone(ref gs);
if (Playerid == 0)
{
var rootHash = Rules.GetHashCodeJ1(ref gsCopy);
var memory = new NativeHashMap <long, NativeList <Node> >(2048, Allocator.Temp);
var possibleChoice = Rules.GetAvailableActions2int(ref gsCopy);
memory.TryAdd(rootHash, new NativeList <Node>(availableActionsFree.Length, Allocator.Temp));
for (var i = 0; i < availableActionsFree.Length; i++)
{
memory[rootHash]
.Add(new Node
{
action = availableActionsFree[i],
nc = 0,
npc = 0,
rc = 0
});
}
for (var n = 0; n < epochs; n++)
{
gsCopy = Rules.Clone(ref gs);
var currentHash = rootHash;
var selectedNodes = new NativeList <SelectedNodeInfo>(Allocator.Temp);
//SELECT
while (!gsCopy.isGameOver)
{
var hasUnexploredNodes = false;
for (var i = 0; i < memory[currentHash].Length; i++)
{
if (memory[currentHash][i].nc == 0)
{
hasUnexploredNodes = true;
break;
}
}
if (hasUnexploredNodes)
{
break;
}
var bestNodeIndex = -1;
var bestNodeScore = float.MinValue;
for (var i = 0; i < memory[currentHash].Length; i++)
{
var list = memory[currentHash];
var node = list[i];
node.npc += 1;
list[i] = node;
memory[currentHash] = list;
var score = (float)memory[currentHash][i].rc / memory[currentHash][i].nc
+ math.sqrt(2 * math.log(memory[currentHash][i].npc) / memory[currentHash][i].nc);
if (score >= bestNodeScore)
{
bestNodeIndex = i;
bestNodeScore = score;
}
}
selectedNodes.Add(new SelectedNodeInfo
{
hash = currentHash,
nodeIndex = bestNodeIndex
});
Rules.Step(ref gsCopy, memory[currentHash][bestNodeIndex].action, 0);
currentHash = Rules.GetHashCodeJ1(ref gsCopy);
if (!memory.ContainsKey(currentHash))
{
memory.TryAdd(currentHash, new NativeList <Node>(availableActionsFree.Length, Allocator.Temp));
for (var i = 0; i < availableActionsFree.Length; i++)
{
memory[currentHash]
.Add(new Node
{
action = availableActionsFree[i],
nc = 0,
npc = 0,
rc = 0
});
}
}
}
//EXPAND
if (!gsCopy.isGameOver)
{
var unexploredActions = new NativeList <int>(Allocator.Temp);
for (var i = 0; i < memory[currentHash].Length; i++)
{
if (memory[currentHash][i].nc == 0)
{
unexploredActions.Add(i);
}
}
var chosenNodeIndex = agent.rdm.NextInt(0, unexploredActions.Length);
selectedNodes.Add(new SelectedNodeInfo
{
hash = currentHash,
nodeIndex = unexploredActions[chosenNodeIndex]
});
Rules.Step(ref gsCopy, memory[currentHash][unexploredActions[chosenNodeIndex]].action, 0);
currentHash = Rules.GetHashCodeJ1(ref gsCopy);
if (!memory.ContainsKey(currentHash))
{
memory.TryAdd(currentHash, new NativeList <Node>(availableActionsFree.Length, Allocator.Temp));
for (var i = 0; i < availableActionsFree.Length; i++)
{
memory[currentHash]
.Add(new Node
{
action = availableActionsFree[i],
nc = 0,
npc = 0,
rc = 0
});
}
}
}
//SIMULATE
while (!gsCopy.isGameOver)
{
var chosenActionIndex = agent.rdm.NextInt(0, availableActionsFree.Length);
Rules.Step(ref gsCopy, chosenActionIndex, 0);
}
//BACKPROPAGATE
for (var i = 0; i < selectedNodes.Length; i++)
{
var list = memory[selectedNodes[i].hash];
var node = list[selectedNodes[i].nodeIndex];
node.rc += gsCopy.playerScore1;
node.nc += 1;
list[selectedNodes[i].nodeIndex] = node;
memory[selectedNodes[i].hash] = list;
}
for (var i = 0; i < memory[rootHash].Length; i++)
{
summedScores[i] = memory[rootHash][i].nc;
}
}
}
else if (Playerid == 1)
{
var rootHash = Rules.GetHashCodeJ2(ref gsCopy);
}
}
public int Act(ref WindjermanGameState gs, NativeList <int> availableActions)
{
//déterminer la distance entre le joueur et le frisbee au moment T
currentDistanceFromFrisbee = CalculerCurrentDistanceFromFrisbee(ref gs);
FindHighGround(ref gs);
//création de la liste des nodes
var listeNodes = new NativeList <NodeAStar>(10, Allocator.Temp);
//pour chaque action disponible
for (int i = 0; i < availableActions.Length; i++)
{
//on crée un node
NodeAStar n = new NodeAStar();
n.distanceFromFrisbee = 0;
n.playerID = this.playerID;
n.gsNode = Rules.Clone(ref gs);
//on execute ladite action pour avoir le gamestate T+1 associé
if (playerID == 0)
{
Rules.Step(ref n.gsNode, availableActions[i], 0);
}
else
{
Rules.Step(ref n.gsNode, 0, availableActions[i]);
}
//déterminer si le joueur a le frisbee à T+1
if (playerID == 0)
{
if (n.gsNode.isFreeze1)
{
n.hasFrisbee = true;
}
else
{
n.hasFrisbee = false;
}
}
else
{
if (n.gsNode.isFreeze2)
{
n.hasFrisbee = true;
}
else
{
n.hasFrisbee = false;
}
}
//déterminer la distance entre le joueur et le frisbee si celui-ci ne l'a pas en main à T+1
if (!n.hasFrisbee)
{
n.CalculerDistanceFromFrisbee();
}
//si le joueur a le frisbee, déterminer sa situation par rapport à l'autre joueur
else
{
n.FindHighGround();
}
//ajouter le node à la liste
listeNodes.Add(n);
}
//une fois les nodes créés, on détermine l'action à réaliser
int action = FindBestAction(ref listeNodes, ref gs, ref availableActions);
//listeNodes.Dispose();
return(action);
}
//Fonction pour lancer la partie via l'interface
public void StartGame(listeChoix choix1, listeChoix choix2)
{
//Initialisation des règles
Rules.Init(ref gs);
//instanciation des éléments graphiques
PlayerView1 = Instantiate(PlayerPrefab1).GetComponent <Transform>();
PlayerView2 = Instantiate(PlayerPrefab2).GetComponent <Transform>();
frisbeeView = Instantiate(FrisbeePrefab).GetComponent <Transform>();
//création des agents en fonction des choix effectués sur l'interface
switch (choix1)
{
case listeChoix.HUMAN:
agentJ1 = new HumanPlayerAgent(0);
break;
case listeChoix.RANDOM:
agentJ1 = new RandomAgent {
rdm = new Unity.Mathematics.Random((uint)UnityEngine.Random.Range(0, 100))
};
break;
case listeChoix.RANDOMROLLOUT:
agentJ1 = new RandomRolloutAgent(0);
break;
case listeChoix.DIJKSTRA:
agentJ1 = new AAgentScript(0);
break;
case listeChoix.MCTS:
Debug.Log("Agent pas implémenté");
break;
default:
Debug.Log("Agent pas implémenté");
break;
}
switch (choix2)
{
case listeChoix.HUMAN:
agentJ2 = new HumanPlayerAgent(1);
break;
case listeChoix.RANDOM:
agentJ2 = new RandomAgent
{
rdm = new Unity.Mathematics.Random((uint)UnityEngine.Random.Range(0, 100))
};
break;
case listeChoix.RANDOMROLLOUT:
agentJ2 = new RandomRolloutAgent(1);
break;
case listeChoix.DIJKSTRA:
agentJ2 = new AAgentScript(1);
break;
case listeChoix.MCTS:
Debug.Log("Agent pas implémenté");
break;
default:
Debug.Log("Agent pas implémenté");
break;
}
gameStarted = true;
StartCoroutine(TimerGame(gs.dureePartie));
}
public void Execute(int index)
{
var epochs = 10;
var agent = rdmAgent;
if (Playerid == 0)
{
for (var n = 0; n < epochs; n++)
{
var gsCopy = Rules.Clone(ref gs);
Rules.Step(ref gsCopy, availableActions[index], 0);
var currentDepth = 0;
while (!gsCopy.isGameOver)
{
var possibleChoice = Rules.GetAvailableActions1int(ref gsCopy);
switch (possibleChoice)
{
case 0:
Rules.Step(ref gsCopy, agent.Act(ref gsCopy, availableActionsFree), 0);
break;
case 1:
Rules.Step(ref gsCopy, agent.Act(ref gsCopy, availableActionsFrozen), 0);
break;
case 2:
Rules.Step(ref gsCopy, agent.Act(ref gsCopy, availableActionsStun), 0);
break;
}
currentDepth++;
if (currentDepth > 500)
{
break;
}
}
summedScores[index] += gsCopy.playerScore1;
}
}
else if (Playerid == 1)
{
for (var n = 0; n < epochs; n++)
{
var gsCopy = Rules.Clone(ref gs);
Rules.Step(ref gsCopy, 0, availableActions[index]);
var currentDepth = 0;
while (!gsCopy.isGameOver)
{
var possibleChoice = Rules.GetAvailableActions2int(ref gsCopy);
switch (possibleChoice)
{
case 0:
Rules.Step(ref gsCopy, 0, agent.Act(ref gsCopy, availableActionsFree));
break;
case 1:
Rules.Step(ref gsCopy, 0, agent.Act(ref gsCopy, availableActionsFrozen));
break;
case 2:
Rules.Step(ref gsCopy, 0, agent.Act(ref gsCopy, availableActionsStun));
break;
}
currentDepth++;
if (currentDepth > 500)
{
break;
}
}
summedScores[index] += gsCopy.playerScore2;
}
}
}
