No OneTemporary
Actions

Size

35 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/assets/audio/Andys Report.mp3 b/assets/audio/Andys Report.mp3
	new file mode 100644
	index 0000000..6eb0a18
	Binary files /dev/null and b/assets/audio/Andys Report.mp3 differ
	diff --git a/assets/audio/game.ogg b/assets/audio/game.ogg
	new file mode 100644
	index 0000000..642b12f
	Binary files /dev/null and b/assets/audio/game.ogg differ
	diff --git a/assets/audio/game.wav b/assets/audio/game.wav
	new file mode 100644
	index 0000000..01ec53d
	Binary files /dev/null and b/assets/audio/game.wav differ
	diff --git a/assets/audio/menu.ogg b/assets/audio/menu.ogg
	new file mode 100644
	index 0000000..d58f038
	Binary files /dev/null and b/assets/audio/menu.ogg differ
	diff --git a/assets/fnt/MorrisJensonInitialen.ttf b/assets/fnt/MorrisJensonInitialen.ttf
	new file mode 100644
	index 0000000..95eed1c
	Binary files /dev/null and b/assets/fnt/MorrisJensonInitialen.ttf differ
	diff --git a/assets/img/menu.jpg b/assets/img/menu.jpg
	new file mode 100644
	index 0000000..c0bc9e5
	Binary files /dev/null and b/assets/img/menu.jpg differ
	diff --git a/boardelems.cpp b/boardelems.cpp
	index 18c8472..e1429c1 100644
	--- a/boardelems.cpp
	+++ b/boardelems.cpp
	@@ -1,46 +1,47 @@
	#include "boardelems.h"

	BoardElems::BoardElems()
	{
	active = false;
	+ displayNeighbours = true;
	}



	void BoardElems::draw(sf::RenderTarget& target, sf::RenderStates states) const
	{

	std::set<int> neighboursAll;

	states.transform *= getTransform();
	for (const efc::BoardElem &i: items)
	{
	target.draw(i, states);
	std::set<int> neighbours(efc::getNeighbours(i.pos));
	- if (active==true)
	+ if ((active==true) && (displayNeighbours==true))
	{
	for (int j: neighbours)
	{
	if (items_map.count(j)==0)
	{
	neighboursAll.insert(j);
	// sf::RectangleShape sprite(efc::createNeighbour(j));
	// target.draw(sprite, states);
	}
	}
	}
	// std::cout << "POS: "<< i.getPosition().x << " " << i.getPosition().y << std::endl;
	}
	if (active==true)
	{
	for (int j: neighboursAll)
	{
	if (items_map.count(j)==0)
	{
	sf::RectangleShape sprite(efc::createNeighbour(j));
	target.draw(sprite, states);
	}
	}
	}

	}
	diff --git a/boardelems.h b/boardelems.h
	index 7e88165..5983804 100644
	--- a/boardelems.h
	+++ b/boardelems.h
	@@ -1,18 +1,19 @@
	#ifndef BOARDELEMS_H
	#define BOARDELEMS_H
	#include "boardelem.h"
	#include "elemsdescription.h"

	class BoardElems: public sf::Drawable, public sf::Transformable
	{
	public:
	BoardElems();
	std::vector<efc::BoardElem> items;
	std::map<int, efc::BoardElem> items_map;
	bool active;
	+ bool displayNeighbours;
	private:
	virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const;

	};

	#endif // BOARDELEMS_H
	diff --git a/game.cpp b/game.cpp
	index 3bb318c..dfe7f73 100644
	--- a/game.cpp
	+++ b/game.cpp
	@@ -1,370 +1,453 @@
	#include "game.h"

	namespace efc {

	void Game::initBoard()
	{
	// Grass tile starts at 342 and has 11 tiles
	// int level[256];
	// int level[256];

	// Structure of the board
	/*
	{
	342, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	80, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0,
	1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3 }
	*/

	// Fill the array
	for (int i=0;i<256;i++)
	{
	int grass = (rand() % 10) + 1;
	level[i] = 342 + grass;
	level[i] = level[i];
	}


	// level[0] = 441;
	// level[240] = 0;
	// level[255] = 0;
	// level[15] = 0;

	level[8] = 813;
	level[24] = 803;
	level[40] = 803;
	level[56] = 803;
	level[72] = 803;

	level[88] = 801;

	level[167] = 809;
	level[183] = 803;
	level[199] = 803;
	level[215] = 803;
	level[231] = 803;
	level[247] = 812;

	level[112] = 811;
	for (int i=113;i<117;i++)
	level[i] = 816;
	level[117] = 815;

	level[138] = 800;
	for (int i=139;i<143;i++)
	level[i] = 816;
	level[143] = 814;

	map.load(&textures, sf::Vector2u(efc::TILE_SIZE, efc::TILE_SIZE), level, efc::BOARD_SIZE, efc::BOARD_SIZE);

	PlayerHud playerHud1(&textures, std::rand() % 80, &gameFont, 32,0);
	PlayerHud playerHud2(&textures, std::rand() % 30, &gameFont, 32,1);
	PlayerHud playerHud3(&textures, std::rand() % 60, &gameFont, 32,2);
	PlayerHud playerHud4(&textures, std::rand() % 50, &gameFont, 32,3);
	players[0] = playerHud1;
	players[1] = playerHud2;
	players[2] = playerHud3;
	players[3] = playerHud4;
	players[0].setActive(true);
	setCurrentNeighbours();
	}


	void Game::setCurrentNeighbours ()
	{
	currentNeighbours = players[turn].getNeighbours();
	}

	void Game::loadAssets()
	{
	if (!textureFaces.loadFromFile("assets/img/faces.jpg"))
	std::exit(1);

	if (!textureTiles.loadFromFile("assets/img/zw-tilesets/_MAP.png"))
	std::exit(1);

	if (!gameFont.loadFromFile("assets/fnt/8bitOperatorPlus-Regular.ttf"))
	{
	std::exit(1);
	}
	+ if (!menuFont.loadFromFile("assets/fnt/MorrisJensonInitialen.ttf"))
	+ {
	+ std::exit(1);
	+ }
	+
	+
	+
	+ menuTxt.setFont(menuFont);
	+ menuTxt.setCharacterSize(120);
	+ menuTxt.setString(gameTitle);
	+
	+ menuTxt.setColor(sf::Color(55, 255, 35, 85));
	+
	+ int width = menuTxt.getLocalBounds().width;
	+ int height = menuTxt.getLocalBounds().height;
	+ std::cout << width << " " << height << std::endl;
	+ menuTxt.setPosition(400-(width/2),300-(height/2)-150);
	+ menuTxt.setScale(0.5, 0.5);
	+
	+
	+}
	+
	+
	+void Game::showMenu()
	+{
	+ menuBackground.setTexture(textures.textureMenu);
	+ musicMenu.play();
	+ musicMenu.setLoop(true);
	+ currentState = state_menu;
	+}
	+void Game::hideMenu()
	+{
	+ musicMenu.stop();
	+}
	+
	+void Game::showGameBoard()
	+{
	+ musicGame.play();
	+ musicGame.setLoop(true);
	+ currentState = state_game;
	+}
	+
	+void Game::hideGameBoard()
	+{
	+ musicGame.play();
	+
	}

	Game::Game():
	- window(sf::VideoMode(800, 600), "EnFuCraft"),
	+ window(sf::VideoMode(800, 600), "Pagan Board"),
	viewTiles(sf::FloatRect(00, 00, 400, 400)),
	viewFull(sf::FloatRect(00, 00, 400, 400)),
	viewGui(sf::FloatRect(00, 00, 112, 400)),
	selector(efc::TILE_SIZE),
	guiSelectBuilding(&textures),
	- turn(0)
	+ turn(0),
	+ gameTitle(" PAgAN\nBOaRD ")
	{


	-
	- if (!musicGame.openFromFile("assets/audio/wind.ogg"))
	+ showPlayerBoardElems = false;
	+ if (!musicGame.openFromFile("assets/audio/game.ogg"))
	+ std::exit(1);
	+ if (!musicBackground.openFromFile("assets/audio/wind.ogg"))
	+ std::exit(1);
	+ if (!musicMenu.openFromFile("assets/audio/menu.ogg"))
	std::exit(1);
	- musicGame.play();
	- musicGame.setLoop(true);
	+

	if (!sfxClickBuffer.loadFromFile("assets/audio/click.ogg"))
	std::exit(1);
	sfxClick.setBuffer(sfxClickBuffer);
	window.setVerticalSyncEnabled(true);
	Hover hover;
	GuiWindow guiWindow(&textures);
	- currentState = state_init;
	+
	std::srand (time(NULL));
	loadAssets();
	viewGui.setViewport(sf::FloatRect(0.8f,0, 1.0f, 1.0f));
	viewTiles.setViewport(sf::FloatRect(0,0, 0.8f, 1.0f));
	selector.changeColor(turn); //This is only for the test TODO: remove
	initBoard();
	- currentState = state_game;
	+ showMenu();
	+

	// run the main loop
	while (window.isOpen())
	{

	std::string resultCommand = "";



	// handle events
	sf::Event event;
	while (window.pollEvent(event))
	{
	sf::Vector2i localPositionTmp = sf::Mouse::getPosition(window);
	sf::Vector2f localPosition = window.mapPixelToCoords(localPositionTmp,viewTiles);
	sf::Vector2f localPositionGui = window.mapPixelToCoords(localPositionTmp,viewGui);

	int mousePosX = (int)localPosition.x / efc::TILE_SIZE;
	int mousePosY = (int)localPosition.y / efc::TILE_SIZE;
	int mousePos = efc::transCords(sf::Vector2i(mousePosX, mousePosY));
	if(event.type == sf::Event::Closed)
	window.close();

	if (currentState==state_gui_elem)
	{
	resultCommand = guiSelectBuilding.getElem(localPosition);


	if (resultCommand.find("elem_")==0)
	command(resultCommand);
	else
	command("hide_gui_elem_description");



	}

	+ if (currentState==state_game)
	+ {
	+
	+
	+ if ((localPosition.x>400) \|\| (localPosition.x<0) \|\| (localPosition.y>400) \|\| (localPosition.y<0))
	+ {
	+ showPlayerBoardElems = false;
	+ players[turn].elems.displayNeighbours = false;
	+ } else {
	+ showPlayerBoardElems = true;
	+ players[turn].elems.displayNeighbours = true;
	+ }
	+ }
	+
	if (event.type == sf::Event::MouseButtonReleased)
	{
	+ std::cout << "Hello " << std::endl;
	+
	if (event.mouseButton.button == sf::Mouse::Left)
	{
	- if (currentState==state_menu)
	- {

	- }

	if (currentState==state_game)
	{
	if (currentNeighbours.find(mousePos) != currentNeighbours.end())
	{
	// std::cout << "SUPER" << std::endl;
	- if (!guiSelectBuilding.active)
	+ if ((!guiSelectBuilding.active) && (showPlayerBoardElems))
	{
	float hover_x =localPosition.x;
	float hover_y = localPosition.y;
	if (localPosition.y > 290)
	hover_y = hover_y - 100;
	if (localPosition.x > 240)
	hover_x = hover_x - 150;
	if (hover_x>250)
	hover_x = 249.0f;
	if (hover_x<0)
	hover_x = 1.0f;
	if (hover_y>300)
	hover_y = 299.0f;
	if (hover_y<0)
	hover_y = 1.0f;
	+
	selectedPos = mousePos;
	guiSelectBuilding.setPosition(hover_x, hover_y);
	guiSelectBuilding.active = true;
	sfxClick.play();
	currentState = state_gui_elem;
	}
	break;
	}

	resultCommand = players[turn].getElem(localPositionGui);
	// std::cout << result << " hello" << turn << std::endl;
	command(resultCommand);


	+
	// nextPlayer();
	}

	if (currentState==state_gui_elem)
	{
	resultCommand = guiSelectBuilding.getElem(localPosition);
	if (resultCommand.find("elem_")==0)
	{
	std::string resultCommandWrapped = "build_" + resultCommand;
	command(resultCommandWrapped);
	} else if (resultCommand.find("close_gui")==0)
	{ command(resultCommand);}
	}
	+ if (currentState==state_menu)
	+ {
	+ std::cout << "Hello 2" << std::endl;
	+ hideMenu();
	+ showGameBoard();
	+
	+
	+ }

	}
	}
	if ((localPosition.x>=0) && (localPosition.y>=0) && (localPosition.x<=efc::BOARD_SIZEefc::TILE_SIZE) && (localPosition.y<=efc::BOARD_SIZEefc::TILE_SIZE))
	{
	selector.setPosition((int) (localPosition.x / efc::TILE_SIZE)efc::TILE_SIZE, ((int) localPosition.y / efc::TILE_SIZE)efc::TILE_SIZE);
	}
	}





	render();
	}
	}

	void Game::nextPlayer(){
	players[turn].updatePlayer();
	turn++;

	if (turn==4)
	turn = 0;
	selector.changeColor(turn);
	for (int i=0;i<4;i++)
	{
	if (i==turn)
	{
	players[i].setActive(true);
	currentNeighbours = players[i].getNeighbours();
	}
	else
	players[i].setActive(false);
	}
	- sfxClick.play();
	+ sfxClick.play();
	}

	void Game::drawPlayersGui(){
	for (int i=0;i<4;i++)
	{
	window.draw(players[i]);
	}
	}

	void Game::drawSquares() {
	- window.draw(selector);
	+ if (showPlayerBoardElems)
	+ {
	+
	+ window.draw(selector);
	+ }

	}



	void Game::update()
	{

	}

	void Game::render()
	{
	window.clear();
	if (currentState==state_game)
	{
	window.setView(viewTiles);
	window.draw(map);
	for (int i=0;i<4;i++)
	{
	window.draw(players[i].elems);
	}
	drawSquares();
	window.setView(viewGui);
	drawPlayersGui();
	+ window.setView(viewTiles);
	+ window.draw(guiSelectBuilding);

	} else if (currentState==state_gui_elem) {
	window.setView(viewTiles);
	window.draw(map);
	for (int i=0;i<4;i++)
	{
	window.draw(players[i].elems);
	}
	// window.draw(selector);
	window.setView(viewGui);
	drawPlayersGui();
	+ window.setView(viewTiles);
	+ window.draw(guiSelectBuilding);
	+ } else if (currentState==state_menu) {
	+
	+window.draw(menuBackground);
	+ window.draw(menuTxt);
	+
	+
	}
	- window.setView(viewTiles);
	- window.draw(guiSelectBuilding);
	+
	window.display();
	}

	void Game::command(std::string command){
	-// std::cout << command << std::endl;
	+ // std::cout << command << std::endl;
	if (command=="close_gui")
	{
	guiSelectBuilding.active = false;
	currentState=state_game;
	sfxClick.play();




	}

	if (command=="hide_gui_elem_description")
	{
	if (currentState==state_gui_elem) {
	guiSelectBuilding.descriptionActive = false;

	}
	}

	if (command.find("elem_")==0)
	{
	if (currentState==state_gui_elem)
	{
	-
	int buildingType = std::stoi(command.substr(5));
	-
	-
	int cashUpd = textures.tilesDescription[buildingType][0];
	int foodUpd = textures.tilesDescription[buildingType][2];
	int enrgUpd = textures.tilesDescription[buildingType][4];
	std::string descTxt = textures.tilesTxt[buildingType];
	guiSelectBuilding.setDescriptionTxt("Cash:" + std::to_string(cashUpd) +"\n"+descTxt);
	guiSelectBuilding.descriptionActive = true;
	-
	}
	}

	if (command=="end_turn")
	nextPlayer();
	if (command.find("build_")==0)
	{
	int buildingType = std::stoi(command.substr(11));
	bool purchaseResult = players[turn].addElem(selectedPos, buildingType);
	if (purchaseResult)
	{
	currentState = state_game;
	setCurrentNeighbours();
	guiSelectBuilding.active = false;
	sfxClick.play();



	}
	}
	}

	sf::Vector2f Game::getMousePos(){
	sf::Vector2i mousePosTmp(sf::Mouse::getPosition(window));
	sf::Vector2f mousePosition(window.mapPixelToCoords(mousePosTmp,viewTiles));
	return mousePosition;
	}


	}

	diff --git a/game.h b/game.h
	index e6052db..cc5f706 100644
	--- a/game.h
	+++ b/game.h
	@@ -1,77 +1,103 @@
	#ifndef GAME_H
	#define GAME_H
	#include <stdlib.h>
	#include <iostream>
	#include <time.h> /* time */
	#include <SFML/Window.hpp>
	#include <SFML/Graphics.hpp>
	#include <SFML/Audio.hpp>
	#include "tilemap.h"
	#include "selector.h"
	#include "playerhud.h"
	#include "textureholder.h"
	#include "hover.h"
	#include "guichoosebuilding.h"
	#include "guiwindow.h"

	namespace efc {
	+
	+
	+
	+
	+
	+
	class Game
	{
	public:
	Game();
	sf::RenderWindow window;
	sf::View viewTiles;


	private:
	void initBoard();
	void loadAssets();
	void drawPlayersGui();
	+ void drawSquares();
	+
	+ void drawMenu();
	+
	sf::Vector2f getMousePos();

	enum states {
	state_init,
	state_menu,
	state_game,
	state_gui_elem,
	state_select_building,
	state_quit
	};

	states currentState;

	sf::Texture textureTiles;
	sf::Texture textureFaces;
	sf::Font gameFont;
	+ sf::Font menuFont;
	+ sf::Text menuTxt;
	+
	+ std::string gameTitle;
	+

	TileMap map;
	PlayerHud players[4];

	int mapSize;
	int level[256];
	int levelElems[256];
	TextureHolder textures;
	std::set<int> currentNeighbours;
	void command(std::string command);
	int selectedPos;
	int turn;
	void update();
	void render();
	sf::View viewGui;
	Selector selector;
	sf::View viewFull;

	GuiChooseBuilding guiSelectBuilding;
	void setCurrentNeighbours ();
	void nextPlayer();

	- void drawSquares();
	+
	+ sf::Sprite menuBackground;


	sf::Music musicGame;
	+ sf::Music musicBackground;
	+ sf::Music musicMenu;
	+
	sf::SoundBuffer sfxClickBuffer;
	sf::Sound sfxClick;
	+ void showMenu();
	+ void hideMenu();
	+ void showGameBoard();
	+ void hideGameBoard();
	+
	+
	+ bool showPlayerBoardElems;

	};
	}
	#endif // GAME_H
	diff --git a/playerhud.cpp b/playerhud.cpp
	index 5f04728..d7ceadc 100644
	--- a/playerhud.cpp
	+++ b/playerhud.cpp
	@@ -1,213 +1,234 @@
	#include "playerhud.h"
	#include "textureholder.h"
	#include "boardelem.h"

	bool PlayerHud::addElem(int pos, int type) {
	int price = textures->tilesDescription[type][0];


	if (price<=cash)
	{
	efc::BoardElem startElem(textures, pos,type);
	startElem.setColor(efc::playersColors[this->pos]);
	elems.items.push_back(startElem);
	elems.items_map.insert({pos, startElem});

	cash -= price;
	updateTxt();
	return true;
	}
	return false;
	}

	+std::set<int> PlayerHud::getTerrainSet(){
	+ std::set<int> terrain;
	+ for (int i: efc::terrain)
	+ {
	+// std::cout << i << std::endl;
	+ terrain.insert(i);
	+ }
	+ return terrain;
	+
	+}
	+
	+
	std::set<int> PlayerHud::getNeighbours(){
	std::set<int> neighbours;
	for (std::pair<int, efc::BoardElem> i: elems.items_map)
	{
	+ std::set<int> terrain = getTerrainSet();

	std::set<int> neighboursVector(efc::getNeighbours(i.second.pos));
	for (int j: neighboursVector)
	{
	- if (elems.items_map.count(j) == 0)
	+ if ((elems.items_map.count(j) == 0) && (terrain.count(j)==0))
	{
	+ std::cout << j << " " << terrain.count(j) << std::endl;
	neighbours.insert(j);
	}
	}
	}
	+
	+// // Fill in s1 and s2 with values
	+// std::set<int> result;
	+// std::set_difference(neighbours.begin(), neighbours.end(), terrain.begin(), terrain.end(),
	+// std::inserter(result, result.end()));
	+
	+
	+// for (int i: result)
	+// {
	+// std::cout << i << std::endl;
	+// }
	return neighbours;
	}

	void PlayerHud::updateTxt(){
	txtCash.setString( "Cash: " + std::to_string(cash));
	txtFood.setString( "Food: " + std::to_string(food));
	txtEnergy.setString("Enrg: " + std::to_string(energy));
	txtFaith.setString( "Gods: " + std::to_string(faith));

	}


	void PlayerHud::updatePlayer(){
	for (const efc::BoardElem &i: elems.items)
	{
	int cashUpd = textures->tilesDescription[i.type][1];
	int foodUpd = textures->tilesDescription[i.type][3];
	int enrgUpd = textures->tilesDescription[i.type][5];
	int faithUpd = textures->tilesDescription[i.type][7];

	cash += cashUpd;
	energy += enrgUpd;
	food += foodUpd;
	faith += faithUpd;
	updateTxt();
	}
	}

	PlayerHud::PlayerHud()
	{
	- active = false;
	- food = 0;
	- cash = 10;
	- energy = 0;
	- faith = 0;
	+
	}

	void PlayerHud::setActive(bool newState){
	active = newState;
	elems.active = newState;
	}

	PlayerHud::PlayerHud(TextureHolder textures, int faceNumber, sf::Font gameFont, int faceSize, int pos)
	{
	active = false;
	this->textures = textures;
	efc::BoardElem startElem(textures, startPlayers[pos],444);
	startElem.setColor(efc::playersColors[pos]);

	elems.items.push_back(startElem);
	elems.items_map.insert({startPlayers[pos], startElem});
	this->faceSize = faceSize;
	spriteFace.setTexture(textures->textureFaces);
	this->pos = pos;

	food = 0;
	- cash = 10;
	+ cash = 20;
	energy = 0;
	faith = 0;

	int x = faceNumber % 10;
	int y = (int) faceNumber /10;

	txtCash.setFont(*gameFont);
	txtFood.setFont(*gameFont);
	txtEnergy.setFont(*gameFont);
	txtFaith.setFont(*gameFont);

	txtNextRound.setFont(*gameFont);
	txtNextRound.setString("End Turn");
	txtNextRound.setScale(sf::Vector2f(0.25f, 1.f));
	txtNextRound.setCharacterSize(10);
	txtNextRound.setPosition(9,(pos*100)+10);

	txtCash.setPosition(1,(pos*100)+40);
	-// txtCash.setString("Cash: " + std::to_string(cash));
	+ // txtCash.setString("Cash: " + std::to_string(cash));
	txtCash.setCharacterSize(10);
	txtCash.setScale(sf::Vector2f(0.25f, 1.f));

	txtFood.setPosition(1,(pos*100)+55);
	-// txtFood.setString("Food: " + std::to_string(food));
	+ // txtFood.setString("Food: " + std::to_string(food));
	txtFood.setCharacterSize(10);
	txtFood.setScale(sf::Vector2f(0.25f, 1.f));

	txtEnergy.setPosition(1,(pos*100)+70);
	-// txtEnergy.setString("Enrg: " + std::to_string(energy));
	+ // txtEnergy.setString("Enrg: " + std::to_string(energy));
	txtEnergy.setCharacterSize(10);
	txtEnergy.setScale(sf::Vector2f(0.25f, 1.f));

	txtFaith.setPosition(1,(pos*100)+85);
	-// txtEnergy.setString("Enrg: " + std::to_string(energy));
	+ // txtEnergy.setString("Enrg: " + std::to_string(energy));
	txtFaith.setCharacterSize(10);
	txtFaith.setScale(sf::Vector2f(0.25f, 1.f));
	updateTxt();

	spriteFace.setTextureRect(sf::IntRect(xfaceSize, yfaceSize, faceSize, faceSize));
	spriteFace.setScale(sf::Vector2f(0.25f, 1.f));
	spriteFace.setPosition(0,pos*100);


	rectangle.setSize(sf::Vector2f(this->faceSize, this->faceSize));
	rectangle2.setSize(sf::Vector2f(this->faceSize, (this->faceSize*2)+3));

	if (pos==0)
	{
	rectangle.setFillColor(sf::Color(50, 50, 150,168));
	rectangle2.setFillColor(sf::Color(100, 100, 150,168));
	rectangle.setOutlineColor(sf::Color(0,0,128));
	}
	else if (pos==1)
	{
	rectangle.setFillColor(sf::Color(50, 150, 50,168));
	rectangle2.setFillColor(sf::Color(100, 150,100,168));
	rectangle.setOutlineColor(sf::Color(0,128,0));
	}

	else if (pos==2)
	{
	rectangle.setFillColor(sf::Color(150, 50, 50,168));
	rectangle2.setFillColor(sf::Color(150, 100,100,168));
	rectangle.setOutlineColor(sf::Color(128,0,0));
	}
	else if (pos==3)
	{
	rectangle.setFillColor(sf::Color(150, 150, 150,168));
	rectangle2.setFillColor(sf::Color(200, 200,200,168));
	rectangle.setOutlineColor(sf::Color(128,128,128));
	}


	rectangle.setOutlineThickness(1);
	rectangle.setPosition(0, pos*100);
	rectangle2.setPosition(0, (pos*100)+faceSize+1);

	buttons.insert({"end_turn",rectangle});

	}

	std::string PlayerHud::getElem(sf::Vector2f mousePosition) {
	std::string result = "";
	sf::Vector2f hoverPos = getPosition();
	for (std::pair<std::string, sf::RectangleShape> i: buttons)
	{
	sf::FloatRect spriteBounds = i.second.getLocalBounds();
	sf::FloatRect closeRect;
	closeRect.left = i.second.getPosition().x;
	closeRect.top = i.second.getPosition().y;
	closeRect.width = spriteBounds.width;
	closeRect.height = spriteBounds.height;
	if (closeRect.contains(mousePosition.x - hoverPos.x,mousePosition.y - hoverPos.y))
	{
	return i.first;
	}
	}
	return result;
	}

	void PlayerHud::draw(sf::RenderTarget& target, sf::RenderStates states) const
	{
	// // apply the transform
	states.transform *= getTransform();
	// Color rectangles making the gui on the right side
	-// sf::RectangleShape rectangle(sf::Vector2f(faceSize, faceSize));
	-// sf::RectangleShape rectangle2(sf::Vector2f(faceSize, (faceSize*2)+3));
	+ // sf::RectangleShape rectangle(sf::Vector2f(faceSize, faceSize));
	+ // sf::RectangleShape rectangle2(sf::Vector2f(faceSize, (faceSize*2)+3));


	target.draw(rectangle, states);
	target.draw(rectangle2, states);
	target.draw(txtCash, states);
	target.draw(txtFood, states);
	target.draw(txtEnergy, states);
	target.draw(txtFaith, states);

	if (active)
	target.draw(txtNextRound, states);
	target.draw(spriteFace, states);
	}
	diff --git a/playerhud.h b/playerhud.h
	index 228062b..4734192 100644
	--- a/playerhud.h
	+++ b/playerhud.h
	@@ -1,62 +1,65 @@
	#ifndef PLAYERHUD_H
	#define PLAYERHUD_H
	#include <iostream>
	#include <set>
	#include <SFML/Window.hpp>
	#include <SFML/Graphics.hpp>
	#include <SFML/System.hpp>
	#include "boardelems.h"
	#include "textureholder.h"
	#include "elemsdescription.h"
	#include "guiwindow.h"

	static int startPlayers[4] = {0,15,240,255};

	namespace efc {
	static sf::Color playersColors[4] = {
	sf::Color(50, 50,230,255),
	sf::Color(50, 230,50,255),
	sf::Color(230, 50,50,255),
	sf::Color(150, 150,150,255)
	};

	}


	class PlayerHud : public sf::Drawable, public sf::Transformable
	{
	public:
	PlayerHud();
	PlayerHud(TextureHolder textures, int faceNumber, sf::Font gameFont, int tileSize, int pos);
	virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const;
	std::set<int> getNeighbours();
	int pos;
	int cash;
	int energy;
	int food;
	int faith;
	bool active;
	BoardElems elems;
	void setActive(bool newState);
	std::vector<int> properties;
	bool addElem(int pos, int type);
	void updatePlayer();
	std::string getElem(sf::Vector2f mousePosition);
	std::map<std::string, sf::RectangleShape> buttons;
	void updateTxt();

	private:
	sf::Sprite spriteFace;
	sf::Text txtCash;
	sf::Text txtEnergy;
	sf::Text txtFood;
	sf::Text txtFaith;
	sf::Text txtNextRound;
	int faceSize;
	int tileSize;
	TextureHolder *textures;
	sf::RectangleShape rectangle;
	sf::RectangleShape rectangle2;
	+ std::set<int> getTerrainSet();
	+
	};

	+
	#endif // PLAYERHUD_H
	diff --git a/textureholder.cpp b/textureholder.cpp
	index 72e2d5c..6f7d1f1 100644
	--- a/textureholder.cpp
	+++ b/textureholder.cpp
	@@ -1,66 +1,69 @@
	#include "textureholder.h"

	TextureHolder::TextureHolder()
	{
	if (!textureTiles.loadFromFile("assets/img/zw-tilesets/_MAP.png"))
	std::exit(1);
	if (!textureFaces.loadFromFile("assets/img/faces.jpg"))
	std::exit(1);
	if (!textureGui.loadFromFile("assets/img/gui.png"))
	std::exit(1);

	+ if (!textureMenu.loadFromFile("assets/img/menu.jpg"))
	+ std::exit(1);
	+
	int defaultArray[5][8] = {
	//Cash Food Energy Faith
	{10, 2, 0, 0, 0, 0, 0, 0}, // base
	{10, 1, 2, 0, 0, 5, 0, 0}, // windmill
	{15, 0, 0, 2, 2, 0, 0, 0}, // granary
	{20, 5, 4, 0, 4, 0, 0, 0}, // marketplace
	{5, 0, 2, 0, 0, 0, 0, 2} // monasterium
	};
	int defaultFields[5] = {443, 651, 442, 585, 1100};


	/*
	* Array with description of the field
	* global rule = even indexes are price, odd - monthly cost
	* [0] - price in cash
	* [1] - monthly cash cost
	* [2] - price - in food
	* [3] - monthly food cost
	* [4] - price in energy
	* [5] - monthly energy cost
	* [6] - price in faith
	* [7] - monthly cost in faith
	*
	*/

	int counter = 0;
	for (int i: defaultFields)
	{
	std::map<int, int> params;
	for (int j=0;j<8;j++)
	{
	params.insert({j, defaultArray[counter][j]});
	}
	// params.insert({0, 10});
	// params.insert({1, 2});
	// params.insert({2, 10});
	// params.insert({3, 0});
	// params.insert({4, 10});
	// params.insert({5, 0});
	// params.insert({6, 0});
	// params.insert({7, 0});
	tilesDescription.insert({i, params});
	counter++;
	};
	tilesTxt.insert({443, "Your base."});
	tilesTxt.insert({651, "Windmill, produces energy."});
	tilesTxt.insert({442, "Granary, increases food\nresources."});
	tilesTxt.insert({585, "Marketplace, generates cash"});
	tilesTxt.insert({1100, "Monasterium, brings you luck"});





	}
	diff --git a/textureholder.h b/textureholder.h
	index ed9f6e8..6debea6 100644
	--- a/textureholder.h
	+++ b/textureholder.h
	@@ -1,19 +1,42 @@
	#ifndef TEXTUREHOLDER_H
	#define TEXTUREHOLDER_H
	+#include <set>
	#include <SFML/Window.hpp>
	#include <SFML/Graphics.hpp>
	+namespace efc {
	+static int terrain[24] = {
	+ 8, 24, 40, 56, 72, 88,
	+ 113, 114, 115, 116, 117, 118,
	+ 138, 139, 140, 141, 142, 143,
	+ 167, 183, 199, 215, 231, 247
	+};
	+
	+
	+static std::set<int> getTerrainSet() {
	+ std::set<int> terrain;
	+ for (int i: efc::terrain)
	+ {
	+ terrain.insert(i);
	+ }
	+ return terrain;
	+}
	+
	+}
	+
	+
	+
	class TextureHolder
	{
	public:
	TextureHolder();
	sf::Texture textureTiles;
	sf::Texture textureFaces;
	sf::Texture textureGui;
	-
	+ sf::Texture textureMenu;

	std::map<int, std::map<int, int>> tilesDescription;
	std::map<int, std::string> tilesTxt;

	};

	#endif // TEXTUREHOLDER_H
	diff --git a/tilemap.cpp b/tilemap.cpp
	index a80ce9d..8422978 100644
	--- a/tilemap.cpp
	+++ b/tilemap.cpp
	@@ -1,119 +1,142 @@
	#include "tilemap.h"
	namespace efc {

	sf::Vector2i transPosition(int pos) {
	int x = (int) pos % efc::BOARD_SIZE;
	int y = (int) pos / efc::BOARD_SIZE;
	sf::Vector2i cords(x,y);

	return cords;
	}

	sf::Vector2i transTilePosition(int pos) {
	int x = (int) pos % efc::TILE_BOARD_SIZE;
	int y = (int) pos / efc::TILE_BOARD_SIZE;
	sf::Vector2i cords(x,y);

	return cords;
	}

	int transCords(sf::Vector2i cords) {
	-// std::cout << cords.x << " " << cords.y << " " << std::endl;
	+ // std::cout << cords.x << " " << cords.y << " " << std::endl;
	int pos = (cords.y * efc::BOARD_SIZE)+cords.x;
	return pos;
	}

	sf::IntRect transPosIntoRect(int pos)
	{
	sf::Vector2i cords = efc::transTilePosition(pos);
	sf::IntRect posRect((int)cords.xefc::TILE_SIZE, (int)cords.yefc::TILE_SIZE, efc::TILE_SIZE, efc::TILE_SIZE);
	-// std::cout << "debug transPosIntoRect " << pos << " "<< cords.x << " " << cords.y << " " << posRect.left << " " << posRect.top << std::endl;
	+ // std::cout << "debug transPosIntoRect " << pos << " "<< cords.x << " " << cords.y << " " << posRect.left << " " << posRect.top << std::endl;
	return posRect;
	}

	std::set<int> getNeighbours(int pos) {
	sf::Vector2i cords = efc::transPosition(pos);



	std::vector<int> neighbours;
	std::set<int> neighboursSet;

	+ std::set<int> terrain = efc::getTerrainSet();
	+
	+
	+ int value = -1;
	+
	if (cords.x>0)
	{
	neighbours.push_back(pos-1);
	- neighboursSet.insert(pos-1);
	+ // neighboursSet.insert(pos-1);
	+ value = pos-1;
	+ if ((value!=-1) && (terrain.count(value)==0))
	+ neighboursSet.insert(value);
	+
	+
	}
	if (cords.x<efc::BOARD_SIZE-1)
	{
	neighbours.push_back(pos+1);
	- neighboursSet.insert(pos+1);
	+ // neighboursSet.insert(pos+1);
	+ value = pos+1;
	+ if ((value!=-1) && (terrain.count(value)==0))
	+ neighboursSet.insert(value);
	}

	if (cords.y>0)
	{
	neighbours.push_back(pos-efc::BOARD_SIZE);
	- neighboursSet.insert(pos-efc::BOARD_SIZE);
	+ // neighboursSet.insert(pos-efc::BOARD_SIZE);
	+ value = pos-efc::BOARD_SIZE;
	+ if ((value!=-1) && (terrain.count(value)==0))
	+ neighboursSet.insert(value);
	}
	if (cords.y<efc::BOARD_SIZE)
	{
	neighbours.push_back(pos+efc::BOARD_SIZE);
	- neighboursSet.insert(pos+efc::BOARD_SIZE);
	+ // neighboursSet.insert(pos+efc::BOARD_SIZE);
	+ value = pos+efc::BOARD_SIZE;
	+ if ((value!=-1) && (terrain.count(value)==0))
	+ neighboursSet.insert(value);
	}
	- return neighboursSet;
	+
	+
	+
	+
	+ return neighboursSet;
	}
	}

	TileMap::TileMap()
	{
	}

	bool TileMap::load(TextureHolder textures, sf::Vector2u tileSize, const int tiles, unsigned int width, unsigned int height)
	{
	this->m_tileset = &textures->textureTiles;
	// resize the vertex array to fit the level size
	m_vertices.setPrimitiveType(sf::Quads);
	m_vertices.resize(width * height * 4);

	// populate the vertex array, with one quad per tile
	for (unsigned int i = 0; i < width; ++i)
	for (unsigned int j = 0; j < height; ++j)
	{
	// get the current tile number
	int tileNumber = tiles[i + j * width];

	// find its position in the tileset texture
	int tu = tileNumber % (m_tileset->getSize().x / tileSize.x);
	int tv = tileNumber / (m_tileset->getSize().x / tileSize.x);

	// get a pointer to the current tile's quad
	sf::Vertex* quad = &m_vertices[(i + j * width) * 4];

	// define its 4 corners
	quad[0].position = sf::Vector2f(i * tileSize.x, j * tileSize.y);
	quad[1].position = sf::Vector2f((i + 1) * tileSize.x, j * tileSize.y);
	quad[2].position = sf::Vector2f((i + 1) * tileSize.x, (j + 1) * tileSize.y);
	quad[3].position = sf::Vector2f(i * tileSize.x, (j + 1) * tileSize.y);

	// define its 4 texture coordinates
	quad[0].texCoords = sf::Vector2f(tu * tileSize.x, tv * tileSize.y);
	quad[1].texCoords = sf::Vector2f((tu + 1) * tileSize.x, tv * tileSize.y);
	quad[2].texCoords = sf::Vector2f((tu + 1) * tileSize.x, (tv + 1) * tileSize.y);
	quad[3].texCoords = sf::Vector2f(tu * tileSize.x, (tv + 1) * tileSize.y);
	}
	return true;
	}

	void TileMap::draw(sf::RenderTarget& target, sf::RenderStates states) const
	{
	// apply the transform
	states.transform *= getTransform();
	// apply the tileset texture
	states.texture = m_tileset;

	// draw the vertex array
	target.draw(m_vertices, states);
	}

	sf::VertexArray m_vertices;
	sf::Texture m_tileset;

File Metadata

Mime Type: text/x-diff
Expires: Mon, Feb 2, 9:09 PM (2 d, 1 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 55581
Default Alt Text: (35 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions