No OneTemporary
Actions

Size

29 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/character.cpp b/character.cpp
	index 7782cfd..a1aa401 100644
	--- a/character.cpp
	+++ b/character.cpp
	@@ -1,173 +1,174 @@
	#include "character.h"



	void Character::setDir(int direction)
	{
	if (direction==efc::DIR_LEFT)
	currentAnimation = &walkingAnimationLeft;
	}



	void Character::setDir()
	{
	setDir(currentAnimationIndex);
	}

	void Character::setDirIndex(int direction)
	{
	currentAnimationIndex = direction;
	}


	void Character::play()
	{
	// animatedSprite.play(*currentAnimation);
	animatedSprite.play(animations[currentAnimationIndex]);
	sf::Vector2f a(getPosition());
	sf::Vector2i position(efc::getCords(a));
	std::cout << a.x << " " << a.y << " " << position.x << " " << position.y << "" << efc::transCords(position) << std::endl;
	}

	Character::Character(TextureHolder *textures, int playerNumber):
	animatedSprite(sf::seconds(0.2), true, false),
	nextRedirect(0.f)

	{

	this->textures = textures;
	int offset = playerNumber*16;

	walkingAnimationDown.setSpriteSheet(textures->textureCharacters);
	walkingAnimationDown.addFrame(sf::IntRect(offset, 0, 16, 24));
	walkingAnimationDown.addFrame(sf::IntRect(offset, 23, 16, 24));

	walkingAnimationRight.setSpriteSheet(textures->textureCharacters);
	walkingAnimationRight.addFrame(sf::IntRect(offset, 48, 16, 24));
	walkingAnimationRight.addFrame(sf::IntRect(offset, 72, 16, 24));

	walkingAnimationLeft.setSpriteSheet(textures->textureCharacters);
	walkingAnimationLeft.addFrame(sf::IntRect(offset, 96, 16, 24));
	walkingAnimationLeft.addFrame(sf::IntRect(offset, 120, 16, 24));

	walkingAnimationUp.setSpriteSheet(textures->textureCharacters);
	walkingAnimationUp.addFrame(sf::IntRect(offset, 144, 16, 24));
	walkingAnimationUp.addFrame(sf::IntRect(offset, 168, 16, 24));

	currentAnimation = &walkingAnimationRight;


	animations[efc::DIR_LEFT] = walkingAnimationLeft;
	animations[efc::DIR_RIGHT] = walkingAnimationRight;
	animations[efc::DIR_UP] = walkingAnimationUp;
	animations[efc::DIR_DOWN] = walkingAnimationDown;


	setDirIndex(efc::DIR_LEFT);
	setDir();

	- sf::Vector2f positions[4] = {sf::Vector2f(40, 40),sf::Vector2f(540, 40),sf::Vector2f(40, 440),sf::Vector2f(540, 440)};
	+ sf::Vector2f positions[4] = {
	+ sf::Vector2f(0, 0),
	+ sf::Vector2f(20, 40),
	+ sf::Vector2f(20, 240),
	+ sf::Vector2f(40, 240)
	+ };
	setPosition(positions[playerNumber]);


	}

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

	states.transform *= getTransform();
	target.draw(animatedSprite, states);

	}

	void Character::update(sf::Time deltaTime, std::set<int> &busyTiles)
	{



	sf::Vector2f a(getPosition());
	sf::Vector2i position(efc::getCords(a));

	int charPos = efc::transCords(position);

	// std::cout << a.x << " " << a.y << " " << position.x << " " << position.y << " " << charPos << std::endl;

	nextRedirect -= deltaTime.asSeconds();

	if (nextRedirect<0)
	{
	int number = rand() % 2;
	if ((currentAnimationIndex==efc::DIR_LEFT) \|\| (currentAnimationIndex==efc::DIR_RIGHT))
	{
	if (number==0){
	setDirIndex(efc::DIR_DOWN);
	setDir();
	} else if (number==1)
	{
	setDirIndex(efc::DIR_UP);
	setDir();
	}
	} else if ((currentAnimationIndex==efc::DIR_UP) \|\| (currentAnimationIndex==efc::DIR_DOWN))
	{
	if (number==0){
	setDirIndex(efc::DIR_LEFT);
	setDir();
	} else if (number==1)
	{
	setDirIndex(efc::DIR_RIGHT);
	setDir();
	}
	}

	nextRedirect = rand() % 4;

	}

	-
	-
	if (currentAnimationIndex==efc::DIR_UP)
	{
	if (position.y<2)
	{
	setDirIndex(efc::DIR_DOWN);
	setDir();
	}
	} else if (currentAnimationIndex==efc::DIR_DOWN)
	{
	if (position.y>efc::BOARD_SIZE-1)
	{
	setDirIndex(efc::DIR_UP);
	setDir();
	}
	} else if (currentAnimationIndex==efc::DIR_LEFT)
	{

	if (position.x<2)
	{
	setDirIndex(efc::DIR_RIGHT);
	setDir();
	}
	} else if (currentAnimationIndex==efc::DIR_RIGHT)
	{
	if (position.x>efc::BOARD_SIZE-1)
	{
	setDirIndex(efc::DIR_LEFT);
	setDir();
	}
	}
	-
	-
	animatedSprite.update(deltaTime);
	}

	sf::FloatRect Character::getLocalBounds() const
	{

	return sf::FloatRect(0.f, 0.f, 0, 0);
	}

	sf::FloatRect Character::getGlobalBounds() const
	{
	return getTransform().transformRect(getLocalBounds());
	}
	diff --git a/character.h b/character.h
	index bf781fe..46dc270 100644
	--- a/character.h
	+++ b/character.h
	@@ -1,41 +1,43 @@
	#ifndef CHARACTER_H
	#define CHARACTER_H
	#include <random>
	#include <iostream>
	#include "data.h"
	#include "textureholder.h"
	#include "animatedsprite.h"
	#include "tilemap.h"


	class Character: public sf::Drawable, public sf::Transformable
	{
	public:
	Character(TextureHolder *textures, int playerNumber);
	TextureHolder *textures;
	Animation walkingAnimationDown;
	Animation walkingAnimationUp;
	Animation walkingAnimationLeft;
	Animation walkingAnimationRight;
	Animation animations[4];
	Animation* currentAnimation;
	int currentAnimationIndex;

	AnimatedSprite animatedSprite;
	sf::FloatRect getLocalBounds() const;
	sf::FloatRect getGlobalBounds() const;
	void setDirUp();
	void setDirDown();
	void setDirLeft();
	void setDirRight();
	virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const;
	void update(sf::Time deltaTime, std::set<int>& busyTiles);
	void play();
	void setDir();
	void setDir(int direction);
	void setDirIndex(int direction);
	float nextRedirect;

	+ int tile_pos;
	+
	};

	#endif // CHARACTER_H
	diff --git a/game.cpp b/game.cpp
	index 66b7ed6..0668040 100644
	--- a/game.cpp
	+++ b/game.cpp
	@@ -1,679 +1,683 @@
	#include "game.h"

	namespace efc {

	int initScreenX = 1360;
	int initScreenY = 768;
	int currentSeason = 0;
	int month = 0;

	std::array<std::array<int,2>,256> boards = {
	{
	{0,1},{0,2},{1,3},{2,4},{3,5},{4,6},{5,12},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},{0,2},
	},
	};

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


	sfxClick.setBuffer(sfxClickBuffer);
	sfxDone.setBuffer(sfxDoneBuffer);

	spriteBackground.setTexture(textureBackground);
	spriteBackgroundDark.setTexture(textures.backgroundDark);
	spriteBackgroundDark.setPosition(568,000);

	viewTiles.setViewport(sf::FloatRect(0.04f,0.060f, 1.0f, 1.0f));
	viewGui.setViewport(sf::FloatRect(0.806f,0.066f, 1, 1));
	selector.changeColor(turn); //This is only for the test TODO: remove

	groupHud.setFont(&gameFont);
	groupHud.setSeason(currentSeason);
	groupHud.setRoundName(roundNumber);

	sf::IntRect seasonsRect[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)};

	sf::Sprite season1;
	season1.setTexture(textures.textureSeasons);
	season1.setTextureRect(seasonsRect[0]);
	season1.setPosition(0,400);
	season1.scale(sf::Vector2f(0.25f, 0.25f));
	season1.move(37.5, 30.5);
	season1.setColor(sf::Color(0,255,0,80));
	seasons[0] = season1;

	sf::Sprite season2;
	season2.setTexture(textures.textureSeasons);
	season2.setTextureRect(seasonsRect[1]);
	season2.setPosition(0,400);
	season2.scale(sf::Vector2f(0.25f, 0.25f));
	season2.move(37.5, 30.5);
	season2.setColor(sf::Color(200,200,50,80));
	seasons[1] = season2;

	sf::Sprite season3;
	season3.setTexture(textures.textureSeasons);
	season3.setTextureRect(seasonsRect[2]);
	season3.setPosition(0,400);
	season3.scale(sf::Vector2f(0.25f, 0.25f));
	season3.move(37.5, 30.5);
	season3.setColor(sf::Color(90,90,255,80));
	seasons[2] = season3;

	sf::Sprite season4;
	season4.setTexture(textures.textureSeasons);
	season4.setTextureRect(seasonsRect[3]);
	season4.setPosition(0,400);
	season4.scale(sf::Vector2f(0.25f, 0.25f));
	season4.move(37.5, 30.5);
	season4.setColor(sf::Color(255,0,0,80));
	seasons[3] = season4;


	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/VCR_OSD_MONO_1.001.ttf"))
	{
	std::exit(1);
	}
	if (!menuFont.loadFromFile("assets/fnt/VCR_OSD_MONO_1.001.ttf"))
	{
	std::exit(1);
	}

	if (!musicGame.openFromFile("assets/audio/game.ogg"))
	std::exit(1);
	if (!musicBackground.openFromFile("assets/audio/wind2.ogg"))
	std::exit(1);
	if (!musicMenu.openFromFile("assets/audio/menu.ogg"))
	std::exit(1);


	if (!sfxClickBuffer.loadFromFile("assets/audio/click.ogg"))
	std::exit(1);

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



	menuTxt.setFont(menuFont);
	menuTxt.setCharacterSize(60);
	menuTxt.setString(gameTitle);
	int width = menuTxt.getLocalBounds().width;
	int height = menuTxt.getLocalBounds().height;
	menuTxt.setPosition(400-(width/2),300-(height/2)-150);
	menuTxt.setColor(sf::Color(55, 255, 35, 85));


	}


	void Game::showMenu()
	{
	musicBackground.play();
	musicBackground.setLoop(true);
	menuBackground.setTexture(textures.textureMenu);
	musicMenu.play();
	musicMenu.setLoop(true);
	currentState = state_menu;
	}
	void Game::hideMenu()
	{
	musicMenu.stop();
	}

	void Game::showGameBoard()
	{
	musicGame.setVolume(20);
	musicGame.play();

	musicGame.setLoop(true);
	currentState = state_game;
	}

	void Game::handleLeftClick(sf::Vector2f pos,
	sf::Vector2f posGui, sf::Vector2f posFull, int mousePos) {
	if (currentState==state_game)
	{

	std::string resultCommand = players[turn].getElem(posGui);
	command(resultCommand);
	if (currentNeighbours.find(mousePos) != currentNeighbours.end())
	{

	if ((!guiSelectBuilding.active) && (showPlayerBoardElems))
	{
	float hover_x =posFull.x;
	float hover_y = posFull.y;
	if (pos.y > 290)
	hover_y = hover_y - 100;
	if (pos.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;

	- std::cout << hover_x << " " << hover_y << std::endl;
	- guiSelectBuilding.setPosition(guiStartPos[turn][0],guiStartPos[turn][1]);
	- guiSelectBuilding.active = true;
	- sfxClick.play();
	- currentState = state_gui_elem;
	+
	+ // Currently we are not goint to use it.
	+// std::cout << hover_x << " " << hover_y << std::endl;
	+// guiSelectBuilding.setPosition(guiStartPos[turn][0],guiStartPos[turn][1]);
	+// guiSelectBuilding.active = true;
	+// sfxClick.play();
	+// currentState = state_gui_elem;
	}
	}

	}

	else if (currentState==state_gui_elem)
	{
	std::string resultCommand = guiSelectBuilding.getElem(posFull);
	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)
	{
	std::string resultCommand = guiRoundDice.getElem(pos);
	command(resultCommand);


	}


	}

	void Game::hideGameBoard()
	{
	musicGame.play();

	}

	Game::Game():
	screenSize(efc::initScreenX,efc::initScreenY),
	window(sf::VideoMode(efc::initScreenX, efc::initScreenY), "Pagan Board"),
	viewFull(sf::FloatRect(00, 00, screenSize.x, screenSize.y)),
	viewGui(sf::FloatRect(00, 00, screenSize.x, screenSize.y)),
	viewTiles(sf::FloatRect(0, 0, 524, 458)),
	selector(efc::TILE_SIZE),
	guiSelectBuilding(&textures),
	character(&textures, 3),
	turn(0),
	gameTitle("pagan\nboard"),
	roundDice(players),
	roundNumber(1),
	guiRoundDice(&textures)
	{

	int gWidth = guiSelectBuilding.rectangle.getLocalBounds().width;
	int gHeight = guiSelectBuilding.rectangle.getLocalBounds().height;
	int borderLeft = 31;
	int borderRight = 28;
	int borderTop = 39;
	int borderBottom = 39;
	int guiWidth = 128;

	int guiStartPosTmp[4][2] = {
	{borderLeft+3,borderTop+2},
	{screenSize.x - guiWidth - borderRight - gWidth-4,borderTop+2},
	{borderLeft+3,screenSize.y-gHeight-borderBottom-4} ,
	{screenSize.x - guiWidth - borderRight - gWidth-4, screenSize.y-gHeight-borderBottom-4}};


	for (int i=0;i<4;i++)
	{
	for (int j=0;j<4;j++)
	guiStartPos[i][j] = guiStartPosTmp[i][j];

	}


	sf::Clock frameClock;


	guiRoundDice.active = true;
	showPlayerBoardElems = false;




	window.setVerticalSyncEnabled(true);
	Hover hover;
	GuiWindow guiWindow(&textures);

	std::srand (time(NULL));
	loadAssets();



	initBoard();
	showMenu();


	// run the main loop
	while (window.isOpen())
	{
	sf::Time frameTime = frameClock.restart();
	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);
	sf::Vector2f localPositionFull = window.mapPixelToCoords(localPositionTmp,viewFull);

	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(localPositionFull);
	showPlayerBoardElems = false;
	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)
	handleLeftClick(localPosition, localPositionGui,
	localPositionFull, mousePos);
	}
	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);
	}
	}

	update(frameTime);
	render();
	}
	}

	void Game::update(sf::Time frameTime) {
	for (int i=0;i<4;i++)
	{
	players[i].play();
	}


	for (int i=0;i<4;i++)
	{
	players[i].update(frameTime, busyTiles);
	}
	}

	void Game::nextRound() {
	turn = 0;
	std::string result = roundDice.drawRound();
	roundNumber += 1;
	- std::cout << "END OF ROUND " << roundNumber << " " << result << std::endl;
	+// std::cout << "END OF ROUND " << roundNumber << " " << result << std::endl;
	month++;
	if (month==13)
	month=1;
	if (month%4==0)
	currentSeason++;
	if (currentSeason>3)
	currentSeason=0;
	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();
	- std::cout << roundNumber << " " << roundNumber % 16 << std::endl;
	+// std::cout << roundNumber << " " << roundNumber % 16 << std::endl;
	groupHud.setRoundName(roundNumber);
	groupHud.setSeason(currentSeason);
	groupHud.setMonthName(month%4);
	setBusyTiles();

	}

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

	window.draw(seasons[currentSeason]);
	}

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

	window.draw(selector);
	}

	}

	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::drawCharacters(){
	- window.setView(viewFull);
	+// window.setView(viewFull);
	+ window.setView(viewTiles); // Yeah Katia's inspiration
	+
	for (int i=0;i<4;i++)
	{
	for (auto&& j: players[i].characters)
	{
	window.draw(j);
	}

	}
	}

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



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

	window.setView(viewTiles);



	drawBaseGame();
	drawCharacters();



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

	} else if (currentState==state_menu) {

	window.draw(menuBackground);
	window.draw(menuTxt);
	window.draw(groupHud);

	window.setView(viewFull);
	// window.draw(spriteBackgroundDark);


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


	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("end_of_round")==0)
	{
	std::string subResult = command.substr(13);
	- std::cout << "SUB RESULT " << subResult << std::endl;
	+// 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 cashCost = textures.tilesDescription[buildingType][1];
	// int foodUpd = textures.tilesDescription[buildingType][2];
	// int foodCost = textures.tilesDescription[buildingType][3];
	// int enrgUpd = textures.tilesDescription[buildingType][4];
	// int enrgCost = textures.tilesDescription[buildingType][5];
	std::string descTxt = textures.tilesTxt[buildingType];
	char priceTxtChar [100];

	std::string priceTxt = priceTxtChar;
	char costTxtChar [100];
	// int cx = snprintf ( costTxtChar, 100, "Cost: cash: %2d food: %2d energy: %2d \n", cashCost, foodCost, enrgCost);
	std::string costTxt = costTxtChar;
	guiSelectBuilding.setDescriptionTxt(priceTxt + costTxt + "\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;
	sfxDone.play();



	}
	}
	}

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



	void Game::setBusyTiles() {

	busyTiles.clear();
	for (int i: efc::terrainArray)
	{
	busyTiles.insert(i);
	}

	for (int i=0;i<4;i++)
	{
	for (int j:players[i].getBusy())
	{
	busyTiles.insert(j);
	}
	}





	}


	}

	diff --git a/guichoosebuilding.cpp b/guichoosebuilding.cpp
	index e7e1a35..036543a 100644
	--- a/guichoosebuilding.cpp
	+++ b/guichoosebuilding.cpp
	@@ -1,86 +1,85 @@
	#include "guichoosebuilding.h"
	#include "tilemap.h"

	GuiChooseBuilding::GuiChooseBuilding(TextureHolder *textures)
	:GuiWindow(textures),
	textureTiles(textures->textureTiles)
	{
	// this->textureTiles = &textures->textureGui;
	// std::cout << "constructor" <<std::endl;
	addBuilding("elem_651", 651);
	addBuilding("elem_442", 442);
	addBuilding("elem_585", 585);
	addBuilding("elem_1100", 1100);

	-
	description = "Description";
	guiElemTxt.setFont(guiElemFont);
	guiElemTxt.setCharacterSize(16);
	guiElemTxt.setColor(sf::Color(255,255,255,200));
	updateDescription();
	guiElemTxt.move(2,50);
	descriptionActive = false;
	rectangle.setSize(sf::Vector2f(400,200));
	bgdDark.setTextureRect((sf::IntRect)rectangle.getLocalBounds());
	spriteClose.setPosition(sf::Vector2f(rectangle.getLocalBounds().width-16,0));


	}

	void GuiChooseBuilding::updateDescription() {
	guiElemTxt.setString(description);
	}

	void GuiChooseBuilding::setDescriptionTxt(std::string newDescription) {
	description = newDescription;
	updateDescription();

	}

	void GuiChooseBuilding::addBuilding(std::string name, int pos){
	sf::Sprite newBuilding;

	newBuilding.setTexture(textureTiles);
	newBuilding.setTextureRect(efc::transPosIntoRect(pos));
	sf::Vector2f mod((buildings.size()efc::TILE_SIZE)+4(buildings.size()+1)+4,efc::TILE_SIZE);
	newBuilding.move(mod);
	buildings.insert({name, newBuilding});
	// std::cout << "size " << buildings.size() <<std::endl;
	}

	void GuiChooseBuilding::draw(sf::RenderTarget& target, sf::RenderStates states) const{
	if (active==true)
	{
	sf::RenderStates states2 = states;
	states2.transform *= getTransform();
	GuiWindow::draw(target, states);
	for (std::pair<std::string, sf::Sprite> i: buildings)
	{
	target.draw(i.second, states2);
	}
	if (descriptionActive)
	target.draw(guiElemTxt, states2);
	}
	}

	std::string GuiChooseBuilding::getElem(sf::Vector2f mousePosition) {
	std::string result = GuiWindow::getElem(mousePosition);
	if (result=="close_gui")
	return result;
	sf::Vector2f hoverPos = getPosition();
	for (std::pair<std::string, sf::Sprite> i: buildings)
	{
	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;
	}

	diff --git a/hover.cpp b/hover.cpp
	index 18f968f..f5be3d6 100644
	--- a/hover.cpp
	+++ b/hover.cpp
	@@ -1,41 +1,37 @@
	#include "hover.h"

	Hover::Hover()
	{
	-
	width = 150;
	height = 100;
	rectangle.setSize(sf::Vector2f(width, height));
	init();
	-
	}

	Hover::Hover(int width, int height)
	{
	-
	this->width = width;
	this->height = height;
	rectangle.setSize(sf::Vector2f(width, height));
	init();
	-
	}

	void Hover::init() {
	rectangle.setFillColor(sf::Color(230, 230, 233,218));
	rectangle.setOutlineColor(sf::Color(33,33,33));
	rectangle.setOutlineThickness(1);
	active = false;
	}

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

	// // draw the vertex array
	if (active==true)
	target.draw(rectangle, states);
	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Feb 4, 12:10 PM (4 h, 3 m ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 55600
Default Alt Text: (29 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions