No OneTemporary
Actions

Size

28 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/game.cpp b/game.cpp
	index fec20d3..b9b3343 100644
	--- a/game.cpp
	+++ b/game.cpp
	@@ -1,496 +1,515 @@
	#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;

	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), "Pagan Board"),
	viewTiles(sf::FloatRect(00, 00, 600, 522)),
	viewFull(sf::FloatRect(00, 00, 800, 600)),
	viewGui(sf::FloatRect(00, 00, 112, 522)),
	selector(efc::TILE_SIZE),
	guiSelectBuilding(&textures),
	turn(0),
	gameTitle(" PAgAN\nBOaRD "),
	roundDice(players),
	roundNumber(1),
	guiRoundDice(&textures)
	{

	if (!textureBackground.loadFromFile("assets/img/background.png"))
	std::exit(1);

	+
	+ spriteBackgroundDark.setTexture(textures.backgroundDark);
	+ spriteBackgroundDark.setPosition(568,000);
	+// spriteBackgroundDark.setColor(sf::Color(55,55,55,155));
	+
	spriteBackground.setTexture(textureBackground);

	guiRoundDice.active = true;
	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);


	if (!sfxClickBuffer.loadFromFile("assets/audio/click.ogg"))
	std::exit(1);
	sfxClick.setBuffer(sfxClickBuffer);
	window.setVerticalSyncEnabled(true);
	Hover hover;
	GuiWindow guiWindow(&textures);



	std::srand (time(NULL));
	loadAssets();
	viewTiles.setViewport(sf::FloatRect(0.04f,0.066f, 1.0f, 1.14f));
	viewGui.setViewport(sf::FloatRect(0.71f,0.066f, 1.04f, 1.14f));

	selector.changeColor(turn); //This is only for the test TODO: remove
	initBoard();
	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)
	{
	if (event.mouseButton.button == sf::Mouse::Left)
	{


	if (currentState==state_game)
	{


	resultCommand = players[turn].getElem(localPositionGui);
	command(resultCommand);

	if (currentNeighbours.find(mousePos) != currentNeighbours.end())
	{

	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;
	}





	// 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)
	{
	hideMenu();
	showGameBoard();


	}

	if (currentState==state_gui_end_round)
	{
	resultCommand = guiRoundDice.getElem(localPosition);
	command(resultCommand);


	}


	}
	}
	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::nextRound() {
	turn = 0;
	std::string result = roundDice.drawRound();
	roundNumber += 1;
	std::cout << "END OF ROUND " << roundNumber << " " << result << std::endl;
	command(result);
	}

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

	if (turn==4)
	{
	nextRound();
	}
	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();
	}

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

	void Game::drawSquares() {
	if (showPlayerBoardElems)
	{

	window.draw(selector);
	}

	}



	void Game::update()
	{

	}

	void Game::drawBaseGame()
	{
	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);
	}

	void Game::render()
	{
	window.clear();



	if (currentState==state_game)
	{
	+ window.setView(viewFull);
	+ window.draw(spriteBackgroundDark);
	+ window.setView(viewTiles);
	drawBaseGame();

	+
	} else if (currentState==state_gui_elem) {
	+ window.setView(viewFull);
	+ window.draw(spriteBackgroundDark);
	drawBaseGame();
	window.draw(guiSelectBuilding);
	+
	} else if (currentState==state_menu) {

	window.draw(menuBackground);
	window.draw(menuTxt);
	+// window.setView(viewFull);
	+// window.draw(spriteBackgroundDark);


	} else if (currentState==state_gui_end_round){
	+ window.setView(viewFull);
	+ window.draw(spriteBackgroundDark);
	drawBaseGame();
	window.draw(guiRoundDice);
	+// window.setView(viewFull);
	+// window.draw(spriteBackgroundDark);
	}
	window.setView(viewFull);
	+// window.draw(spriteBackgroundDark);
	window.draw(spriteBackground);

	window.display();
	}

	void Game::command(std::string command){
	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("end_of_round")==0)
	{
	std::string subResult = command.substr(13);
	std::cout << "SUB RESULT " << subResult << std::endl;
	guiRoundDice.active = true;
	guiRoundDice.setTitle(subResult);
	currentState = state_gui_end_round;
	}

	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 2ceb477..4e64e90 100644
	--- a/game.h
	+++ b/game.h
	@@ -1,118 +1,120 @@
	#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"
	#include "rounddice.h"
	#include "guirounddice.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_gui_end_round,
	state_quit
	};

	states currentState;

	sf::Texture textureBackground;
	sf::Sprite spriteBackground;
	+ sf::Sprite spriteBackgroundDark;
	+

	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;

	RoundDice roundDice;
	int roundNumber;


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

	void nextRound();


	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;
	void drawBaseGame();
	};
	}
	#endif // GAME_H
	diff --git a/enfucraft.pro b/pagan_board.pro
	similarity index 95%
	rename from enfucraft.pro
	rename to pagan_board.pro
	index 6bdbb2e..3d1897a 100644
	--- a/enfucraft.pro
	+++ b/pagan_board.pro
	@@ -1,49 +1,49 @@
	TEMPLATE = app
	CONFIG += console
	CONFIG -= app_bundle
	CONFIG -= qt
	CONFIG += c++11
	SOURCES += main.cpp \
	game.cpp \
	tilemap.cpp \
	selector.cpp \
	playerhud.cpp \
	boardelem.cpp \
	boardelems.cpp \
	textureholder.cpp \
	hover.cpp \
	guiwindow.cpp \
	purchaseguielem.cpp \
	guichoosebuilding.cpp \
	rounddice.cpp \
	guirounddice.cpp

	LIBS += -lsfml-window -lsfml-system -lsfml-graphics -lsfml-audio
	-DESTDIR = ../build_release_enfucraft
	+DESTDIR = ../build_release_pagan_board

	assets.path = $${DESTDIR}/assets
	assets.files = assets/*

	INSTALLS += assets

	HEADERS += \
	game.h \
	tilemap.h \
	selector.h \
	playerhud.h \
	boardelem.h \
	boardelems.h \
	textureholder.h \
	hover.h \
	guiwindow.h \
	purchaseguielem.h \
	guichoosebuilding.h \
	elemsdescription.h \
	rounddice.h \
	guirounddice.h

	RESOURCES += \
	images.qrc

	OTHER_FILES += \
	CREDITS.md
	diff --git a/playerhud.cpp b/playerhud.cpp
	index 73461eb..f569d7b 100644
	--- a/playerhud.cpp
	+++ b/playerhud.cpp
	@@ -1,254 +1,254 @@
	#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) && (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()
	{

	}

	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;


	symbol.setTexture(this->textures->textureSymbols);


	sf::IntRect symbolsRect[4] = {sf::IntRect(0,0,255,255), sf::IntRect(256,0,512,255), sf::IntRect(0,255, 255, 512), sf::IntRect(255,255,512, 512)};


	symbol.setTextureRect(symbolsRect[pos]);
	- symbol.setScale(sf::Vector2f(0.025f, 0.1f));
	- symbol.setColor(sf::Color(25, 25, 25, 55));
	+ symbol.setScale(sf::Vector2f(0.05f, 0.1f));
	+ symbol.setColor(sf::Color(25, 25, 25, 105));
	+ symbol.setPosition(12.5, (pos*100)+55);


	food = 0;
	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);


	- symbol.setPosition(15, (pos*100)+52);

	txtCash.setPosition(1,(pos*100)+40);
	// 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.setCharacterSize(10);
	txtFood.setScale(sf::Vector2f(0.25f, 1.f));

	txtEnergy.setPosition(1,(pos*100)+70);
	// 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));
	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));
	+ rectangle.setFillColor(sf::Color(50, 50, 200,68));
	+ rectangle2.setFillColor(sf::Color(100, 100, 150,38));
	+ rectangle.setOutlineColor(sf::Color(0,0,128,68));
	}
	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));
	+ rectangle.setFillColor(sf::Color(50, 150, 50,68));
	+ rectangle2.setFillColor(sf::Color(100, 150,100,38));
	+ rectangle.setOutlineColor(sf::Color(0,128,0,68));
	}

	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));
	+ rectangle.setFillColor(sf::Color(150, 50, 50,68));
	+ rectangle2.setFillColor(sf::Color(150, 100,100,38));
	+ rectangle.setOutlineColor(sf::Color(128,0,0,68));
	}
	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.setFillColor(sf::Color(150, 150, 150,68));
	+ rectangle2.setFillColor(sf::Color(200, 200,200,38));
	+ rectangle.setOutlineColor(sf::Color(128,128,128,68));
	}


	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;
	// std::cout << closeRect.left << " " << closeRect.top << " " << closeRect.width << " " << closeRect.height
	// << hoverPos.x << " " << hoverPos.y << " OK"
	// << std::endl;
	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));


	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(symbol, states);
	target.draw(spriteFace, states);
	}
	diff --git a/textureholder.cpp b/textureholder.cpp
	index acc6373..98410b6 100644
	--- a/textureholder.cpp
	+++ b/textureholder.cpp
	@@ -1,73 +1,76 @@
	#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 (!textureSymbols.loadFromFile("assets/img/symbols.png"))
	std::exit(1);

	+ if (!backgroundDark.loadFromFile("assets/img/background_dark.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"});





	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Feb 2, 9:07 PM (2 d, 14 m ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 55575
Default Alt Text: (28 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions