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
Hide whitespace changes
Inline Side-by-side
Showing
with 465 additions and 258 deletions
AI/src/mcts/MCTS_SETTINGS.hpp
View file @ b8a621a7
#ifndef __MCTS_SETTINGS_HPP__
#define __MCTS_SETTINGS_HPP__
// Allocated memory for the mcts. If not enough the program may crash
#define MCTS_ALLOCATOR_SIZE 1000000U
#define MCTS_ALLOCATOR_SIZE 80000000U
// Reflection time for every turn of the mcts (in ms)
#define MCTS_TURN_TIME 5000
......
AI/src/mcts/mcts_two_players.hpp
View file @ b8a621a7
......@@ -9,60 +9,68 @@
#include <fstream>
#include <vector>
#include "openings.hpp"
#include "heuristic.hpp"
namespace mcts
{
template <typename Game>
class mcts_two_players : public mcts<Game>
{
template <typename Game>
class mcts_two_players : public mcts<Game>
{
allocator alloc_;
const util::fast_log fast_log_;
const float C_;
const unsigned int nb_visits_before_expansion_;
const heuristic<Game>& heuristic_;
const bool new_version_;
inline node* select(const std::shared_ptr<Game>& game, std::mt19937& generator, node* parent);
inline void expand(const std::shared_ptr<Game>& game, node* n);
void think(const std::shared_ptr<Game>& game);
public:
mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion = 8, bool new_version = true);
public:
mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion = 8,
const heuristic<Game>& heuristic = zero_knowledge<Game>(), bool new_version = true);
void reset();
void init_with_openings(const openings& o);
inline uint16_t select_move();
void last_move(uint16_t move);
void last_moves(uint16_t computer, uint16_t other);
};
};
template <typename Game>
mcts_two_players<Game> make_mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion = 8, bool new_version = true)
{
return mcts_two_players<Game>(game, milliseconds, C, nb_visits_before_expansion, new_version);
}
template <typename Game>
mcts_two_players<Game> make_mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion = 8,
const heuristic<Game>& heuristic = zero_knowledge<Game>(),
bool new_version = true)
{
return mcts_two_players<Game>(game, milliseconds, C, nb_visits_before_expansion, heuristic, new_version);
}
template <typename Game>
mcts_two_players<Game>::mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion, bool new_version)
: mcts<Game>(game, milliseconds), C_(C), nb_visits_before_expansion_(nb_visits_before_expansion), new_version_(new_version)
{
template <typename Game>
mcts_two_players<Game>::mcts_two_players(Game& game, uint32_t milliseconds, float C, unsigned int nb_visits_before_expansion,
const heuristic<Game>& heuristic,
bool new_version)
: mcts<Game>(game, milliseconds), C_(C), nb_visits_before_expansion_(nb_visits_before_expansion),
heuristic_(heuristic), new_version_(new_version)
{
this->generators.assign(util::omp_util::get_num_threads(), std::mt19937());
this->root = alloc_.allocate(1);
}
}
template <typename Game>
void mcts_two_players<Game>::reset()
{
template <typename Game>
void mcts_two_players<Game>::reset()
{
alloc_.clear();
this->root = alloc_.allocate(1);
}
}
template <typename Game>
void mcts_two_players<Game>::init_with_openings(const openings& o)
{
template <typename Game>
void mcts_two_players<Game>::init_with_openings(const openings& o)
{
o.copy_to(this->root, alloc_);
}
}
template <typename Game>
node* mcts_two_players<Game>::select(const std::shared_ptr<Game>& game, std::mt19937& generator, node* parent)
{
template <typename Game>
node* mcts_two_players<Game>::select(const std::shared_ptr<Game>& game, std::mt19937& generator, node* parent)
{
using namespace std;
const unsigned int N = parent->get_statistics().count;
const float log_of_N = fast_log_.log(N);
......@@ -76,63 +84,63 @@ namespace mcts
unsigned int count;
float v;
for (uint16_t i = 0; i < nb_children; ++i)
{
{
node* child = children + k;
count = child->get_statistics().count;
v = -child->get_statistics().value + C_ * sqrt(log_of_N / count);
if (v > best_value_so_far)
{
{
best_value_so_far = v;
best_child_so_far = child;
best_move_so_far = k;
}
}
++k;
if (k == nb_children) k = 0;
}
}
if (best_child_so_far->is_proven())
{
{
if (best_child_so_far->is_lost()) parent->set_won();
else
{
{
bool all_won = true;
for (uint16_t i = 0; i < nb_children; ++i)
{
{
node* child = children + i;
if (!child->is_won())
{
{
all_won = false;
break;
}
}
}
}
if (all_won) parent->set_lost();
}
}
}
}
game->play(best_move_so_far);
return best_child_so_far;
}
}
template <typename Game>
void mcts_two_players<Game>::expand(const std::shared_ptr<Game>& game, node* n)
{
template <typename Game>
void mcts_two_players<Game>::expand(const std::shared_ptr<Game>& game, node* n)
{
unsigned int count = n->get_statistics().count;
if (count >= nb_visits_before_expansion_ && !n->test_and_set())
{
{
unsigned int nb_children = game->number_of_moves();
node* children = alloc_.allocate(nb_children);
for (unsigned int i = 0; i < nb_children; ++i)
{
{
node* child = children + i;
child->get_statistics_ref().count = 1;
child->get_statistics_ref().value = 0;
}
child->get_statistics_ref().count = heuristic_.get_count(*game, i);
child->get_statistics_ref().value = heuristic_.get_value(*game, i);
}
n->set_children(children);
n->set_number_of_children(nb_children);
}
}
}
}
template <typename Game>
void mcts_two_players<Game>::think(const std::shared_ptr<Game>& game)
{
template <typename Game>
void mcts_two_players<Game>::think(const std::shared_ptr<Game>& game)
{
using namespace std;
const chrono::steady_clock::time_point start = chrono::steady_clock::now();
chrono::steady_clock::time_point now;
......@@ -142,72 +150,72 @@ namespace mcts
vector<uint16_t> moves(200);
unsigned int nb_iter = 0;
do
{
{
int size = 1;
node* current = this->root;
visited[0] = current;
while (!game->end_of_game() && !current->is_leaf() && !current->is_proven())
{
{
current = select(game, generator, current);
visited[size++] = current;
}
}
int game_value = 0;
if (current->is_proven())
{
{
if (current->is_won()) game_value = 1;
else
{
{
game_value = -1;
}
}
}
}
else if (game->end_of_game())
{
{
int v = game->value_for_current_player();
if (v > 0)
{
{
game_value = 1;
if (new_version_) current->set_won();
}
}
else if (v < 0)
{
{
game_value = -1;
if (new_version_)
{
{
current->set_lost();
if (size > 1) visited[size - 2]->set_won();
}
}
}
}
}
}
else
{
{
uint8_t player = game->current_player();
expand(game, current);
game->playout(generator);
int v = game->value(player);
if (v > 0) game_value = 1;
else if (v < 0) game_value = -1;
}
}
for (int i = size - 1; i >= 0; --i)
{
{
visited[i]->update(game_value);
game_value = -game_value;
}
}
game->set_state(state);
++nb_iter;
if ((nb_iter & 0x3F) == 0) now = chrono::steady_clock::now();
}
}
while ((nb_iter & 0x3F) != 0 || now < start + this->milliseconds);
}
}
template <typename Game>
uint16_t mcts_two_players<Game>::select_move()
{
template <typename Game>
uint16_t mcts_two_players<Game>::select_move()
{
using namespace std;
if (!this->root->is_proven())
{
#pragma omp parallel
{
#pragma omp parallel
think(game::copy(this->game));
}
}
// std::ofstream ofs ("graph.gv", ofstream::out);
// util::display_node::node_to_dot(ofs, this->root, 1000, 50);
util::display_node::node_to_ascii(cout, this->root, 1);
......@@ -222,52 +230,52 @@ namespace mcts
node* children = this->root->get_children();
unsigned int c;
for (uint16_t i = 0; i < nb_children; ++i)
{
{
node *child = children + k;
if (child->is_lost())
{
{
best_move_so_far = k;
break;
}
}
c = children[k].get_statistics().count;
if (c > best_count_so_far)
{
{
best_count_so_far = c;
best_move_so_far = k;
}
}
++k;
if (k == nb_children) k = 0;
}
}
return best_move_so_far;
}
}
template <typename Game>
void mcts_two_players<Game>::last_moves(uint16_t computer, uint16_t other)
{
template <typename Game>
void mcts_two_players<Game>::last_moves(uint16_t computer, uint16_t other)
{
if (this->root->is_leaf() || this->root->get_children()[computer].is_leaf())
{
{
alloc_.clear();
this->root = alloc_.allocate(1);
}
}
else
{
{
this->root = alloc_.move(&this->root->get_children()[computer].get_children()[other]);
}
}
}
}
template <typename Game>
void mcts_two_players<Game>::last_move(uint16_t move)
{
template <typename Game>
void mcts_two_players<Game>::last_move(uint16_t move)
{
if (this->root->is_leaf())
{
{
alloc_.clear();
this->root = alloc_.allocate(1);
}
}
else
{
{
this->root = alloc_.move(&this->root->get_children()[move], 20);
}
}
}
}
}
......
AI/src/mcts/test_mcts_two_players.hpp
View file @ b8a621a7
#ifndef __TEST_MCTS_TWO_PLAYERS_HPP__
#define __TEST_MCTS_TWO_PLAYERS_HPP__
#include "openings.hpp"
#include "mcts_two_players.hpp"
#include "MCTS_SETTINGS.hpp"
......@@ -10,67 +9,79 @@
#include <iomanip>
#include <set>
#include <fstream>
#include "heuristic.hpp"
#include "config.hpp"
#include "test_statistics.hpp"
#include <unistd.h>
#include "penguin.hpp"
namespace mcts
{
template <typename Game>
class test_mcts_two_players
{
openings openings_;
template <typename Game>
class test_mcts_two_players
{
openings* openings_;
void play(Game g);
void play(Game g, const heuristic<Game>& h);
void self_play(Game g);
void self_play(Game g, int n, bool with_openings = false);
void self_play(Game g, const heuristic<Game>& h1 = zero_knowledge<Game>(), const heuristic<Game>& h2 = zero_knowledge<Game>());
void self_play_learn_openings(Game g, int n);
void test_openings(Game g, int nb_learning, int nb_testing);
int select_move(Game& game);
public:
test_mcts_two_players(const Game& g);
};
public:
test_mcts_two_players(const Game& g, const heuristic<Game>& h1 = zero_knowledge<Game>(), const heuristic<Game>& h2 = zero_knowledge<Game>());
};
template <typename Game>
test_mcts_two_players<Game>::test_mcts_two_players(const Game& g) : openings_(g)
{
//self_play(g, 1000);
play(g);
//test_openings(g, 10000, 1000);
}
template <typename Game>
test_mcts_two_players<Game>::test_mcts_two_players(const Game& g, const heuristic<Game>& h, const heuristic<Game>& h2)
{
game::config& config = game::config::get_config();
std::cout << "wtf" << std::endl;
if(config.is_ai_vs_ai())
{
self_play(g, h,h2);
}
else
{
play(g, h);
}
}
template <typename Game>
void run_test_mcts_two_players(const Game& g)
{
test_mcts_two_players<Game>{g};
}
template <typename Game>
void run_test_mcts_two_players(const Game& g, const heuristic<Game>& h = zero_knowledge<Game>(),const heuristic<Game>& h2 = zero_knowledge<Game>())
{
test_mcts_two_players<Game> {g, h, h2};
}
template <typename Game>
void test_mcts_two_players<Game>::test_openings(Game g, int nb_learning, int nb_testing)
{
// self_play(g, nb_testing);
template <typename Game>
void test_mcts_two_players<Game>::test_openings(Game g, int nb_learning, int nb_testing)
{
//self_play(g, nb_testing);
self_play_learn_openings(g, nb_learning);
self_play(g, nb_testing, true);
}
}
template <typename Game>
int test_mcts_two_players<Game>::select_move(Game& game)
{
template <typename Game>
int test_mcts_two_players<Game>::select_move(Game& game)
{
std::cout << game.player_to_string(game.current_player()) << " move: ";
std::map<std::string, int> m;
for (int i = 0; i < game.number_of_moves(); ++i)
{
{
m[game.move_to_string(i)] = i;
}
}
std::string move;
getline(std::cin, move);
game.play(m[move]);
return m[move];
}
}
template <typename Game>
void test_mcts_two_players<Game>::play(Game g)
{
template <typename Game>
void test_mcts_two_players<Game>::play(Game g, const heuristic<Game>& h)
{
// ProfilerStart("theturk.prof");
auto the_turk = make_mcts_two_players(g, MCTS_TURN_TIME, 0.4, 8);
auto the_turk = make_mcts_two_players(g, MCTS_TURN_TIME, 0.4, 8, h);
std::cout << "play one game" << std::endl;
std::cout << "who's first? (h)uman/(c)omputer ";
std::string ans;
......@@ -78,190 +89,207 @@ namespace mcts
std::cout << g.to_string() << std::endl;
int human_last_move = -1, computer_last_move = -1;
while (!g.end_of_game())
{
{
if ((ans == "h" && g.current_player() == 0) || (ans == "c" && g.current_player() == 1))
{
{
human_last_move = select_move(g);
}
}
else
{
{
if (human_last_move != -1 && computer_last_move != -1)
{
{
the_turk.last_moves(computer_last_move, human_last_move);
}
}
uint16_t move = the_turk.select_move();
computer_last_move = move;
std::cout << g.player_to_string(g.current_player()) << " move: " << g.move_to_string(move) << std::endl;
g.play(move);
}
}
std::cout << g << std::endl;
}
}
if (g.won(0)) std::cout << g.player_to_string(0) << " won";
else if (g.won(1)) std::cout << g.player_to_string(1) << " won";
else std::cout << "draw";
std::cout << std::endl;
// ProfilerStop();
}
}
template <typename Game>
void test_mcts_two_players<Game>::self_play_learn_openings(Game g, int n)
{
template <typename Game>
void test_mcts_two_players<Game>::self_play_learn_openings(Game g, int n)
{
std::vector<uint16_t> moves(200);
auto state = g.get_state();
auto the_turk_1 = make_mcts_two_players(g, 1000, 0.6, 2);
auto the_turk_2 = make_mcts_two_players(g, 1000, 0.6, 2);
std::cout << "DZMALJDFOPZAIHFOAZHFOZUHAOFHZAO" << std::endl;
std::map<std::set<int>, std::pair<std::uint32_t, double>> learning_examples;
for (int i = 0; i < n; ++i)
{
{
std::cout << i << std::endl;
std::cout << openings_ << std::endl << std::endl;
std::cout << (*openings_) << std::endl << std::endl;
moves.clear();
g.set_state(state);
the_turk_1.reset();
the_turk_1.init_with_openings(openings_);
the_turk_1.init_with_openings(*openings_);
the_turk_2.reset();
the_turk_2.init_with_openings(openings_);
the_turk_2.init_with_openings(*openings_);
int the_turk_1_last_move = -1, the_turk_2_last_move = -1;
int k = 0;
while (!g.end_of_game())
{
{
if (k == 1) the_turk_2.last_move(the_turk_1_last_move);
if (k % 2 == 0)
{
{
if (the_turk_2_last_move != -1)
{
{
the_turk_1.last_moves(the_turk_1_last_move, the_turk_2_last_move);
}
}
std::uint16_t move = the_turk_1.select_move();
moves.push_back(move);
the_turk_1_last_move = move;
g.play(move);
}
}
else
{
{
if (the_turk_2_last_move != -1)
{
{
the_turk_2.last_moves(the_turk_2_last_move, the_turk_1_last_move);
}
}
std::uint16_t move = the_turk_2.select_move();
moves.push_back(move);
the_turk_2_last_move = move;
g.play(move);
}
}
++k;
}
std::cout << g.to_string() << std::endl;
}
std::cout << g.to_string() << std::endl;
int v = g.value(0);
std::cout << "value for first player " << v << std::endl;
g.set_state(state);
openings_.update(g, moves, v);
g.set_state(state);
for (std::uint16_t m : moves)
{
g.play(m);
v = -v;
std::set<int> input_vector = std::move(g.to_input_vector());
auto it = learning_examples.find(input_vector);
if (it == learning_examples.end())
{
learning_examples[input_vector] = std::make_pair(1, v);
}
else
{
it->second.second = (it->second.second * it->second.first + v) / (it->second.first + 1);
it->second.first += 1;
}
}
}
openings_->update(g, moves, v);
g.set_state(state);
for (std::uint16_t m : moves)
{
g.play(m);
v = -v;
std::set<int> input_vector = std::move(g.to_input_vector());
auto it = learning_examples.find(input_vector);
if (it == learning_examples.end())
{
learning_examples[input_vector] = std::make_pair(1, v);
}
else
{
it->second.second = (it->second.second * it->second.first + v) / (it->second.first + 1);
it->second.first += 1;
}
}
}
std::cout << "number of learning examples: " << learning_examples.size() << std::endl;
std::ofstream output("learning_examples.txt");
for (const auto& example : learning_examples)
{
output << example.second.second;
for (int index : example.first)
{
output << " " << index << ":" << 1;
}
output << std::endl;
}
{
output << example.second.second;
for (int index : example.first)
{
output << " " << index << ":" << 1;
}
output << std::endl;
}
output.close();
}
}
template <typename Game>
void test_mcts_two_players<Game>::self_play(Game g, int n, bool with_openings)
{
template <typename Game>
void test_mcts_two_players<Game>::self_play(Game g, const heuristic<Game>& h1, const heuristic<Game>& h2)
{
//std::cout << getFilePath() << std::endl;
game::config& c = game::config::get_config();
auto state = g.get_state();
auto the_turk_v1 = make_mcts_two_players(g, 1000, 0.6, 2);
auto the_turk_v2 = make_mcts_two_players(g, 1000, 0.6, 2);
auto the_turk_v1 = make_mcts_two_players(g, c.get_think_time(), 0.6, 4, h1);
auto the_turk_v2 = make_mcts_two_players(g, c.get_think_time(), 0.6, 2, h2);
std::string result_directory(get_test_results_directory());
int nb_win_v1 = 0, nb_win_v2 = 0, nb_draw = 0;
for (int i = 0; i < n; ++i)
{
std::cout << i << std::endl;
for (unsigned int i = 0; i < c.get_game_count(); ++i)
{
//std::cout << i << std::endl;
if(i%2 == 1)
{
state = game::penguin::random_start_state();
}
g.set_state(state);
the_turk_v1.reset();
the_turk_v2.reset();
if (with_openings) the_turk_v2.init_with_openings(openings_);
int the_turk_v1_last_move = -1, the_turk_v2_last_move = -1;
int k = 0;
int k = 0;
while (!g.end_of_game())
{
if (with_openings && k == 1 && i % 2 == 0) the_turk_v2.last_move(the_turk_v1_last_move);
++k;
{
++k;
// cout << c4 << endl;
if ((i % 2 == 0 && g.current_player() == 0) || (i % 2 == 1 && g.current_player() == 1))
{
{
if (the_turk_v1_last_move != -1 && the_turk_v2_last_move != -1)
{
{
the_turk_v1.last_moves(the_turk_v1_last_move, the_turk_v2_last_move);
}
}
std::uint16_t move = the_turk_v1.select_move();
the_turk_v1_last_move = move;
g.play(move);
}
}
else
{
{
if (the_turk_v1_last_move != -1 && the_turk_v2_last_move != -1)
{
{
the_turk_v2.last_moves(the_turk_v2_last_move, the_turk_v1_last_move);
}
}
std::uint16_t move = the_turk_v2.select_move();
the_turk_v2_last_move = move;
play(move);
}
}
g.play(move);
}
if(c.should_send_game_to_gui())
std::cout << g;
}
if (g.won(0))
{
{
if (i % 2 == 0)
{
/*cout << "v1 won" << endl;*/ ++nb_win_v1;
}
{
std::cout << "v1 won" << std::endl;
++nb_win_v1;
}
else
{
/*cout << "v2 won" << endl;*/ ++nb_win_v2;
}
}
{
std::cout << "v2 won" << std::endl;
++nb_win_v2;
}
}
else if (g.won(1))
{
{
if (i % 2 == 0)
{
/*cout << "v2 won" << endl;*/ ++nb_win_v2;
}
{
std::cout << "v2 won" <<std::endl; ++nb_win_v2;
}
else
{
/*cout << "v1 won" << endl;*/ ++nb_win_v1;
}
}
{
std::cout << "v1 won" << std::endl; ++nb_win_v1;
}
}
else
{
{
/*cout << "draw" << endl;*/ ++nb_draw;
}
}
save_stats(result_directory,nb_win_v1,nb_win_v2,nb_draw);
std::cout << std::setw(10) << "v1 nb wins: " << nb_win_v1 << " v2 nb wins: " << nb_win_v2 << " nb draws: " << nb_draw << std::endl;
}
}
}
}
template <typename Game>
void test_mcts_two_players<Game>::self_play(Game g)
{
template <typename Game>
void test_mcts_two_players<Game>::self_play(Game g)
{
auto the_turk_v1 = make_mcts_two_players(g, 1000, 1.2, 2);
auto the_turk_v2 = make_mcts_two_players(g, 1000, 1.2, 2);
std::cout << "play one game" << std::endl;
......@@ -271,36 +299,36 @@ namespace mcts
std::cout << g << std::endl;
int the_turk_v1_last_move = -1, the_turk_v2_last_move = -1;
while (!g.end_of_game())
{
{
if ((ans == "v1" && g.current_player() == 0) || (ans == "v2" && g.current_player() == 1))
{
{
if (the_turk_v1_last_move != -1 && the_turk_v2_last_move != -1)
{
{
the_turk_v1.last_moves(the_turk_v1_last_move, the_turk_v2_last_move);
}
}
std::uint16_t move = the_turk_v1.select_move();
the_turk_v1_last_move = move;
std::cout << g.player_to_string(g.current_player()) << " move: " << g.move_to_string(move) << std::endl;
g.play(move);
}
}
else
{
{
if (the_turk_v1_last_move != -1 && the_turk_v2_last_move != -1)
{
{
the_turk_v2.last_moves(the_turk_v2_last_move, the_turk_v1_last_move);
}
}
std::uint16_t move = the_turk_v2.select_move();
the_turk_v2_last_move = move;
std::cout << g.player_to_string(g.current_player()) << " move: " << g.move_to_string(move) << std::endl;
g.play(move);
}
std::cout << g << std::endl;
}
}
std::cout << g << std::endl;
}
if (g.won(0)) std::cout << g.player_to_string(0) << " won";
else if (g.won(1)) std::cout << g.player_to_string(1) << " won";
else std::cout << "draw";
std::cout << std::endl;
}
}
}
......
GUI/src/controller/Controller.java
View file @ b8a621a7
......@@ -382,3 +382,4 @@ public class Controller implements Initializable
}
GUI/src/controller/UpdateThread.java
View file @ b8a621a7
......@@ -206,3 +206,4 @@ public class UpdateThread extends Thread
}
}
}
GUI/src/model/GameState.java
View file @ b8a621a7
......@@ -33,7 +33,7 @@ public class GameState
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"));
......@@ -50,6 +50,7 @@ public class GameState
for (int i = 0; i < jsonPeng.length(); i++)
penguins.get(Player.Blue)[i] = jsonPeng.getInt(i);
}
/**
......
Makefile
View file @ b8a621a7
......@@ -31,13 +31,13 @@ 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
AIInclude=-I $(AISRC)/game -I $(AISRC)/util -I $(AISRC)/monte_carlo -I $(AISRC)/mcts -I $(AISRC)/json -I $(AISRC)/heuristics
# 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
test_mcts_two_players.cpp bits.cpp test_bits.cpp penguin_heuristic.cpp number_direction_freedom_heuristic.cpp main.cpp config.cpp movement_freedom_heuristic.cpp points_heuristic.cpp test_statistics.cpp go_left_up_heuristic.cpp
# Directories in which make will search for files
vpath %.cpp $(AISRC)/game $(AISRC)/main $(AISRC)/util $(AISRC)/monte_carlo $(AISRC)/mcts $(AISRC)/gdl
vpath %.cpp $(AISRC)/game $(AISRC)/heuristics $(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
......
Makefile.orig 0 → 100644
View file @ b8a621a7
# 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 \
<<<<<<< HEAD
test_mcts_two_players.cpp bits.cpp test_bits.cpp penguin_heuristic.cpp points_heuristic.cpp main.cpp config.cpp
=======
test_mcts_two_players.cpp bits.cpp test_bits.cpp penguin_heuristic.cpp movement_freedom_heuristic.cpp main.cpp config.cpp
>>>>>>> 34412ade6e5941a3c916b90b915655977cb2068c
# 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
# 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
launch_test.sh 0 → 100755
View file @ b8a621a7
#!/bin/bash
#declare -a machines=("berger" "cavalier" "pion" "roi" "reine" "fou" "pat" "echiquier" "mate")
declare -a machines=("contrex" "perrier")
echo -n User:
read user
for m in "${machines[@]}"
do
#ssh ${user}@${m} '
#gnome-terminal -hold "bash -c ssh ${user}@${m}"
xterm -hold -e "ssh ${user}@${m} 'cd pingouins;make && ./AI/bin/penguin'" &
done
sum_up_stats.sh 0 → 100755
View file @ b8a621a7
#!/bin/bash
for test_ver in `ls test`
do
win_v1=0
win_v2=0
draw=0
rm "test/$test_ver/res.stats"
for file in `ls test/$test_ver/*.stats`
do
read -r line < $file
IFS=' ' read -r -a wins <<< "$line"
win_v1=$((win_v1 + wins[0]))
win_v2=$((win_v2 + wins[1]))
draw=$((draw + wins[2]))
done
echo "$win_v1 $win_v2 $draw" > "test/$test_ver/res.stats"
done