.gitignore

 .vs
 
-Debug
-Grammar/Tools
-
-GameCompiler.sln
-GameCompiler.vcxproj
-GameCompiler.vcxproj.filters
-GameCompiler.vcxproj.user
\ No newline at end of file
+Debug/*
\ No newline at end of file

Game/Compiler.cpp

 #include "Compiler.h"
 
+#include "../Grammar/Common.h"
+#include "../Grammar/Parser.tab.h"
+
+extern "C" SyntaxTree * parser_main(char* file_path);
+
 // Prints warning and 
 	// returns false if 
 	// ptr == NULL
@@ -130,21 +135,57 @@ void Compiler::setVariable(DataSet* data_set, std::string type, std::string name
 	else std::cout << "Error: unknown type:\t" << type << '\n';
 }
 
+State* Compiler::createState(SyntaxTree* input_state)
+{
+	DataSet* state_data = createDataSet(get_DATA_SET_from_STATE(input_state));
+	InstructionBlock* setup = createInstructionBlock(get_INSTRUCTION_BLOCK_from_STATE(input_state), state_data, NULL, VAR_TYPE::VOID);
+
+	return new State(state_data, setup);
+}
+
 
 // Main components
 
 Game* Compiler::createGame(SyntaxTree* input_game)
 {
+	SyntaxTree* players_st = extract(input_game, 0, "PLAYERS from GAME");
 	SyntaxTree* state_st = get_STATE_from_GAME(input_game);
+	SyntaxTree* main_rule_st = extract(input_game, 2, "MAIN_RULE from GAME");
+	SyntaxTree* moves_st = extract(input_game, 3, "MOVES from GAME");
+
+
+
+	players_set = createPlayers(players_st);
+
+	state = createState(state_st);
+
+	MainRule* main_rule = createMainRule(main_rule_st);
+
+	Moves* moves = createMoves(moves_st);
+
+
+	//state->setupState();
+	//main_rule->Run();
+	//state->print();
+	//players_set->print();
 
-	DataSet* state = createDataSet(get_DATA_SET_from_STATE(state_st));
-	InstructionBlock* IB = createInstructionBlock(get_INSTRUCTION_BLOCK_from_STATE(state_st), state, NULL, VAR_TYPE::VOID);
 
-	IB->RunBlock();
-	state->print();
 
-	Game* game = new Game(state);
-	return game;
+	game_object = new Game(players_set, state, main_rule, moves);
+
+	return game_object;
+}
+
+Game* Compiler::createGame(std::string source)
+{
+	SyntaxTree* st = parser_main(const_cast<char*>(source.c_str()));
+	SyntaxTree_print(st, 0);
+
+	std::cout << "\n\n";
+
+	Compiler compiler = Compiler();
+	
+	return compiler.createGame(st);
 }
 
 DataSet* Compiler::createDataSet(SyntaxTree* input_data_set)
@@ -186,6 +227,180 @@ DataSet* Compiler::createDataSet(SyntaxTree* input_data_set)
 	return data_set;
 }
 
+PlayersSet* Compiler::createPlayers(SyntaxTree* input_players)
+{
+	SyntaxTree* players_list_st = extract(input_players, 0, "PLAYERS_LIST from PLAYERS");
+
+	std::list<Player*> players = std::list<Player*>();
+
+	while (true)
+	{
+		SyntaxTree* player_class_st = extract(players_list_st, 0, "PLAYER from PLYERS_LIST");
+		addPlayerClass(player_class_st, players);
+
+		if (players_list_st->children_num == 2)
+			players_list_st = extract(players_list_st, 1, "PLAYERS_LIST from PLYERS_LIST");
+
+		else break;
+	}
+
+
+	return new PlayersSet(players);
+}
+
+void Compiler::addPlayerClass(SyntaxTree* input_player_class, std::list<Player*>& players)
+{
+	std::string identifier = extract(input_player_class, 0, "IDENTIFIER from PLAYER_CLASS")->text;
+	int class_size = std::stoi(extract(input_player_class, 1, "CLASS_SIZE from PLAYER_CLASS")->text);
+
+	for (int i = 0; i < class_size; i++)
+		players.push_back(new Player(identifier, i));
+}
+
+MainRule* Compiler::createMainRule(SyntaxTree* input_main_rule)
+{
+	SyntaxTree* end_rule_list_st = extract(input_main_rule, 0, "MAIN_RULE_LIST from MAIN_RULE");
+
+	std::list<EndRule*> end_rule_list;
+
+	while (true)
+	{
+		SyntaxTree* end_rule_st = extract(end_rule_list_st, 0, "END_RULE from END_RULE_LIST");
+		EndRule* end_rule = createEndRule(end_rule_st);
+		end_rule_list.push_back(end_rule);
+
+		if (end_rule_list_st->children_num == 2)
+			end_rule_list_st = extract(end_rule_list_st, 1, "END_RULE_LIST from END_RULE_LIST");
+
+		else break;
+	}
+
+	return new MainRule(end_rule_list);
+}
+
+EndRule* Compiler::createEndRule(SyntaxTree* input_end_rule)
+{
+	SyntaxTree* identifier_st = extract(input_end_rule, 0, "IDENTIFIER from END_RULE");
+	SyntaxTree* rule_condition_st = extract(input_end_rule, 1, "INSTRUCTION_BLOCK from END_RULE");
+	SyntaxTree* payoff_list_st = extract(input_end_rule, 2, "PAYOFF_LIST from END_RULE");
+
+	std::string rule_name = identifier_st->text;
+	InstructionBlock* rule_condition = createInstructionBlock(rule_condition_st, state->getData(), NULL, VAR_TYPE::BOOL);
+
+	std::list<Payoff*> payoff_list;
+
+	while (true)
+	{
+		SyntaxTree* payoff_st = extract(payoff_list_st, 0, "PAYOFF from PAYOFF_LIST");
+		Payoff* payoff = createPayoff(payoff_st);
+		payoff_list.push_back(payoff);
+
+		if (payoff_list_st->children_num == 2)
+			payoff_list_st = extract(payoff_list_st, 1, "PAYOFF_LIST from PAYOFF_LIST");
+
+		else break;
+	}
+
+	return new EndRule(rule_name, rule_condition, payoff_list, players_set);
+}
+
+Payoff* Compiler::createPayoff(SyntaxTree* input_payoff)
+{
+	SyntaxTree* identifier_st = extract(input_payoff, 0, "IDENTIFIER from PAYOFF");
+	SyntaxTree* payoff_st = extract(input_payoff, 1, "INSTRUCTION_BLOCK from PAYOFF");
+
+	std::string player_class = identifier_st->text;
+	InstructionBlock* payoff_block = createInstructionBlock(payoff_st, state->getData(), NULL, VAR_TYPE::INT);
+
+	return new Payoff(player_class, payoff_block);
+}
+
+Moves* Compiler::createMoves(SyntaxTree* input_moves)
+{
+	SyntaxTree* move_list_st = extract(input_moves, 0, "MOVE_LIST from MOVES");
+
+	std::list<Move*> move_list;
+
+	while (true)
+	{
+		SyntaxTree* move_st = extract(move_list_st, 0, "MOVE from MOVE_LIST");
+		Move* move = createMove(move_st);
+		move_list.push_back(move);
+
+		if (move_list_st->children_num == 2)
+			move_list_st = extract(move_list_st, 1, "MOVE_LIST from MOVE_LIST");
+
+		else break;
+	}
+
+	return new Moves(move_list);
+}
+
+Move* Compiler::createMove(SyntaxTree* input_move)
+{
+	SyntaxTree* identifier_st = extract(input_move, 0, "IDENTIFIER from MOVE");
+	SyntaxTree* players_scope_st = extract(input_move, 1, "PLAYERS_SCOPE from MOVE");
+	SyntaxTree* move_data_st = extract(input_move, 2, "DATA_SET from MOVE");
+	SyntaxTree* validation_st = extract(input_move, 3, "INSTRUCTION_BLOCK from MOVE");
+	SyntaxTree* execution_st = extract(input_move, 4, "INSTRUCTION_BLOCK from MOVE");
+
+	std::string name = identifier_st->text;
+	std::list<std::string> players_scope = createPlayersScope(players_scope_st);
+	DataSet* move_data = createDataSet(move_data_st);
+	InstructionBlock* validation = createInstructionBlock(validation_st, state->getData(), move_data, VAR_TYPE::BOOL);
+	InstructionBlock* move_execution = createInstructionBlock(execution_st, state->getData(), move_data, VAR_TYPE::VOID);
+
+	return new Move(name, players_scope, move_data, validation, move_execution);
+}
+
+std::list<std::string> Compiler::createPlayersScope(SyntaxTree* input_players_scope)
+{
+	if (input_players_scope->children_num == 0) // Add all player classes
+		return getPlayersClasses();
+
+
+	SyntaxTree* identifier_list_st = extract(input_players_scope, 0, "IDENTIFIER_LIST from PLAYERS_SCOPE");
+
+	std::list<std::string> players_scope; 
+	
+	while (true)
+	{
+		SyntaxTree* identifier_st = extract(identifier_list_st, 0, "IDENTIFIER from IDENTIFIER_LIST");
+		players_scope.push_back(identifier_st->text);
+
+		if (identifier_list_st->children_num == 2)
+			identifier_list_st = extract(identifier_list_st, 1, "IDENTIFIER_LIST from IDENTIFIER_LIST");
+
+		else break;
+	}
+
+	return players_scope;
+}
+
+std::list<std::string> Compiler::getPlayersClasses()
+{
+	std::list<std::string> all_classes;
+
+	std::list<Player*> players_list = players_set->getPlayersList();
+	for (Player* player : players_list)
+	{
+		bool exists = false;
+		for (std::string from_scope : all_classes)
+		{
+			if (player->getType() == from_scope)
+			{
+				exists = true;
+				break;
+			}
+		}
+
+		if (!exists)
+			all_classes.push_back(player->getType());
+	}
+
+	return all_classes;
+}
+
 InstructionBlock* Compiler::createInstructionBlock(SyntaxTree* input_instruction_block, DataSet* state, DataSet* move, VAR_TYPE return_type)
 {
 	SyntaxTree* local_data = getElement(input_instruction_block, Type::instruction_block, Type::data_set);
@@ -216,11 +431,18 @@ Instruction* Compiler::createInstruction(SyntaxTree* input_instruction, DataSet*
 		last_instructions.push_back(instr);
 		return instr;
 	}
+	case Type::next_player_instr: {
+		Instruction* instr = createNextPlayerInstruction(typed_instruction, local, state, move);
+		last_instructions.push_back(instr);
+		return instr;
+	}
 	case Type::return_instr: return createReturnInstruction(typed_instruction, local, state, move, return_var);
 	case Type::if_instr: return createIfInstruction(typed_instruction, local, state, move, return_var, last_instructions);
 	case Type::while_instr: return createWhileInstruction(typed_instruction, local, state, move, return_var, last_instructions);
 	default: break;
 	}
+	
+	std::cout << "Warnig: No implementation for instruction type: " << getTypeName(typed_instruction->type) << "\n";
 
 	return nullptr;
 }
@@ -337,6 +559,19 @@ Instruction* Compiler::createWhileInstruction(SyntaxTree* input_instruction, Dat
 	return while_instr;
 }
 
+Instruction* Compiler::createNextPlayerInstruction(SyntaxTree* input_instruction, DataSet* local, DataSet* state, DataSet* move)
+{
+	SyntaxTree* identifier_st = extract(input_instruction, 0, "IDENTIFIER from NEXT_PLAYER_INSTR");	// REFACTOR
+	SyntaxTree* player_id_expr_st = extract(input_instruction, 1, "EXPR from NEXT_PLAYER_INSTR");	// REFACTOR
+
+	std::string type = identifier_st->text;
+	ExpressionInt* id_expr = createIntExpression(player_id_expr_st, local, state, move);
+
+	// No check if NEW_PLYER_INSTR is available in current block
+
+	return new InstructionNextPlayer(players_set, type, id_expr);
+}
+
 Instruction* Compiler::createInstructionGraph(SyntaxTree* input_instruction_list, DataSet* local, DataSet* state, DataSet* move, Variable* return_variable, std::list<Instruction*>& predecessors)
 {
 	Instruction* entry = NULL;
@@ -354,13 +589,10 @@ Instruction* Compiler::createInstructionGraph(SyntaxTree* input_instruction_list
 		if (entry == NULL)
 		{
 			entry = next_instr;
-			//previous_instr = next_instr;
 			predecessors = last_instructions;
 		}
 		else
 		{
-			//previous_instr->setNext(next_instr);
-			//previous_instr = next_instr;
 			for (Instruction* instr : predecessors)
 				instr->setNext(next_instr);
 
@@ -382,6 +614,10 @@ ExpressionInt* Compiler::createIntExpression(SyntaxTree* input_expression, DataS
 		SyntaxTree* next_expr = extract(input_expression, 0, "EXPR from EXPR");	// REFACTOR
 		return createIntExpression(next_expr, local, state, move);
 	}
+	case Type::expr_player_index:
+	{
+		return new ExpressionInt_PlayerIndex(players_set);
+	}
 	case Type::expr_ref:
 	{
 		SyntaxTree* variable_reference_st = extract(input_expression, 0, "VARIABLE_REFERENCE from EXPR");	// REFACTOR
@@ -423,7 +659,9 @@ ExpressionInt* Compiler::createIntExpression(SyntaxTree* input_expression, DataS
 		case Type::expr_mod: return new ExpressionInt_Mod(a, b);
 		}
 	}
-	default: break;
+	default: 
+		std::cout << "Error: Invalid operator \"" << getTypeName(input_expression->type) << "\" in INT expression\n";
+		break;
 	}
 
 	return nullptr;
@@ -496,7 +734,9 @@ ExpressionBool* Compiler::createBoolExpression(SyntaxTree* input_expression, Dat
 		case Type::expr_less:			return new ExpressionBool_Less(a, b);
 		}
 	}
-	default: break;
+	default:
+		std::cout << "Error: Invalid operator \"" << getTypeName(input_expression->type) << "\" in BOOL expression\n"; 
+		break;
 	}
 
 	return nullptr;

Game/Compiler.h

@@ -8,6 +8,10 @@
 class Compiler
 {
 private:
+	Game* game_object;
+	PlayersSet* players_set;
+	State* state;
+
 
 	bool nullCheck(SyntaxTree* ptr, std::string warning);
 
@@ -36,49 +40,39 @@ private:
 	std::string get_identifier_from_VAR_DECLARATION(SyntaxTree* var_declaration);
 	std::string get_value_from_VAR_DECLARATION(SyntaxTree* var_declaration);
 
-	// Extract INSTRUCTION_BLOCK
-	SyntaxTree* get_DATA_SET_from_INSTRUCTION_BLOCK(SyntaxTree* state);
-	SyntaxTree* get_INSTRUCTION_LIST_from_INSTRUCTION_BLOCK(SyntaxTree* state);
 
-	// Extract INSTRUCTION_LIST
-	SyntaxTree* get_INSTRUCTION_LIST_from_INSTRUCTION_LIST(SyntaxTree* state);
-	SyntaxTree* get_INSTRUCTION_from_INSTRUCTION_LIST(SyntaxTree* state);
 
-	// Extract INSTRUCTION
-	SyntaxTree* get_INSTRUCTION_type_from_INSTRUCTION(SyntaxTree* state);
+	// Data functions
+
+	void setVariable(DataSet* data_set, std::string type, std::string name, std::string value);
 
-	// Extract ASSIGN_INSTR
-	SyntaxTree* get_VAR_REFERENCE_from_ASSIGN_INSTR(SyntaxTree* state);
-	SyntaxTree* get_EXPR_from_ASSIGN_INSTR(SyntaxTree* state);
 
-	// Extract VAR_REFERENCE
-	SyntaxTree* get_SCOPE_from_VAR_REFERENCE(SyntaxTree* state);
-	SyntaxTree* get_IDENTIFIER_from_VAR_REFERENCE(SyntaxTree* state);
+	// Main components //
 
-	// Extract EXPR
-	SyntaxTree* get_VAR_REFERENCE_from_EXPR(SyntaxTree* state);
-	SyntaxTree* get_VAR_DEFINITION_from_EXPR(SyntaxTree* state);
-	SyntaxTree* get_EXPR_from_EXPR(SyntaxTree* state);
 
+	State* createState(SyntaxTree* input_state);
 
+	// Takes STATE part of syntax tree as an input
+	DataSet* createDataSet(SyntaxTree* input_data_set);
 
+	// Players
+	PlayersSet* createPlayers(SyntaxTree* input_players);
+	void addPlayerClass(SyntaxTree* input_player_class, std::list<Player*>& players);
 
 
-	// Data functions
+	// Main Rule //
 
-	void setVariable(DataSet* data_set, std::string type, std::string name, std::string value);
+	MainRule* createMainRule(SyntaxTree* input_main_rule);
+	EndRule* createEndRule(SyntaxTree* input_end_rule);
+	Payoff* createPayoff(SyntaxTree* input_payoff);
 
 
-	// Main components //
+	// Moves //
 
-	// Takes STATE part of syntax tree as an input
-	// Structure of STATE is:
-	//
-	// DATA_SET -> VAR_LIST -> VAR_DECLARATION
-	//						|
-	//                      -> VAR_DECLARATION
-	//                         VAR_LIST
-	DataSet* createDataSet(SyntaxTree* input_data_set);
+	Moves* createMoves(SyntaxTree* input_moves);
+	Move* createMove(SyntaxTree* input_move);
+	std::list<std::string> createPlayersScope(SyntaxTree* input_players_scope);
+	std::list<std::string> getPlayersClasses();
 
 
 	// Instructions //
@@ -90,6 +84,7 @@ private:
 	Instruction* createReturnInstruction(SyntaxTree* input_instruction, DataSet* local, DataSet* state, DataSet* move, Variable* return_var);
 	Instruction* createIfInstruction(SyntaxTree* input_instruction, DataSet* local, DataSet* state, DataSet* move, Variable* return_var, std::list<Instruction*>& last_instructions);
 	Instruction* createWhileInstruction(SyntaxTree* input_instruction, DataSet* local, DataSet* state, DataSet* move, Variable* return_var, std::list<Instruction*>& last_instructions);
+	Instruction* createNextPlayerInstruction(SyntaxTree* input_instruction, DataSet* local, DataSet* state, DataSet* move);
 
 	Instruction* createInstructionGraph(SyntaxTree* input_instruction_list, DataSet* local, DataSet* state, DataSet* move, Variable* return_variable, std::list<Instruction*>& predecessors);
 	ExpressionInt* createIntExpression(SyntaxTree* input_expression, DataSet* local, DataSet* state, DataSet* move);
@@ -100,11 +95,7 @@ private:
 
 public:
 	// Takes as an input all syntax tree
-	// Its main parts are:
-	//
-	// MAIN_RULE
-	// STATE 
-	// MOVES
 	Game* createGame(SyntaxTree* input_game);
+	Game* createGame(std::string source);
 };
 

Game/DataSet/DataSet.cpp

@@ -40,7 +40,7 @@ void* DataSet::getValuePtr(std::string name)
 {
 	if (!exist(name))
 	{
-		std::cout << "not found\n";
+		std::cout << "Warning: Not found identifier \"" << name << "\" in scope\n";
 		return nullptr;
 	}
 
@@ -52,13 +52,45 @@ VAR_TYPE DataSet::getValueType(std::string name)
 {
 	if (!exist(name))
 	{
-		std::cout << "not found\n";
+		std::cout << "Warning: Not found identifier \"" << name << "\" in scope\n";
 		return VAR_TYPE::UNKNOWN;
 	}
 
 	return map.at(name).type;
 }
 
+void DataSet::setInt(std::string name, int value)
+{
+	if (!exist(name))
+	{
+		std::cout << "Warning: Not found identifier \"" << name << "\" in scope\n";
+		return;
+	}
+	variable var = map.at(name);
+
+	if (var.type == VAR_TYPE::INT)
+		*(int*)((char*)data + var.pointer) = value;
+
+	else
+		std::cout << "Warning: Idetifier is not type INT\n";
+}
+
+void DataSet::setBool(std::string name, bool value)
+{
+	if (!exist(name))
+	{
+		std::cout << "Warning: Not found identifier \"" << name << "\" in scope\n";
+		return;
+	}
+	variable var = map.at(name);
+
+	if (var.type == VAR_TYPE::BOOL)
+		*(bool*)((char*)data + var.pointer) = value;
+
+	else
+		std::cout << "Warning: Idetifier is not type BOOL\n";
+}
+
 void DataSet::print()
 {
 	for (std::pair<const std::string, variable>& kv : map)

Game/DataSet/DataSet.h

@@ -46,6 +46,9 @@ public:
 	void* getValuePtr(std::string name);
 	VAR_TYPE getValueType(std::string name);
 
+	void setInt(std::string name, int value);
+	void setBool(std::string name, bool value);
+
 
 	void print();
 

Game/Game.cpp

 #include "Game.h"
 
-Game::Game(DataSet* state)
+Game::Game(PlayersSet* players, State* state, MainRule* main_rule, Moves* moves)
+	: players(players), state(state), main_rule(main_rule), moves(moves)
 {
-	this->state = state;
+	state_data = state->getData();
+
+	moves_map = moves->getMovesDataMap();
+}
+
+void Game::setPlayer(IPlayer* i_player, std::string player_class, int player_id)
+{
+	players->setPlayer(i_player, player_class, player_id);
+}
+
+void Game::startGame()
+{
+	state->setupState();
+
+	bool finished = false;
+	while (!finished)
+	{
+		nextMove();
+		finished = main_rule->Run();
+	}
+}
+
+void Game::nextMove()
+{
+	while (true)
+	{
+		std::string move_name = players->makeMove(state_data, moves_map);
+		if (moves->makeMove(move_name))	// Break if valid mowe was executed
+			break;
+	}
+
+}
+
+void Game::print()
+{
+	players->print();
+	std::cout << '\n';
+
+	state->print();
 }

Game/Game.h

 #pragma once
 #include "DataSet/DataSet.h"
+#include "Player/Player.h"
 #include "Instructions/InstructionBlock.h"
+#include "GameComponents/State.h"
+#include "GameComponents/MainRule.h"
+#include "GameComponents/Moves.h"
 
 class Game
 {
 private:
-	DataSet* state;
+	PlayersSet* players;
+	State* state;
+	MainRule* main_rule;
+	Moves* moves;
+
+	// Helping structures
+	DataSet* state_data;
+	std::unordered_map<std::string, DataSet*> moves_map;
+
+	void nextMove();
 
 public:
-	Game(DataSet* state);
+	Game(PlayersSet* players, State* state, MainRule* main_rule, Moves* moves);
+
+	void setPlayer(IPlayer* i_player, std::string player_class, int player_id);
+
+	void startGame();
+
+	void print();
 };
 

Game/GameComponents/MainRule.cpp

+#include "MainRule.h"
+
+MainRule::MainRule(std::list<EndRule*> end_rules)
+	: end_rules(end_rules)
+{}
+
+bool MainRule::Run()
+{
+	for (EndRule* rule : end_rules)
+		if (rule->Run())
+			return true;
+
+	return false;
+}

Game/GameComponents/MainRule.h

+#pragma once
+
+#include <list>
+#include "MainRule/EndRule.h"
+
+class MainRule
+{
+private:
+	std::list<EndRule*> end_rules;
+
+public:
+	MainRule(std::list<EndRule*> end_rules);
+
+	bool Run();
+
+};
+

Game/GameComponents/MainRule/EndRule.cpp

+#include "EndRule.h"
+
+bool EndRule::existInMap(std::string player_class)
+{
+	return payoff_map.find(player_class) != payoff_map.end();
+}
+
+EndRule::EndRule(std::string rule_name, InstructionBlock* rule_condition, std::list<Payoff*> payoff_list, PlayersSet* players)
+	: rule_name(rule_name), rule_condition(rule_condition), players(players)
+{
+	for (Payoff* payoff : payoff_list)
+	{
+		payoff_map[payoff->getClassName()] = payoff;
+	}
+
+	std::list<Player*> players_list = players->getPlayersList();
+	for (Player* player : players_list)
+	{
+		if (!existInMap(player->getType()))
+			std::cout << "Error: No payoff definition for player \"" << player->getType() << "\"\n";
+	}
+}
+
+bool EndRule::Run()
+{
+	rule_condition->RunBlock();
+	bool result = rule_condition->getReturnVariable()->getValueBool();
+
+	if (result)
+	{
+		std::list<Player*> players_list = players->getPlayersList();
+		for (Player* player : players_list)
+		{
+			std::string player_class = player->getType();
+			if (existInMap(player_class))
+			{
+				players->setNextPlayer(player);
+				Payoff* payoff = payoff_map.at(player->getType());
+				payoff->sendPayoff(player);
+			}
+			else std::cout << "Execution Error: Not found player \"" << player_class << "\" in payoff list \n";
+		}
+
+		return true;
+	}
+
+	return false;
+}

Game/GameComponents/MainRule/EndRule.h

+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include "Payoff.h"
+#include "../../Instructions/InstructionBlock.h"
+
+class EndRule
+{
+private:
+	std::string rule_name;
+	InstructionBlock* rule_condition;
+	std::unordered_map<std::string, Payoff*> payoff_map;
+
+	PlayersSet* players;
+
+	bool existInMap(std::string player_class);
+
+public:
+	EndRule(std::string rule_name, InstructionBlock* rule_condition, std::list<Payoff*> payoff_list, PlayersSet* players);
+
+	bool Run();
+};
+

Game/GameComponents/MainRule/Payoff.cpp

+#include "Payoff.h"
+
+Payoff::Payoff(std::string player_class, InstructionBlock* payoff)
+	: player_class(player_class), payoff(payoff)
+{}
+
+void Payoff::sendPayoff(Player * player)
+{
+	payoff->RunBlock();
+	int result = payoff->getReturnVariable()->getValueInt();
+	player->setPayoff(result);
+}
+
+std::string Payoff::getClassName()
+{
+	return player_class;
+}

Game/GameComponents/MainRule/Payoff.h

+#pragma once
+
+#include <string>
+#include "../../Instructions/InstructionBlock.h"
+
+class Payoff
+{
+private:
+	std::string player_class;
+	InstructionBlock* payoff;
+
+public:
+	Payoff(std::string player_class, InstructionBlock* payoff);
+
+	void sendPayoff(Player* player);
+
+	std::string getClassName();
+};
+

Game/GameComponents/Moves.cpp

+#include "Moves.h"
+
+bool Moves::existsInMap(std::string move_name)
+{
+	return moves.find(move_name) != moves.end();
+}
+
+Moves::Moves(std::list<Move*> moves)
+{
+	for (Move* move : moves)
+	{
+		this->moves[move->getMoveName()] = move;
+	}
+}
+
+DataSet* Moves::getMoveData(std::string move_name)
+{
+	if (!existsInMap(move_name))
+	{
+		std::cout << "Execution Warning: Move \"" << move_name << "\" does not exist\n";
+		return NULL;
+	}
+
+	return moves.at(move_name)->getMoveData();
+}
+
+std::unordered_map<std::string, DataSet*> Moves::getMovesDataMap()
+{
+	std::unordered_map<std::string, DataSet*> moves_map;
+
+	for (std::pair<const std::string, Move*>& kv : moves)
+	{
+		const std::string& name = kv.first;
+		Move* move = kv.second;
+
+		moves_map[name] = move->getMoveData();
+	}
+
+	return moves_map;
+}
+
+bool Moves::makeMove(std::string move_name)
+{
+	if (!existsInMap(move_name))
+	{
+		std::cout << "Execution warning: Move \"" << move_name << "\" does not exist\n";
+		return false;
+	}
+	
+	return moves.at(move_name)->makeMove();
+}

Game/GameComponents/Moves.h

+#pragma once
+
+#include <unordered_map>
+#include <iostream>
+#include "Moves/Move.h"
+
+class Moves
+{
+private:
+	std::unordered_map<std::string, Move*> moves;
+
+	bool existsInMap(std::string move_name);
+
+public:
+	Moves(std::list<Move*> moves);
+
+	DataSet* getMoveData(std::string move_name);
+
+
+	std::unordered_map<std::string, DataSet*> getMovesDataMap();
+
+	bool makeMove(std::string move_name);
+};
+

Game/GameComponents/Moves/Move.cpp

+#include "Move.h"
+
+Move::Move(std::string name, std::list<std::string> players_scope, DataSet* move_data, InstructionBlock* validation, InstructionBlock* move_execution)
+	: name(name), players_scope(players_scope), move_data(move_data), validation(validation), move_execution(move_execution)
+{}
+
+std::string Move::getMoveName()
+{
+	return name;
+}
+
+DataSet* Move::getMoveData()
+{
+	return move_data;
+}
+
+bool Move::makeMove()
+{
+	validation->RunBlock();
+	if (validation->getReturnVariable()->getValueBool())
+	{
+		move_execution->RunBlock();
+		return true;
+	}
+
+
+	std::cout << "Execution warning: Move \"" << name << "\" is not valid\n";
+	return false;
+}

Game/GameComponents/Moves/Move.h

+#pragma once
+
+#include <string>
+#include <list>
+
+#include"../../Instructions/InstructionBlock.h"
+
+class Move
+{
+private:
+	std::string name;
+	std::list<std::string> players_scope;
+
+	DataSet* move_data;
+	InstructionBlock* validation;
+	InstructionBlock* move_execution;
+
+public:
+	Move(std::string name, std::list<std::string> players_scope, DataSet* move_data, InstructionBlock* validation, InstructionBlock* move_execution);
+
+	std::string getMoveName();
+	DataSet* getMoveData();
+
+	bool makeMove();
+};
+

Game/GameComponents/State.cpp

+#include "State.h"
+
+State::State(DataSet* data, InstructionBlock* setup)
+	: data(data), setup(setup)
+{}
+
+DataSet* State::getData()
+{
+	return data;
+}
+
+void State::setupState()
+{
+	setup->RunBlock();
+}
+
+void State::print()
+{
+	data->print();
+	// TODO: print setup instructions
+}

Game/GameComponents/State.h

+#pragma once
+
+#include "../DataSet/DataSet.h"
+#include "../Instructions/InstructionBlock.h"
+
+class State
+{
+private:
+	DataSet* data;
+	InstructionBlock* setup;
+
+public:
+	State(DataSet* data, InstructionBlock* setup);
+
+	DataSet* getData();
+
+	void setupState();
+	void print();
+};
+

Game/Instructions/Instruction/Expression/ExpressionInt.cpp

@@ -13,6 +13,16 @@ ExpressionInt_Value::ExpressionInt_Value(int val)
 	value = val;
 }
 
+ExpressionInt_PlayerIndex::ExpressionInt_PlayerIndex(PlayersSet* players)
+{
+	this->players = players;
+}
+
+int ExpressionInt_PlayerIndex::evaluate()
+{
+	return players->getCurrentPlayer()->getId();
+}
+
 ExpressionInt_Neg::ExpressionInt_Neg(ExpressionInt* expr)
 {
 	this->expr = expr;