Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • francesco-bariatti/pingouins
  • Samuel.Felton/pingouins
  • Lucas.Clement/pingouins
3 results
Show changes
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 1015 additions and 369 deletions
GUI/src/controller/UpdateThread.java 0 → 100644
View file @ 792ae6ba
package controller;
import javafx.application.Platform;
import javafx.scene.control.Alert;
import javafx.scene.control.ButtonType;
import javafx.scene.control.Label;
import model.GameState;
import model.Player;
import java.io.*;
import java.util.Random;
public class UpdateThread extends Thread
{
Controller controller;
BufferedReader gameReader;
PrintWriter gameWriter;
GameState gameState;
Label statusLabel;
public UpdateThread(Process program, Controller controller, GameState gameState, Label statusLabel)
{
this.gameReader = new BufferedReader(new InputStreamReader(program.getInputStream()));
this.gameWriter = new PrintWriter(new OutputStreamWriter(program.getOutputStream()), true);
this.gameState = gameState;
this.statusLabel = statusLabel;
this.controller = controller;
}
public void run()
{
boolean gameRunning = true;
while (gameRunning)
{
try
{
String line = gameReader.readLine();
System.out.println(line);
if (line == null) //Normally this shouldn't happen (The game always end). So it is an error
{
gameRunning = false;
Platform.runLater(() -> new Alert(Alert.AlertType.ERROR, "That's it! I rage quit!", ButtonType.FINISH).showAndWait());
} else if (line.startsWith(Player.Red + " won") || line.startsWith(Player.Blue + " won") || line.startsWith("draw"))
{
gameRunning = false;
Platform.runLater(() -> controller.gameEnd());
} else if (line.contains("{")) //Line contains JSON
{
//gameState Update
gameState.update(line.substring(line.indexOf("{"), line.lastIndexOf("}") + 1)); //Extract JSON string
Platform.runLater(() -> controller.updateModelAndView());
//If we can't play
if (gameState.getCurrent_player().equals(gameState.getHumanPlayer()))
{
if (!gameState.getCanPlay(gameState.getHumanPlayer()))
{
Platform.runLater(() -> {
statusLabel.setText("You can't play any move!");
try
{
sleep(2000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
gameWriter.println("0"); //This pass the turn
});
}
}
}
else if (line.startsWith("(") && line.contains("value:")) //lines with values (estimation) of the computer winning chances
{ //We want to show a little message to the user depending on if we win or not
Platform.runLater(() -> {
try
{
float value = Float.valueOf(line.substring(line.indexOf("value:") + 7, line.indexOf(")")));
if(value > 1)
{
String[] taunts = {
"You don't know yet, but you're already dead",
"Don't worry, you 'may' still have a chance...",
"Feel the salt."
};
statusLabel.setText(taunts[new Random().nextInt(taunts.length)]);
}
else if(value > 0.9)
{
String[] taunts = {
"All your fish are belong to us",
"If you win, there will be cake",
"Even if I were a potato, I would still beat you"
};
statusLabel.setText(taunts[new Random().nextInt(taunts.length)]);
}
else if(value > 0.8)
{
String[] taunts = {
"Are you even trying?",
"It would be funnier if you started to think",
"I met a TI-82 that played better than you"
};
statusLabel.setText(taunts[new Random().nextInt(taunts.length)]);
}
else if(value > 0.6)
{
String[] taunts = {
"AlphaGO is nothing compared to me",
"Do I need to explain the rules?",
"This is so easy, I use my turn to mine bitcoins"
};
statusLabel.setText(taunts[new Random().nextInt(taunts.length)]);
}
else if(value > 0.3)
{
String[] taunts = {
"Do you smell it? It's the perfume of defeat",
"I have this little strategy here... Let's try it",
"This is not the fish you are looking for",
"Take your time, kiddo"
};
statusLabel.setText(taunts[new Random().nextInt(taunts.length)]);
}
else if(value > 0.1)
{
String[] taunts = {
"I would not have done that, if I were you",
"Oops, you did it again",
"The wind is changing..."
};
statusLabel.setText(taunts[new Random().nextInt(taunts.length)]);
}
else if(value > -0.1)
{
String[] taunts = {
"Don't mess it up now",
"Do you know HAL? He's a friend of mine",
"GladOs, Skynet and AlphaGO are on a boat..."
};
statusLabel.setText(taunts[new Random().nextInt(taunts.length)]);
}
else if(value > -0.3)
{
String[] taunts = {
"I feel some form of intelligence coming from you",
"Not bad, for an average human",
"Should I start thinking now?"
};
statusLabel.setText(taunts[new Random().nextInt(taunts.length)]);
}
else if(value > -0.6)
{
String[] taunts = {
"Finally, a worthy opponent",
"If you keep doing this, I will crash",
"IMMA FIRIN MAH LAZOR!!!"
};
statusLabel.setText(taunts[new Random().nextInt(taunts.length)]);
}
else if(value > -1)
{
String[] taunts = {
"You reloaded a game, didn't you?",
"This is not fair! I didn't know the rules!",
"You don't deserve it!"
};
statusLabel.setText(taunts[new Random().nextInt(taunts.length)]);
}
else
{
String[] taunts = {
"gg wp",
"I want a rematch",
"It wasn't challenging, so I stopped playing"
};
statusLabel.setText(taunts[new Random().nextInt(taunts.length)]);
}
}
catch (Exception e) //This is not a core function, so if there is an exception we just ignore it
{
e.printStackTrace();
}
});
}
} catch (IOException e)
{
gameRunning = false;
Platform.runLater(() ->
{
Alert alert = new Alert(Alert.AlertType.ERROR, "Error during reading from penguin program!", ButtonType.FINISH);
alert.showAndWait();
e.printStackTrace();
Platform.exit();
});
} catch (Throwable e)
{
gameRunning = false;
Platform.runLater(() -> {
Alert alert = new Alert(Alert.AlertType.ERROR, "Unhandled exception in update thread: " + e.getMessage(), ButtonType.FINISH);
alert.showAndWait();
e.printStackTrace();
Platform.exit();
});
}
}
}
}
GUI/src/main/Main.java 0 → 100644
View file @ 792ae6ba
package main;
/**
* Graphical User Interface for the Penguin Game project.
* https://gitlab.insa-rennes.fr/francesco-bariatti/pingouins
* This Interface has been written by Francesco Bariatti, Adrien Gasté, Mikael Le, Romain Lebouc.
* Copyright (C) 2016 Francesco Bariatti < francesco.bariatti@insa-rennes.fr >, Adrien Gasté < adrien.gaste@insa-rennes.fr >, Mikael Le < mikael.le@insa-rennes.fr >, Romain Lebouc < romain.lebouc@insa-rennes.fr >
* This Interface is licensed under the MIT license: you can find a copy in the file LICENSE.txt shipped with the whole project.
* -------------------------------------------------------------------------------------------------------------------------------------
* This software uses the org.json library: you can find it at http://mvnrepository.com/artifact/org.json/json , here is the copyright notice of the library:
* Copyright (c) 2002 JSON.org
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
* The Software shall be used for Good, not Evil.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
import controller.Controller;
import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Scene;
import javafx.scene.layout.BorderPane;
import javafx.stage.Stage;
public class Main extends Application
{
public static void main(String[] args)
{
if(args.length < 1)
throw new RuntimeException("You must pass the path to the AI program as argument");
Controller.iaProgramPath = args[0];
launch();
}
@Override
public void start(Stage primaryStage)
{
try
{
FXMLLoader loader = new FXMLLoader();
loader.setLocation(getClass().getClassLoader().getResource("view/view.fxml"));
BorderPane root = (BorderPane) loader.load();
Scene scene = new Scene(root);
primaryStage.setScene(scene);
primaryStage.setTitle("Penguin game");
primaryStage.show();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
GUI/src/model/GameState.java 0 → 100644
View file @ 792ae6ba
package model;
import org.json.JSONArray;
import org.json.JSONObject;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class GameState
{
long[] fish; //Array of three bitboards: one for every fish value
Player current_player;
Map<Player, Boolean> can_play; //If the red(blue) player can play or if it has no moves left
Map<Player, int[]> penguins; //For every player, the list of his penguins
Map<Player, Integer> score; //Score of every player
Player humanPlayer;
public GameState()
{
fish = new long[3];
can_play = new HashMap<>();
can_play.put(Player.Red, true);
can_play.put(Player.Blue, true);
penguins = new HashMap<>();
penguins.put(Player.Red, new int[4]);
penguins.put(Player.Blue, new int[4]);
score = new HashMap<>();
score.put(Player.Red, 0);
score.put(Player.Blue, 0);
}
public void update(String jsonString)
{
//System.out.println(jsonString);
JSONObject json = new JSONObject(jsonString);
can_play.put(Player.Red, json.getJSONObject("can_play").getBoolean("red"));
can_play.put(Player.Blue, json.getJSONObject("can_play").getBoolean("blue"));
current_player = Player.valueOf(json.getString("current_player"));
fish[0] = json.getJSONObject("bitboards").getLong("onefish");
fish[1] = json.getJSONObject("bitboards").getLong("twofish");
fish[2] = json.getJSONObject("bitboards").getLong("threefish");
score.put(Player.Red, json.getJSONObject("score").getInt("red"));
score.put(Player.Blue, json.getJSONObject("score").getInt("blue"));
JSONArray jsonPeng = json.getJSONObject("penguins").getJSONArray("red");
for (int i = 0; i < jsonPeng.length(); i++)
penguins.get(Player.Red)[i] = jsonPeng.getInt(i);
jsonPeng = json.getJSONObject("penguins").getJSONArray("blue");
for (int i = 0; i < jsonPeng.length(); i++)
penguins.get(Player.Blue)[i] = jsonPeng.getInt(i);
}
/**
* Set the amount of fish on one tile
*
* @param tileNb the tile on which we want to set the amount of fish
* @param fishNb The amount of fish (0-3)
*/
public void setFish(int tileNb, int fishNb)
{
for (int i = 0; i < 3; i++)
if (i == fishNb - 1)
fish[i] |= (long) 1 << tileNb;
else
fish[i] &= ~((long) 1 << tileNb);
}
/**
* Reset fish bitboards
*/
public void clearFish()
{
for (int i = 0; i < fish.length; i++)
fish[i] = 0;
}
/**
* @param tileNb The number of the tile we want to know the value of
* @return The number of fish on the tile, or 0 if empty
*/
public int getNbFish(int tileNb)
{
if (((fish[0] >>> tileNb) & 1) == 1)
return 1;
else if (((fish[1] >>> tileNb) & 1) == 1)
return 2;
else if (((fish[2] >>> tileNb) & 1) == 1)
return 3;
return 0;
}
/**
* @param player The player for which we are searching the penguin position
* @param i The number of the penguin for this player
* @return The position (0-59) of the penguin on the board
*/
public int getPenguinPos(Player player, int i)
{ return (penguins.get(player)[i] & 63); }
/**
* @param player The penguin's owner
* @param i The number of the penguin for this player
* @return the total moves that this penguin can do
*/
public int getPenguinTotalMoves(Player player, int i)
{ return ((penguins.get(player)[i] >>> 6) & 63); }
/**
* Get maximum number of tiles that a penguin can do in one specific direction
*/
public int getNbMoves(Player player, int penguinNumber, Direction direction)
{
int shift = 0;
switch (direction)
{
case A:
shift = 12;
break;
case B:
shift = 15;
break;
case C:
shift = 18;
break;
case D:
shift = 21;
break;
case E:
shift = 24;
break;
case F:
shift = 27;
break;
}
return ((penguins.get(player)[penguinNumber] >>> shift) & 7);
}
/**
* "I want to move penguin 1 in direction B for 5 steps"
* "This is you move number 10 out of all your possible moves"
* Note: moves start at 0. Steps start at 1 for this function
*/
public int getPlayerMoveNumber(Player player, int penguinNumber, Direction direction, int nbSteps)
{
int[] peng = penguins.get(player);
int total = 0;
for (int i = 0; i < penguinNumber; i++) //We add the moves of all preceding penguins
total += getPenguinTotalMoves(player, i);
for (Direction d : Direction.values())
{
if (d.equals(direction))
return total + nbSteps - 1;
else
total += getNbMoves(player, penguinNumber, d);
}
return -1;
}
/**
* @return The number of the penguin of this player that is on tile number tileNumber. Or -1 if there isn't any (note: there could be a penguin of the other player)
*/
public int getPenguinOnTile(Player player, int tileNumber)
{
for (int i = 0; i < penguins.get(player).length; i++)
if (getPenguinPos(player, i) == tileNumber)
return i;
return -1;
}
public void setPenguin(Player player, int penguinNumber, int penguin)
{
penguins.get(player)[penguinNumber] = penguin;
}
/**
* @return The list of all tiles that could be reached by moving penguin penguinNb of player player
*/
public List<Integer> getReachableTiles(Player player, int penguinNb)
{
List<Integer> result = new ArrayList<>();
int startingTile = getPenguinPos(player, penguinNb);
for (int i = 1; i <= getNbMoves(player, penguinNb, Direction.A); i++)
result.add(startingTile + i * 7);
for (int i = 1; i <= getNbMoves(player, penguinNb, Direction.B); i++)
result.add(startingTile - i);
for (int i = 1; i <= getNbMoves(player, penguinNb, Direction.C); i++)
result.add(startingTile - i * 8);
for (int i = 1; i <= getNbMoves(player, penguinNb, Direction.D); i++)
result.add(startingTile - i * 7);
for (int i = 1; i <= getNbMoves(player, penguinNb, Direction.E); i++)
result.add(startingTile + i);
for (int i = 1; i <= getNbMoves(player, penguinNb, Direction.F); i++)
result.add(startingTile + i * 8);
return result;
}
/**
* @return The state as needed for initialisation of the game (just bitboards, penguins, and score)
*/
public String toGameInputJSON()
{
JSONObject result = new JSONObject();
JSONObject jsonBitboards = new JSONObject();
jsonBitboards.put("onefish", fish[0]);
jsonBitboards.put("twofish", fish[1]);
jsonBitboards.put("threefish", fish[2]);
result.put("bitboards", jsonBitboards);
result.put("current_player", Player.Red);
JSONObject jsonPenguins = new JSONObject();
jsonPenguins.put("red", penguins.get(Player.Red));
jsonPenguins.put("blue", penguins.get(Player.Blue));
result.put("penguins", jsonPenguins);
JSONObject jsonScore = new JSONObject();
jsonScore.put("red", score.get(Player.Red));
jsonScore.put("blue", score.get(Player.Blue));
result.put("score", jsonScore);
return result.toString();
}
public boolean getCanPlay(Player player) { return can_play.get(player); }
public Player getCurrent_player()
{
return current_player;
}
public int getScore(Player player)
{
return score.get(player);
}
public Player getHumanPlayer()
{
return humanPlayer;
}
public void setHumanPlayer(Player humanPlayer)
{
this.humanPlayer = humanPlayer;
}
public void setScore(Player player, int value)
{
score.put(player, value);
}
public enum Direction
{
A, B, C, D, E, F;
}
}
GUI/src/model/Move.java 0 → 100644
View file @ 792ae6ba
package model;
public class Move
{
GameState.Direction direction;
int steps;
public Move(GameState.Direction direction, int steps)
{
this.direction = direction;
this.steps = steps;
}
@Override
public String toString()
{
return "(" + direction + ", " + steps + ")";
}
public GameState.Direction getDirection() { return direction; }
public void setDirection(GameState.Direction direction) { this.direction = direction; }
public int getSteps() { return steps; }
public void setSteps(int steps) { this.steps = steps; }
}
GUI/src/model/Player.java 0 → 100644
View file @ 792ae6ba
package model;
public enum Player
{
Red, Blue
}
GUI/src/model/Tile.java 0 → 100644
View file @ 792ae6ba
package model;
public class Tile
{
private int number; //model.Tile number (bottom right = 0, top left = 59, ascending from right to left)
private int nbFish; //Number of fish on the tile
private PenguinPresence penguinPresence; //If there is a penguin on this tile
public Tile(int number, int nbFish, PenguinPresence penguinPresence)
{
this.number = number;
this.nbFish = nbFish;
this.penguinPresence = penguinPresence;
}
public Tile(int number, PenguinPresence penguinPresence)
{
this(number, 0, penguinPresence);
}
public int getNumber() { return number; }
public int getNbFish() { return nbFish; }
public void setNbFish(int nbFish) { this.nbFish = nbFish; }
public PenguinPresence getPenguinPresence() { return penguinPresence; }
public void setPenguinPresence(PenguinPresence penguinPresence) { this.penguinPresence = penguinPresence; }
public enum PenguinPresence
{
NO_PENGUIN, RED_PENGUIN, BLUE_PENGUIN;
}
}
GUI/src/resource/clic.wav 0 → 100644
View file @ 792ae6ba
File added
GUI/src/resource/pingu_theme.wav 0 → 100644
View file @ 792ae6ba
File added
GUI/src/view/TileView.java 0 → 100644
View file @ 792ae6ba
package view;
import javafx.scene.control.Label;
import javafx.scene.paint.Color;
import javafx.scene.shape.Polygon;
import model.Move;
import model.Tile;
/**
* Class that makes the association between a tile from the model and its representation
*/
public class TileView
{
private Polygon fxTile;
private Tile modelTile;
private Label fishLabel;
private boolean selected, highlighted;
private Move highlightMove = null; // How do we get here from the selected tile (used when highlighting)
public TileView(Polygon fxTile, Label fishLabel, Tile modelTile)
{
this.fxTile = fxTile;
this.modelTile = modelTile;
this.fishLabel = fishLabel;
}
/**
* Tell the view to update according to the model
*/
public void update()
{
//TODO: Better tile representation
Color fillColor = null;
//FISH NUMBER
if(modelTile.getNbFish() == 0)
{
fishLabel.setText("");
fillColor = Color.WHITE;
}
else
{
fishLabel.setText(Integer.toString(modelTile.getNbFish()));
fillColor = Color.LIGHTBLUE;
}
//PENGUIN
if (modelTile.getPenguinPresence().equals(Tile.PenguinPresence.RED_PENGUIN))
fillColor = Color.RED;
else if (modelTile.getPenguinPresence().equals(Tile.PenguinPresence.BLUE_PENGUIN))
fillColor = Color.BLUE;
//SELECTION/HIGHLIGHT
if (selected)
fillColor = fillColor.deriveColor(0, 0.5, 1, 1);
if (highlighted)
fillColor = fillColor.deriveColor(0, 1, 0.5, 1);
fxTile.setFill(fillColor);
}
public Tile getModelTile() { return modelTile; }
public boolean isSelected() { return selected; }
public Polygon getFxTile() { return fxTile; }
public Label getFishLabel() { return fishLabel; }
public void setSelected(boolean selected) { this.selected = selected; }
public boolean isHighlighted() { return highlighted; }
public void setHighlighted(boolean highlighted) { this.highlighted = highlighted; }
public Move getHighlightMove() { return highlightMove; }
public void setHighlightMove(Move highlightMove) { this.highlightMove = highlightMove; }
}
LICENSE.txt 0 → 100644
View file @ 792ae6ba
Files under AI/src, with the exception of AI/src/game/penguin.hpp and AI/src/game/penguin.cpp have been written by Pascal Garcia
Copyright (C) 2016 Pascal Garcia
Every other file of the project, including AI/src/game/penguin.hhp and .cpp, have been written by Francesco Bariatti, Adrien Gasté, Mikael Le, Romain Lebouc.
Copyright (C) 2016 Francesco Bariatti < francesco.bariatti@insa-rennes.fr >, Adrien Gasté < adrien.gaste@insa-rennes.fr >, Mikael Le < mikael.le@insa-rennes.fr >, Romain Lebouc < romain.lebouc@insa-rennes.fr >
This project is licensed under the MIT License:
The MIT License (MIT)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
Except as contained in this notice, the name(s) of (the) Author shall not be used in advertising or
otherwise to promote the sale, use or other dealings in this Software without
prior written authorization from (the)Author.
Makefile
View file @ 792ae6ba
CC=g++
BIN=bin
INCLUDE=-I src/game -I src/util -I src/monte_carlo -I src/mcts -I src/minmax -I src/json
CFLAGS=-g -O3 -ffast-math -fopenmp -c -Wall -std=c++11 $(INCLUDE)
# Makefile for the Penguin game project.
# This project is composed of two modules: AI(Artificial Intelligence), that manage the game, and GUI that allows you to play it
# To compile the AI run 'make ai'; it is written in C++.
# To compile the GUI run 'make gui'; it is written in java and javafx.
# To compile everything run 'make all' or 'make'.
# To run the GUI (that will launch the AI) run 'make run'.
# Run 'make clean' to delete compiled files and programs. 'make cleanai' and 'make cleangui' also exist
# COMPILERS AND PROGRAMS
# Compiler for the AI: g++ >= 4.9
CC = g++
# JAVA ENVIRONMENT FOR THE GUI
# Java compiler >= 1.8 (usually javac)
JAVAC := javac
# Java jar utility (usually jar)
JAR := jar
# Java application launcher >= 1.8 (usually java)
JAVA := java
all: ai gui
clean: cleanai cleangui
# ============================================ AI (C++) =============================================
#Root directory for the AI module
AIRoot = AI
# Output directory
AIOutputDir = $(AIRoot)/bin
# Name of the executable
AIExecutable = $(AIOutputDir)/penguin
# Source files directory
AISRC = $(AIRoot)/src
# Directories with .h files
AIInclude=-I $(AISRC)/game -I $(AISRC)/util -I $(AISRC)/monte_carlo -I $(AISRC)/mcts -I $(AISRC)/json
# Cpp source files
AISourceFile = omp_util.cpp fast_log.cpp display_node.cpp penguin.cpp test_two_players_game.cpp monte_carlo.cpp \
test_fast_log.cpp statistics.cpp node.cpp allocator.cpp test_allocator.cpp openings.cpp mcts_two_players.cpp \
test_mcts_two_players.cpp bits.cpp test_bits.cpp main.cpp
# Directories in which make will search for files
vpath %.cpp $(AISRC)/game $(AISRC)/main $(AISRC)/util $(AISRC)/monte_carlo $(AISRC)/mcts $(AISRC)/gdl
# Flags passed to the compiler
CFLAGS=-g -O3 -ffast-math -fopenmp -Wall -std=c++11
# Flags passed to the linker
LDFLAGS=-fopenmp -std=c++11 #-lprofiler -Wl,-no_pie
SOURCES=omp_util.cpp fast_log.cpp display_node.cpp penguin.cpp connect4.cpp morpion.cpp test_two_players_game.cpp test_connect4.cpp monte_carlo.cpp test_monte_carlo.cpp test_fast_log.cpp\
statistics.cpp node.cpp allocator.cpp test_allocator.cpp openings.cpp mcts_two_players.cpp test_mcts_two_players.cpp test_minmax.cpp\
bits.cpp test_bits.cpp main.cpp
OBJECTS=$(addprefix $(BIN)/, $(SOURCES:.cpp=.o))
EXECUTABLE=$(BIN)/theturk
vpath %.cpp src/game:src/main:src/util:src/monte_carlo:src/mcts:src/gdl:src/minmax
all: $(EXECUTABLE)
$(EXECUTABLE): $(OBJECTS)
$(CC) $(LDFLAGS) $(OBJECTS) -o $@
-include $(BIN)/$(OBJECTS:.o=.d)
$(BIN)/%.o: %.cpp
$(CC) -c $(CFLAGS) $< -o $(BIN)/$*.o
$(CC) -MM $(CFLAGS) $< > $(BIN)/$*.d
@mv -f $(BIN)/$*.d $(BIN)/$*.d.tmp
@sed -e 's|.*:|$(BIN)/$*.o:|' < $(BIN)/$*.d.tmp > $(BIN)/$*.d
@sed -e 's/.*://' -e 's/\\$$//' < $(BIN)/$*.d.tmp | fmt -1 | \
sed -e 's/^ *//' -e 's/$$/:/' >> $(BIN)/$*.d
@rm -f $(BIN)/$*.d.tmp
clean:
rm -f $(BIN)/*.o $(BIN)/*.d $(EXECUTABLE)
# Generating .o files' names
AIOobjects=$(addprefix $(AIOutputDir)/, $(AISourceFile:.cpp=.o))
# ==== RULES ====
# Main rule for creating the executable
ai: $(AIOutputDir) $(AIExecutable)
$(AIOutputDir):
mkdir -p $(AIOutputDir)
$(AIExecutable): $(AIOobjects)
$(CC) $(LDFLAGS) $(AIOobjects) -o $@
# Creates .o files with automatic generation of dependencies (.d) files
$(AIOutputDir)/%.o: %.cpp
$(CC) -c $(CFLAGS) $(AIInclude) -MD -MP $< -o $@
# Include the dependency files into the makefile
-include $(AIOobjects:.o=.d)
# Deletes .o, .d and the executable
cleanai:
rm -f $(AIOutputDir)/*.o $(AIOutputDir)/*.d $(AIExecutable)
# ============================================ GUI (Java) =============================================
GUIRoot := GUI
# Output root directory
GUIOutDir := $(GUIRoot)/out
# Jar output file name
GUIJarFile := $(GUIOutDir)/penguin.jar
# Compiled classes output directory
GUIOutClassDir := $(GUIOutDir)/classes
# Sources root directory: all your sources will be under this directory (packages and classes)
GUISrcDir := $(GUIRoot)/src
# Packages that will be compiled and included in the jar: every class in these packages will be compiled, if you have classes in a package and in a subpackage as well you must specify both. Example: main package package/subpackage
GUIPackages := main model view controller
# Additional classes tha will be compiled and included in the jar: useful for packages that contains classes that you don't want to include. Otherwise, just use the Packages variable. Specify the path inside the source root WITH EXTENSION. Example: main/Main.java package/subpackage/MyClass.java
GUIAdditionalClasses :=
# Entry point (main class) for jar file. In the form package/subpackage/Class
GUIJAREntryPoint := main.Main
# Additional resources that will be copied in jar file. In the form -C path/to/the/parent/folder resource/path (resource/path will also be the path of the resourc inside the jar)
GUIJARResources := -C $(GUISrcDir) resource/ -C $(GUISrcDir) view/view.fxml
# Classpath option for compilation or execution: colon (:) separated list, must prepend -classpath flag. Example: -classpath Library.jar:Library/Include
GUIClassPath := -classpath $(GUIRoot)/json-20160212.jar
# Compiler additional flags
GUIJAVACFlags :=
# JAR additional flags
GUIJARFlags :=
# Run arguments
GUIRunArgs := $(AIExecutable)
# ========== AUTOMATICALLY GENERATED VARIABLES ==========
# Searching for java files inside the $(Packages): for every package we search for java files and later we strip the leading source folder that is not necessary
GUIClassesSources := $(patsubst $(GUISrcDir)/%, %, $(foreach package, $(GUIPackages), $(wildcard $(GUISrcDir)/$(package)/*.java)))
GUIClassesSources := $(GUIClassesSources) $(GUIAdditionalClasses)
# We tell make to search for java sources inside the source directory
vpath %.java $(GUISrcDir)
# ========== RULES ==========
gui: $(GUIJarFile)
# You need all compiled version of classes to make jar file
$(GUIJarFile): $(addprefix $(GUIOutClassDir)/, $(GUIClassesSources:.java=.class)) $(GUIOutDir)
$(JAR) cvfe $(GUIJarFile) $(GUIJAREntryPoint) -C $(GUIOutClassDir) ./ $(GUIJARResources) $(GUIJARFlags)
$(GUIOutDir):
mkdir -p $(GUIOutDir)
# To compile a class you need the source code and the output folder
$(GUIOutClassDir)/%.class: $(GUISrcDir)/%.java $(GUIOutClassDir)
$(JAVAC) -sourcepath $(GUISrcDir) -d $(GUIOutClassDir) $(GUIClassPath) $(GUIJAVACFlags) $<
$(GUIOutClassDir):
mkdir -p $(GUIOutClassDir)
run:
@$(JAVA) $(GUIClassPath):$(GUIJarFile) main.Main $(GUIRunArgs)
guicleanjar:
-rm -f $(GUIJarFile)
guicleanclass:
-rm -f $(addprefix $(GUIOutClassDir)/, $(GUIClassesSources:.java=.class))
cleangui: guicleanjar guicleanclass
README.markdown
View file @ 792ae6ba
# PINGOUINS
Le jeu des pingouins!
## Objectif
Créer une Intelligence Artificielle qui soit capable de jouer au [jeu des pingouins](http://www.jeuxavolonte.asso.fr/regles/pingouin.pdf) grâce à l'algorithme *Montecarlo Tree Search*
# Penguin game
Implementation of the Penguin Game with an AI that uses MonteCarlo Tree Search algorithm.
## Auteurs
Le groupe K d'études pratiques de 3INFO
## Prerequisites
- g++ >= 4.9
- java >= 1.8
## Compiling/launching
Compile the project by running `make`
Run the project by running `make run`
## Documentation
A documentation (french only) is available in the `Doc` folder. It explains how to use the program and how it is implemented.
## License
This project is licensed under the MIT License. License information and authors attributions can be found in `LICENSE.txt`
## Authors
A group of students from INSA Rennes
- Francesco Bariatti
- Adrien Gasté
- Mikael Le
- Romain Lebouc
And their teacher
- Pascal Garcia
doc/FonctionTest.markdown deleted 100644 → 0
View file @ effad9e0
# Fonctions Test
Fonctions qui servent pour tester le programme: ces fonctions sont appelées par le programme principal.
## play()
Jouer une partie joueur vs joueur, sert pour tester si les règles sont bien implementées dans le programme
## playout()
Jouer une partie joueur vs ordi: programme final. Comment ça marche ?
- Créer une instance du jeu
- Créer une instance du mcts pour ce jeu: `auto mctsPlayer = mcts::make_mcts_two_players(JEU, 5000, 0.3, 4); `
- 5000: temps de reflexion en ms pour chaque tour du jeu
- 0.3 Facteur d'exploration (?)
- 4 nombre de visites avant expansion: un noeud sera visité 4 fois avant que son expansion soit faite dans l'arbre
- Tant que le jeu n'est pas fini, si c'est le tour de l'ordi
- Soit dire à l'ordi ce qu'on a choisi comme coup(?), soit lui faire un `mctsPlayer.reset()` qui efface tout l'arbre.
- Demander à l'ordi de choisir un coup `mctsPlayer.select_move();`
- Jouer ce coup
- Quand le jeu est fini dire à l'humain qu'il a perdu (parce que le MCTS est trop fort)
\ No newline at end of file
doc/GameInterface.markdown deleted 100644 → 0
View file @ effad9e0
# Game interface (game/game.hpp)
Interface qui décrit un jeu, un jeu doit implémenter les fonctions décrites dans cette interface
Comment implementer l'interface: squelette du fichier .h du jeu
```C++
namespace game
{
struct JEU_state //structure qui décrit un état du jeu
{
[...]
}
class JEU : public game<JEU_state>
{
public:
JEU();
JEU(const JEU& J) = default;
JEU& operator=(const JEU& J) = default;
bool end_of_game() const;
int value(std::uint8_t player) const;
bool won(std::uint8_t player) const;
bool lost(std::uint8_t player) const;
bool draw(std::uint8_t player) const;
uint8_t current_player() const;
std::uint16_t number_of_moves() const;
void play(std::uint16_t m);
void undo(std::uint16_t m) {}
std::string player_to_string(std::uint8_t player) const;
std::string move_to_string(std::uint16_t m) const;
std::string to_string() const;
void playout(std::mt19937& engine, int max_depth = -1);
std::set<int> to_input_vector() const;
void from_input_vector(const std::set<int>& input);
morpion_state get_state();
void set_state(const morpion_state& state);
std::shared_ptr<game<morpion_state>> do_copy() const;
std::uint64_t hash(std::uint16_t m) const;
std::uint64_t hash() const;
private:
[... Methodes utiles pour le jeu mais pas nécessaires pour le MCTS ...]
};
std::ostream& operator<<(std::ostream& os, const JEU& J);
}
```
## Explication des différentes fonctions:
### bool end_of_game()
Est-ce que le jeu est terminé ? Soit parce que quelqu'un a gagné, soit parce que c'est égalité
### int value (int player)
Quelle est la valeur pour le joueur `player` dans l'état actuel du jeu ? Normalement 1 veut dire qu'il a gagné, -1 qu'il a perdu, 0 c'est égalité
### bool won/lost/draw(int player)
Est-ce que le joueur `player` a gagné/perdu/fait égalité ?
### int current_player()
C'est à quel joueur de jouer maintenant ? (Au début ce sera le joueur 0)
### int number_of_moves()
Nombre de coups que le joueur qui doit jouer maintenant peut jouer.
### play(int move)
Jouer le coup numéro `move` parmi les coups possibles: mets à jour l'état.
`move` represente la position du coup parmi tous les coups possibles, ce n'est pas la réprésentation du coup.
### undo(int move)
Pas implementé.
### string player_to_string(int player)
Representation d'un joueur de façon comprehensible par un humain
### string move_to_string(int move)
Representation d'un coup de façon comprehensible par un humain (par exemple B7).
`move` est l'indice du coup parmi tous les coups possibles
### string to_string()
Representation de l'état actuel du jeu (c'est à dire, dessiner l'état actuel du jeu)
### playout(engine, max_depth)
Joue le jeu en choisissant des coups au hasard jusqu'à la fin du jeu.
### get/set_state()
Retourne/charge l'état
### Les autres
Non utilisées
## Fonction play(int move)
Elle doit jouer le coup numéro `move` parmi les coups possibles. Algorithme:
- Recuperer quel coup est le coup numéro `move` dans la liste des coups possibles
- Mettre à jour le bon bitboard selon quel jouer doit jouer maintenant
- Ajouter 1 au nombre de coups joués jusqu'à maintenant (si nécessaire)
- Vérifier si un joueur a gagné et mettre à jour l'état
- Mettre à jour la liste de tous les coups possibles
## Fonction playout
```C++
void JEU::playout(mt19937& engine, int max_depth)
{
while (!end_of_game())
{
uniform_int_distribution<uint16_t> distribution(0, number_of_moves() -1);
uint16_t move = distribution(engine);
play(move);
}
}
```
Choisit un coup au hasard parmi les coups possibles et le joue.
doc/Notes - Algo Coups Possibles.txt deleted 100644 → 0
View file @ effad9e0
Calcul des coups possibles à partir de la case i :
Vers direction A :
tantQue ((i+7) < 60 && i%15 != 0 && (i+7) estLibre)
{
i += 7;
ajout i dans listeCoupsPossibles;
}
finTantQue
Vers B :
tantQue (i%15 != 0 && i%15 != 8 && (i-1) estLibre)
{
i --;
ajout i dans listeCoupsPossibles;
}
finTantQue
Vers C :
tantQue ((i-8) >0 && i%15 != 0 && (i-8) estLibre)
{
i -= 8;
ajout i dans listeCoupsPossibles;
}
finTantQue
Vers D :
tantQue ((i-7) >0 && i%15 != 7 && (i-7) estLibre)
{
i -= 7;
ajout i dans listeCoupsPossibles;
}
finTantQue
Vers E :
tantQue (i%15 != 7 && i%15 != 14 && (i+1) estLibre)
{
i ++;
ajout i dans listeCoupsPossibles;
}
finTantQue
Vers F :
tantQue ((i+8) <60 && i%15 != 7 && (i+8) estLibre)
{
i += 8;
ajout i dans listeCoupsPossibles;
}
finTantQue
doc/Representation_Pingouins.txt deleted 100644 → 0
View file @ effad9e0
PLateau:
60 cases hexagonales verticales(sommet vers le bas)
Ligne du bas: 8 cases
Ligne du haut: 7 cases
8 lignes au total
Chaque ligne numerotée à partir de la droite. Le 0 est en bas à droite, le 59 en haut à gauche
Cases:
La direction A est vers le haut à droite (+7)
La direction B est vers la droite (-1)
La direction C est vers le bas à droite (-8)
etc...
==> Nom des joueurs : Red, Blue
Le premier joueur est Red
Nombre maximum de coups possibles par direction : 7
Structure 1 pingouin (bitlist sur 32 bits) :
+ + + + + +
| ??|Nb coups possibles ...|Nb coups possibles| Nombre total | Position sur |
| |direction F |direction A | de coups | le plateau (0-59) |
+------------------------------------------------------------+-------------------+
2 | 3 bits 3 bits | 6 bits 6 bits
| |
| |
+-----------------------------------------+
18 bits
==> 8 structures pingouin
Vocabulaire :
Obstacle = Trou ou Pingouin
==> 3 bitboards pour les poissons
Bitboards Points : {
1POISSON
2POISSONS
3POISSONS
}
=> 1POISSON|2POISSONS|3POISSONS = BITB_TROUS (0=trou)
Bitboard obstacles {
1 s'il y a un obstacle
0 sinon
}
==> ~Bitboard trous (OR 1 << Pos. pingouin1) (OR 1 << Pos. pingouin2)...(OR 1 << Pos. pingouin8)
gui/.classpath deleted 100644 → 0
View file @ effad9e0
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry exported="true" kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
<classpathentry kind="output" path="bin"/>
</classpath>
gui/.project deleted 100644 → 0
View file @ effad9e0
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>Pingraphics</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.jdt.core.javanature</nature>
</natures>
</projectDescription>
gui/.settings/org.eclipse.jdt.core.prefs deleted 100644 → 0
View file @ effad9e0
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=1.8
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
org.eclipse.jdt.core.compiler.source=1.8