Page MenuHomePhabricator (Chris)
Files F131727

No OneTemporary
Actions

Authored By
Unknown
Size
110 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/src/boarddiamondseq.cpp b/src/boarddiamondseq.cpp
index 2b9c5b5..37e6a5d 100644
--- a/src/boarddiamondseq.cpp
+++ b/src/boarddiamondseq.cpp
@@ -1,138 +1,138 @@
#include "boarddiamondseq.h"
BoardDiamondSeq::BoardDiamondSeq(TextureHolder *textures)
{
this->textures = textures;
- for (int i=0; i<efc::diamondsNumber; i++)
+ for (int i=0; i<DP::diamondsNumber; i++)
{
diamonds[i] = BoardDiamond(this->textures,
- efc::DIAMONDS_SETUP[i][0],
- efc::DIAMONDS_SETUP[i][1],
- efc::DIAMONDS_SETUP[i][2]);
+ DP::DIAMONDS_SETUP[i][0],
+ DP::DIAMONDS_SETUP[i][1],
+ DP::DIAMONDS_SETUP[i][2]);
}
reorder();
}
void BoardDiamondSeq::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
states.transform *= getTransform();
- for (int i=0; i<efc::diamondsNumber; i++)
+ for (int i=0; i<DP::diamondsNumber; i++)
{
target.draw(diamonds[i],states);
}
}
-std::array<int,efc::diamondsNumber> BoardDiamondSeq::getBoardPositions()
+std::array<int,DP::diamondsNumber> BoardDiamondSeq::getBoardPositions()
{
- std::array<int, efc::diamondsNumber> results;
- for (int i=0; i<efc::diamondsNumber; i++)
+ std::array<int, DP::diamondsNumber> results;
+ for (int i=0; i<DP::diamondsNumber; i++)
{
results[i] = diamonds[i].getBoardPosition();
}
return results;
}
//bool BoardDiamondSeq::ifFieldIsEmpty(int pos, int element)
//{
-// for (int i=element*efc::diamondsNumber/4;i<(efc::diamondsNumber/4)+(element*efc::diamondsNumber/4);i++)
+// for (int i=element*DP::diamondsNumber/4;i<(DP::diamondsNumber/4)+(element*DP::diamondsNumber/4);i++)
// {
// if (diamonds[i].boardPosition==pos)
// return false;
// }
// return true;
//}
bool BoardDiamondSeq::ifFieldIsEmpty(int pos)
{
for (int element=0;element<4;element++)
{
- for (int i=element*efc::diamondsNumber/4;i<(efc::diamondsNumber/4)+(element*efc::diamondsNumber/4);i++)
+ for (int i=element*DP::diamondsNumber/4;i<(DP::diamondsNumber/4)+(element*DP::diamondsNumber/4);i++)
{
if (diamonds[i].boardPosition==pos)
return false;
}
}
return true;
}
int BoardDiamondSeq::getRandomPos(int playerNumber)
{
- std::set<int> setSteps(efc::occupiedFields[playerNumber].cbegin(), efc::occupiedFields[playerNumber].cend());
- for (int i=playerNumber*efc::diamondsNumber/4;i<(efc::diamondsNumber/4)+(playerNumber*efc::diamondsNumber/4);i++)
+ std::set<int> setSteps(DP::occupiedFields[playerNumber].cbegin(), DP::occupiedFields[playerNumber].cend());
+ for (int i=playerNumber*DP::diamondsNumber/4;i<(DP::diamondsNumber/4)+(playerNumber*DP::diamondsNumber/4);i++)
{
if (diamonds[i].boardPosition!=-1)
{
setSteps.erase(diamonds[i].boardPosition);
}
}
int step = rand()%setSteps.size();
std::vector<int> freePositions;
freePositions.resize(setSteps.size());
freePositions.assign(setSteps.begin(),setSteps.end());
return freePositions[step];
}
void BoardDiamondSeq::reorder()
{
srand((unsigned)time(0));
for (int element=0;element<4;element++)
{
int start = element;
- for (int i=start*efc::diamondsNumber/4;i<(efc::diamondsNumber/4)+(start*efc::diamondsNumber/4);i++)
+ for (int i=start*DP::diamondsNumber/4;i<(DP::diamondsNumber/4)+(start*DP::diamondsNumber/4);i++)
{
int step = getRandomPos(element);
diamonds[i].setBoardPosition(step);
}
}
}
void BoardDiamondSeq::reorder(int element)
{
srand((unsigned)time(0));
int start = element;
if (element==2)
start = 3;
else if (element==3)
start = 2;
int newElement = start;
- for (int i=start*efc::diamondsNumber/4;i<(efc::diamondsNumber/4)+(start*efc::diamondsNumber/4);i++)
+ for (int i=start*DP::diamondsNumber/4;i<(DP::diamondsNumber/4)+(start*DP::diamondsNumber/4);i++)
{
int step = getRandomPos(newElement);
diamonds[i].setBoardPosition(step);
}
}
void BoardDiamondSeq::collectField(int pos)
{
- for (int i=0; i<efc::diamondsNumber; i++)
+ for (int i=0; i<DP::diamondsNumber; i++)
{
if (diamonds[i].boardPosition==pos)
{
diamonds[i].setBoardPosition(-1);
break;
}
}
}
int BoardDiamondSeq::getNumberForField(int pos)
{
- for (int i=0; i<efc::diamondsNumber; i++)
+ for (int i=0; i<DP::diamondsNumber; i++)
{
if (diamonds[i].boardPosition==pos)
{
return diamonds[i].idNumber;
}
}
return -1;
}
diff --git a/src/boarddiamondseq.h b/src/boarddiamondseq.h
index 194d1b5..40b6bd8 100644
--- a/src/boarddiamondseq.h
+++ b/src/boarddiamondseq.h
@@ -1,47 +1,47 @@
#ifndef BOARDDIAMONDSEQ_H
#define BOARDDIAMONDSEQ_H
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <set>
#include "textureholder.h"
#include <SFML/Graphics.hpp>
#include "boarddiamond.h"
/*!
* \brief The BoardDiamondSeq class
* We are going to have 2 cards / diamonds of each element per each area,
* which gives 2*4*4 = 32 cards diamonds of elements on the board.
*
* Additionally there will be extra 6 white diamonds per area to collect, which
* gives 4*6 = 24 diamonds on the board.
*
* Together it would give 32 + 24 = 56 diamonds cards/diamonds together,
* 15 per area.
*/
class BoardDiamondSeq : public sf::Drawable, public sf::Transformable
{
public:
explicit BoardDiamondSeq(TextureHolder *textures);
TextureHolder *textures;
- BoardDiamond diamonds[efc::diamondsNumber];
+ BoardDiamond diamonds[DP::diamondsNumber];
- std::array<int,efc::diamondsNumber> getBoardPositions();
+ std::array<int,DP::diamondsNumber> getBoardPositions();
virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const;
int getRandomPos(int playerNumber);
void reorder();
// bool ifFieldIsEmpty(int pos, int element);
bool ifFieldIsEmpty(int pos);
void collectField(int pos);
int getNumberForField(int pos);
void reorder(int element);
};
#endif // BOARDDIAMONDSEQ_H
diff --git a/src/boardelem.cpp b/src/boardelem.cpp
index c615b49..59d9cbd 100644
--- a/src/boardelem.cpp
+++ b/src/boardelem.cpp
@@ -1,31 +1,31 @@
#include "boardelem.h"
-namespace efc {
+namespace DP {
sf::RectangleShape createNeighbour(int pos) {
- sf::RectangleShape rectangle(sf::Vector2f(efc::TILE_SIZE, efc::TILE_SIZE));
- sf::Vector2i cords(efc::transPosition(pos));
+ sf::RectangleShape rectangle(sf::Vector2f(DP::TILE_SIZE, DP::TILE_SIZE));
+ sf::Vector2i cords(DP::transPosition(pos));
rectangle.setFillColor(sf::Color(240, 240, 240,98));
rectangle.setOutlineColor(sf::Color(24,24,24, 90));
- rectangle.setPosition(cords.x*efc::TILE_SIZE, cords.y*efc::TILE_SIZE);
+ rectangle.setPosition(cords.x*DP::TILE_SIZE, cords.y*DP::TILE_SIZE);
return rectangle;
}
}
-efc::BoardElem::BoardElem(int pos, int type)
+DP::BoardElem::BoardElem(int pos, int type)
{
this->pos = pos;
this->type = type;
- sf::Vector2i cords = efc::transPosition(pos);
- int y_type = (int) type / efc::TILE_BOARD_SIZE;
- int x_type = type % efc::TILE_BOARD_SIZE;
- setPosition(cords.x*efc::TILE_SIZE,cords.y*efc::TILE_SIZE);
- setTextureRect(sf::IntRect(x_type*efc::TILE_SIZE, y_type*efc::TILE_SIZE, efc::TILE_SIZE, efc::TILE_SIZE));
+ sf::Vector2i cords = DP::transPosition(pos);
+ int y_type = (int) type / DP::TILE_BOARD_SIZE;
+ int x_type = type % DP::TILE_BOARD_SIZE;
+ setPosition(cords.x*DP::TILE_SIZE,cords.y*DP::TILE_SIZE);
+ setTextureRect(sf::IntRect(x_type*DP::TILE_SIZE, y_type*DP::TILE_SIZE, DP::TILE_SIZE, DP::TILE_SIZE));
textureTiles = nullptr;
}
diff --git a/src/boardelem.h b/src/boardelem.h
index b41a0e8..f24addb 100644
--- a/src/boardelem.h
+++ b/src/boardelem.h
@@ -1,24 +1,24 @@
#ifndef BOARDELEM_H
#define BOARDELEM_H
#include <SFML/Window.hpp>
#include <SFML/Graphics.hpp>
#include "tilemap.h"
#include "textureholder.h"
-namespace efc {
+namespace DP {
sf::RectangleShape createNeighbour(int pos);
class BoardElem: public sf::Sprite
{
public:
BoardElem();
BoardElem(int pos, int type);
int pos;
int type;
sf::Texture* textureTiles;
};
}
#endif // BOARDELEM_H
diff --git a/src/boardelems.cpp b/src/boardelems.cpp
index 64ecb1d..e30ad01 100644
--- a/src/boardelems.cpp
+++ b/src/boardelems.cpp
@@ -1,50 +1,50 @@
#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();
sf::BlendMode blendmode = sf::BlendAlpha;
states.blendMode = blendmode;
- for (const efc::BoardElem &i: items)
+ for (const DP::BoardElem &i: items)
{
target.draw(i, states);
- std::set<int> neighbours(efc::getNeighbours(i.pos));
+ std::set<int> neighbours(DP::getNeighbours(i.pos));
if ((active==true) && (displayNeighbours==true))
{
for (int j: neighbours)
{
if (items_map.count(j)==0)
{
neighboursAll.insert(j);
-// sf::RectangleShape sprite(efc::createNeighbour(j));
+// sf::RectangleShape sprite(DP::createNeighbour(j));
// target.draw(sprite, states);
}
}
}
}
if (active==true)
{
for (int j: neighboursAll)
{
if (items_map.count(j)==0)
{
- sf::RectangleShape sprite(efc::createNeighbour(j));
+ sf::RectangleShape sprite(DP::createNeighbour(j));
target.draw(sprite, states);
}
}
}
}
diff --git a/src/boardelems.h b/src/boardelems.h
index 5983804..345bd43 100644
--- a/src/boardelems.h
+++ b/src/boardelems.h
@@ -1,19 +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;
+ std::vector<DP::BoardElem> items;
+ std::map<int, DP::BoardElem> items_map;
bool active;
bool displayNeighbours;
private:
virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const;
};
#endif // BOARDELEMS_H
diff --git a/src/card.h b/src/card.h
index cb805f7..ed14627 100644
--- a/src/card.h
+++ b/src/card.h
@@ -1,39 +1,39 @@
#ifndef CARD_H
#define CARD_H
#include <string>
#include <array>
-namespace efc {
+namespace DP {
const static std::array<std::string, 4> cardsTypes = {
{"stop", "card", "diamond", "diamond x 2"}
};
const static std::array<std::array<std::string,4>,4> cardsTitles = {
{{{"stop", "card", "diamond", "diamond x 2"}},
{{"stop", "card", "diamond", "diamond x 2"}},
{{"stop", "card", "diamond", "diamond x 2"}},
{{"stop", "card", "diamond", "diamond x 2"}}}
};
}
/*!
* \brief The Card definition
*/
class Card
{
public:
Card();
int id;
int elementNumber; //location
int amount;
std::string cardType;
// Card type from the cardsTypes
int cardTypeInt;
// Title of the card, will be presented at the bottom of the card
std::string cardTitle;
};
#endif // CARD_H
diff --git a/src/cardsdeck.cpp b/src/cardsdeck.cpp
index baade85..7d644c3 100644
--- a/src/cardsdeck.cpp
+++ b/src/cardsdeck.cpp
@@ -1,143 +1,143 @@
#include "cardsdeck.h"
CardsDeck::CardsDeck(TextureHolder *textures, sf::Font *gameFont, Command *command)
{
commandManager=command;
std::array<std::array<int,2>,4> cardsPos = {
{
{{1087,95}}, {{1225, 95}}, {{1225, 277}}, {{1087, 277}}
}
};
this->textures = textures;
for (int i=0;i<=3;i++)
{
// spriteCardBases[i].setTexture(this->textures->textureCardBases[i]);
spriteCardBases[i].setPosition(cardsPos[i][0],cardsPos[i][1]);
textPileTitle[i].setFont(*gameFont);
textPileTitle[i].setCharacterSize(16);
textPileTitle[i].setPosition(cardsPos[i][0]+10,cardsPos[i][1]+100);
- for (unsigned int j=0;j<efc::cardsDistribution.size();j++)
+ for (unsigned int j=0;j<DP::cardsDistribution.size();j++)
{
- int cardTypeInt = efc::cardsDistribution[j];
+ int cardTypeInt = DP::cardsDistribution[j];
- cardsList[i].cardsPile[j].cardType = efc::cardsTypes[cardTypeInt];
+ cardsList[i].cardsPile[j].cardType = DP::cardsTypes[cardTypeInt];
cardsList[i].cardsPile[j].cardTypeInt = cardTypeInt;
spriteCardBases[i].setTexture(this->textures->cardsTextures[i][cardTypeInt]);
}
}
reloadCards();
}
void CardsDeck::reloadCards(){
for (int i=0;i<=3;i++)
{
cardsList[i].shufflePile();
setTitles(i);
}
}
void CardsDeck::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
states.transform *= getTransform();
for (int i=0;i<=3;i++)
{
if ((cardsList[i].invisibleLeft==0.0f) and (cardsList[i].active))
{
target.draw(spriteCardBases[i], states);
target.draw(textPileTitle[i], states);
}
}
}
void CardsDeck::setTitles(int number)
{
int cardTypeInt = getCardTypeInt(number);
- textPileTitle[number].setString(efc::cardsTypes[cardTypeInt]);
+ textPileTitle[number].setString(DP::cardsTypes[cardTypeInt]);
// int val = getCardTypeInt(number);
spriteCardBases[number].setTexture(textures->cardsTextures[number][cardTypeInt]);
}
void CardsDeck::setFonts(sf::Font *gameFont)
{
for (int i=0;i<=3;i++)
{
textPileTitle[i].setFont(*gameFont);
}
}
void CardsDeck::nextCard(int pileNumber)
{
if (cardsList[pileNumber].active)
{
cardsList[pileNumber].invisibleLeft = 0.75f;
unsigned int currentCard = getCurrentCard(pileNumber);
- if (currentCard>=efc::cardsDistribution.size()-1)
+ if (currentCard>=DP::cardsDistribution.size()-1)
{
cardsList[pileNumber].active = false;
commandManager->removeAllCardElement(pileNumber);
} else
{
currentCard += 1;
if (currentCard>3)
currentCard = 0;
cardsList[pileNumber].currentCard = currentCard;
setTitles(pileNumber);
}
}
// setSprites(pileNumber);
}
int CardsDeck::getCurrentCard(int pileNumber)
{
int currentCard = cardsList[pileNumber].currentCard;
return currentCard;
}
std::string CardsDeck::getTitle(int pileNumber)
{
- std::string currentText = efc::cardsTypes[getCardTypeInt(pileNumber)];
+ std::string currentText = DP::cardsTypes[getCardTypeInt(pileNumber)];
return currentText;
}
int CardsDeck::getCardTypeInt(int pileNumber)
{
int result = cardsList[pileNumber].cardsPile[getCurrentCard(pileNumber)].cardTypeInt;
return result;
}
void CardsDeck::update(sf::Time deltaTime)
{
for (int i=0;i<=3;i++)
{
if (cardsList[i].invisibleLeft>0.0f)
{
cardsList[i].invisibleLeft -= deltaTime.asSeconds();
}
if (cardsList[i].invisibleLeft<0.0f)
{
cardsList[i].invisibleLeft = 0.0f;
}
}
}
diff --git a/src/cardslist.h b/src/cardslist.h
index ce4ce0d..4e49c91 100644
--- a/src/cardslist.h
+++ b/src/cardslist.h
@@ -1,45 +1,45 @@
#ifndef CARDSLIST_H
#define CARDSLIST_H
#include <vector>
#include <iostream> // std::cout
#include <algorithm> // std::shuffle
#include <random> // std::default_random_engine
#include <chrono> // std::chrono::system_clock
#include "card.h"
-namespace efc {
+namespace DP {
const static std::array<int,32> cardsDistribution = {{
0,0,0,0,0,0,0,0,
1,1,1,1,1,1,1,1,
2,2,2,2,2,2,2,2,
3,3,3,3,3,3,3,3,
}};
const static std::array<int,2> cardsDistributionDebug = {{
2,3
}};
- const static int PILE_SIZE = efc::cardsDistribution.size();
+ const static int PILE_SIZE = DP::cardsDistribution.size();
}
class CardsList
{
public:
CardsList(); // To create an array of CardsList
explicit CardsList(int element);
// int amount;
// std::vector<Card*> sd;
/*!
* \brief element Number of the element
*/
- std::array<Card, efc::PILE_SIZE> cardsPile;
+ std::array<Card, DP::PILE_SIZE> cardsPile;
int currentCard;
int element; /*!< Number of the element */
float invisibleLeft;
bool active;
void shufflePile();
};
#endif // CARDSLIST_H
diff --git a/src/character.cpp b/src/character.cpp
index 433ba51..97df664 100644
--- a/src/character.cpp
+++ b/src/character.cpp
@@ -1,283 +1,283 @@
#include "character.h"
/*!
* \brief Character::getMovements
* \return
*/
std::array<int,2> Character::getMovements(int howFar)
{
std::array<int,2> myArray = {{-1,-1}};
if (howFar==7)
{
return myArray;
}
// std::array<int,2> myArray;
if (active==true)
{
int indexRight = boardPosition;
for (int i=boardPosition;i<=boardPosition+howFar-1;i++)
{
moveRight = indexRight;
if (indexRight==-1)
break;
- indexRight = efc::boards[indexRight][1];
+ indexRight = DP::boards[indexRight][1];
if (indexRight==-2)
{
indexRight = moveRight;
break;
}
if (indexRight==-1)
break;
}
moveRight = indexRight;
int indexLeft = boardPosition;
for (int i=boardPosition;i>=boardPosition-howFar+1;i--)
{
moveLeft = indexLeft;
if (indexLeft==-1)
break;
- indexLeft = efc::boards[indexLeft][0];
+ indexLeft = DP::boards[indexLeft][0];
if (indexLeft==-2)
{
indexLeft = moveLeft;
break;
}
if (indexLeft==-1)
break;
}
moveLeft = indexLeft;
myArray = {{moveLeft,moveRight}};
}
else
{
myArray = {{-1,-1}};
}
// std::cout << "howfar: " <<howFar << std::endl;
return myArray;
}
void Character::setBoardPosition(int playerNumber)
{
Elem::setBoardPosition(playerNumber);
move(0,-20);
}
void Character::setDir(int direction)
{
- if (direction==efc::DIR_LEFT)
+ if (direction==DP::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));
+// sf::Vector2i position(DP::getCords(a));
// std::cout << a.x << " " << a.y << " "
// << position.x << " " << position.y << " pos > "
// << getBoardPosition() << std::endl;
}
Character::Character(TextureHolder *textures, int playerNumber):
animatedSprite(sf::seconds(0.2f), true, false),
nextRedirect(0.f)
{
drawMovements = false;
this->textures = textures;
int offset = playerNumber*32;
active = false;
rectangleLeft.setFillColor(sf::Color(12, 12, 12,120));
rectangleLeft.setOutlineColor(sf::Color(24,24,40, 255));
rectangleRight.setFillColor(sf::Color(240, 240, 240,98));
rectangleRight.setOutlineColor(sf::Color(24,40,24, 90));
int charWidth = 32;
int charHeight = 58;
walkingAnimationDown.setSpriteSheet(textures->textureCharacters);
walkingAnimationDown.addFrame(sf::IntRect(offset, 0, charWidth, charHeight));
walkingAnimationDown.addFrame(sf::IntRect(offset, 58, charWidth, charHeight));
walkingAnimationRight.setSpriteSheet(textures->textureCharacters);
walkingAnimationRight.addFrame(sf::IntRect(offset, 116, charWidth, charHeight));
walkingAnimationRight.addFrame(sf::IntRect(offset, 174, charWidth, charHeight));
walkingAnimationLeft.setSpriteSheet(textures->textureCharacters);
walkingAnimationLeft.addFrame(sf::IntRect(offset, 232, charWidth, charHeight));
walkingAnimationLeft.addFrame(sf::IntRect(offset, 290, charWidth, charHeight));
walkingAnimationUp.setSpriteSheet(textures->textureCharacters);
walkingAnimationUp.addFrame(sf::IntRect(offset, 348, charWidth, charHeight));
walkingAnimationUp.addFrame(sf::IntRect(offset, 406, charWidth, charHeight));
currentAnimation = &walkingAnimationRight;
leftChar.move(202,76);
rightChar.move(202,76);
- animations[efc::DIR_LEFT] = walkingAnimationLeft;
- animations[efc::DIR_RIGHT] = walkingAnimationRight;
- animations[efc::DIR_UP] = walkingAnimationUp;
- animations[efc::DIR_DOWN] = walkingAnimationDown;
+ animations[DP::DIR_LEFT] = walkingAnimationLeft;
+ animations[DP::DIR_RIGHT] = walkingAnimationRight;
+ animations[DP::DIR_UP] = walkingAnimationUp;
+ animations[DP::DIR_DOWN] = walkingAnimationDown;
- setDirIndex(efc::DIR_LEFT);
+ setDirIndex(DP::DIR_LEFT);
setDir();
std::array<int, 4> boardPositions{{0,15,255-15,255}};
setBoardPosition(boardPositions[playerNumber]);
}
void Character::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
states.transform *= getTransform();
target.draw(animatedSprite, states);
}
void Character::update(sf::Time deltaTime)
{
sf::Vector2f a(getPosition());
- sf::Vector2i position(efc::getCords(a));
+ sf::Vector2i position(DP::getCords(a));
nextRedirect -= deltaTime.asSeconds();
if (nextRedirect<0)
{
int number = rand() % 2;
- if ((currentAnimationIndex==efc::DIR_LEFT) || (currentAnimationIndex==efc::DIR_RIGHT))
+ if ((currentAnimationIndex==DP::DIR_LEFT) || (currentAnimationIndex==DP::DIR_RIGHT))
{
if (number==0){
- setDirIndex(efc::DIR_DOWN);
+ setDirIndex(DP::DIR_DOWN);
setDir();
} else if (number==1)
{
- setDirIndex(efc::DIR_UP);
+ setDirIndex(DP::DIR_UP);
setDir();
}
- } else if ((currentAnimationIndex==efc::DIR_UP) || (currentAnimationIndex==efc::DIR_DOWN))
+ } else if ((currentAnimationIndex==DP::DIR_UP) || (currentAnimationIndex==DP::DIR_DOWN))
{
if (number==0){
- setDirIndex(efc::DIR_LEFT);
+ setDirIndex(DP::DIR_LEFT);
setDir();
} else if (number==1)
{
- setDirIndex(efc::DIR_RIGHT);
+ setDirIndex(DP::DIR_RIGHT);
setDir();
}
}
nextRedirect = rand() % 4;
}
- if (currentAnimationIndex==efc::DIR_UP)
+ if (currentAnimationIndex==DP::DIR_UP)
{
if (position.y<2)
{
- setDirIndex(efc::DIR_DOWN);
+ setDirIndex(DP::DIR_DOWN);
setDir();
}
- } else if (currentAnimationIndex==efc::DIR_DOWN)
+ } else if (currentAnimationIndex==DP::DIR_DOWN)
{
- if (position.y>efc::BOARD_SIZE-1)
+ if (position.y>DP::BOARD_SIZE-1)
{
- setDirIndex(efc::DIR_UP);
+ setDirIndex(DP::DIR_UP);
setDir();
}
- } else if (currentAnimationIndex==efc::DIR_LEFT)
+ } else if (currentAnimationIndex==DP::DIR_LEFT)
{
if (position.x<2)
{
- setDirIndex(efc::DIR_RIGHT);
+ setDirIndex(DP::DIR_RIGHT);
setDir();
}
- } else if (currentAnimationIndex==efc::DIR_RIGHT)
+ } else if (currentAnimationIndex==DP::DIR_RIGHT)
{
- if (position.x>efc::BOARD_SIZE-1)
+ if (position.x>DP::BOARD_SIZE-1)
{
- setDirIndex(efc::DIR_LEFT);
+ setDirIndex(DP::DIR_LEFT);
setDir();
}
}
animatedSprite.update(deltaTime);
if (active==true)
{
if (moveLeft>-1)
{
-// sf::Vector2i cordsLeft(efc::transPosition(moveLeft));
- sf::Vector2i neededCords(efc::transPosition(moveLeft));
+// sf::Vector2i cordsLeft(DP::transPosition(moveLeft));
+ sf::Vector2i neededCords(DP::transPosition(moveLeft));
- sf::Vector2f newPos(efc::getScreenPos(neededCords));
- leftChar.setPosition(newPos.x+efc::TILE_SIZE/4,newPos.y);
+ sf::Vector2f newPos(DP::getScreenPos(neededCords));
+ leftChar.setPosition(newPos.x+DP::TILE_SIZE/4,newPos.y);
leftChar.move(202,76);
}
if (moveRight>-1)
{
-// sf::Vector2i cordsRight(efc::transPosition(moveRight));
- sf::Vector2i neededCords(efc::transPosition(moveRight));
+// sf::Vector2i cordsRight(DP::transPosition(moveRight));
+ sf::Vector2i neededCords(DP::transPosition(moveRight));
- sf::Vector2f newPos(efc::getScreenPos(neededCords));
- rightChar.setPosition(newPos.x+efc::TILE_SIZE/4,newPos.y);
+ sf::Vector2f newPos(DP::getScreenPos(neededCords));
+ rightChar.setPosition(newPos.x+DP::TILE_SIZE/4,newPos.y);
rightChar.move(202,76);
}
// std::cout << " dice " << diceResult<< moveLeft << " " << moveRight << std::endl;
}
}
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/src/command.cpp b/src/command.cpp
index caa55d0..4649d00 100644
--- a/src/command.cpp
+++ b/src/command.cpp
@@ -1,191 +1,191 @@
#include <algorithm>
#include <iterator>
#include "game.h"
#include "command.h"
#include "data.h"
-Command::Command(efc::Game &currentGame) :
+Command::Command(DP::Game &currentGame) :
game(currentGame)
{
}
/*!
* \brief Command::removeCard
* \param playerNumber number of the player which cards will be removed
* \return
*/
bool Command::removeCard(int playerNumber)
{
/*! This should works as following:
* - iterate over BoardDiamondSeq
* - find diamonds belonging to the playerNumber
* - create an array from the aboves
* - get a random element
* - remove from the board - set not active
*/
std::vector<int> diamonds;
for (auto&& i: game.boardDiamonds.diamonds)
{
int fieldNumber = i.playerNumber;
if ((fieldNumber==playerNumber) && (i.boardPosition>-1)
&& (i.idNumber<4))
{
diamonds.push_back(i.boardPosition);
}
}
int numberDiamonds = diamonds.size();
if (numberDiamonds>0)
{
int elemToRemove = rand() % numberDiamonds;
game.boardDiamonds.collectField(diamonds[elemToRemove]);
return true;
}
return false;
}
void Command::removeAllCardElement(int elementNumber) const
{
/*! This should works as following:
* - iterate over BoardDiamondSeq
* - find diamonds belonging to the playerNumber
* - create an array from the aboves
* - get a random element
* - remove from the board - set not active
*/
for (auto&& i: game.boardDiamonds.diamonds)
{
int cardElementNumber = i.idNumber;
if ((i.boardPosition>-1) && (cardElementNumber==elementNumber))
{
i.boardPosition=-1;
};
}
}
/*!
* \brief Command::removeDiamond
* \param playerNumber
* \return if diamond had been removed
*/
bool Command::removeDiamond(int playerNumber)
{
/*! This should works as following:
* - iterate over BoardDiamondSeq
* - find diamonds belonging to the playerNumber
* - create an array from the aboves
* - get a random element
* - remove from the board - set not active
*/
std::vector<int> diamonds;
for (auto&& i: game.boardDiamonds.diamonds)
{
int fieldNumber = i.playerNumber;
if ((fieldNumber==playerNumber) && (i.boardPosition>-1)
&& (i.idNumber==4))
{
diamonds.push_back(i.boardPosition);
}
}
int numberDiamonds = diamonds.size();
if (numberDiamonds>0)
{
int elemToRemove = rand() % numberDiamonds;
game.boardDiamonds.collectField(diamonds[elemToRemove]);
return true;
}
return false;
}
void Command::freezePlayer(int playerNumber)
{
game.players[playerNumber].frozenLeft += 1;
}
void Command::removeAllItems(int playerNumber) const
{
for (auto&& i: game.boardDiamonds.diamonds)
{
int itemPlayerNumber = i.playerNumber;
if ((i.boardPosition>-1) && (itemPlayerNumber==playerNumber))
{
i.boardPosition=-1;
};
}
}
/*!
* \brief Command::processField when the player enters the field
* \param pos
*/
void Command::processField(int pos)
{
- bool startField = std::find(std::begin(efc::startPlayers),
- std::end(efc::startPlayers), pos)
- != std::end(efc::startPlayers);
+ bool startField = std::find(std::begin(DP::startPlayers),
+ std::end(DP::startPlayers), pos)
+ != std::end(DP::startPlayers);
- if ((startField) && (efc::startPlayers[game.turn]==pos))
+ if ((startField) && (DP::startPlayers[game.turn]==pos))
{
game.banner.setText("meditation");
game.boardDiamonds.reorder(game.turn);
game.sfx.soundMeditation.play();
}
if (game.boardDiamonds.ifFieldIsEmpty(pos)==false)
{
game.sfx.playCollect();
if (game.boardDiamonds.getNumberForField(pos)==4)
{
game.players[game.turn].cash += 1;
} else if (game.boardDiamonds.getNumberForField(pos)<4)
{
processCard(pos);
}
game.boardDiamonds.collectField(pos);
}
}
/*!
* \brief Command::processCard when the user enters the field
* \param pos
*/
void Command::processCard(int pos)
{
int tokenNumber = game.boardDiamonds.getNumberForField(pos);
std::string cardType = game.cardsDeck.getTitle(tokenNumber);
if (tokenNumber!=game.turn)
{
if (cardType == "diamond")
{
removeDiamond(game.boardDiamonds.getNumberForField(pos));
game.players[game.turn].cash += 1;
} else if (cardType == "stop")
{
freezePlayer(tokenNumber);
} else if (cardType == "card")
{
removeCard(game.boardDiamonds.getNumberForField(pos));
} else if (cardType == "diamond x 2")
{
if (removeDiamond(game.boardDiamonds.getNumberForField(pos)))
game.players[game.turn].cash += 1;
if (removeDiamond(game.boardDiamonds.getNumberForField(pos)))
game.players[game.turn].cash += 1;
}
}
game.cardsDeck.nextCard(tokenNumber);
game.sfx.playCard();
}
//int Command::processGui(sf::Vector2f posGui)
//{
// return posGui.x + posGui.y; /*! TODO: add processing some actions */
//}
diff --git a/src/command.h b/src/command.h
index 80aa88b..5026683 100644
--- a/src/command.h
+++ b/src/command.h
@@ -1,30 +1,30 @@
#ifndef COMMAND_H
#define COMMAND_H
#include "vector"
-namespace efc {
+namespace DP {
class Game;
}
class Command
{
public:
// Command();
- explicit Command(efc::Game &currentGame);
+ explicit Command(DP::Game &currentGame);
/*!
* \brief Removes a diamond from the player's field.
* \param player
*/
bool removeDiamond(int playerNumber);
bool removeCard(int playerNumber);
void freezePlayer(int playerNumber);
void removeAllItems(int playerNumber) const;
- efc::Game &game;
+ DP::Game &game;
void processField(int pos);
void processCard(int pos);
void removeAllCardElement(int elementNumber) const;
};
#endif // COMMAND_H
diff --git a/src/data.cpp b/src/data.cpp
index 99d53b7..4c49829 100644
--- a/src/data.cpp
+++ b/src/data.cpp
@@ -1,128 +1,128 @@
#include <array>
#include "data.h"
-namespace efc {
+namespace DP {
std::string seasonsNames[4] = {"winter", "spring", "summer", "fall"};
// This array defines fields occupied by the river
int terrainArray[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
};
/*
* 0
* 16
* 32
* 48
* 64
* 80
* 96
* 112
* 128
* 144
* 160
* 176
* 192
*/
std::array<std::array<int,2>,256> boards = {
{
{{-1,1}}, {{0,2}}, {{1,3}}, {{2,4}}, {{3,5}}, {{4,21}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{11,26}}, {{12,10}}, {{13,11}}, {{14,12}}, {{15,13}}, {{-1,14}},
{{-1,-1}}, {{18,33}}, {{19,17}}, {{20,18}}, {{21,19}}, {{5,20}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{10, 27,}}, {{26,28}}, {{27,29}}, {{28,30}}, {{29,46}}, {{-1,-1}},
{{33,48}}, {{17,32}}, {{-1,-1}}, {{51,36}}, {{35,37}}, {{36,38}}, {{37,54}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{43,58}}, {{44,42}}, {{60,43}}, {{-1,-1}}, {{30,47}}, {{46,63}},
{{32,49}}, {{48,50}}, {{49,51}}, {{50,35}}, {{-1,-1}}, {{54,69}}, {{38,53}}, {{-1,-1}}, {{-1,-1}}, {{58,73}}, {{42,57}}, {{-1,-1}}, {{61,44}}, {{62,60}}, {{63,61}}, {{47,62}},
{{65,80}}, {{66,64}}, {{67,65}}, {{68,66}}, {{69,67}}, {{53,68}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{57,74}}, {{73,75}}, {{74,76}}, {{75,77}}, {{76,78}}, {{77,79}}, {{78,95}},
{{64,81}}, {{80,97}}, {{-1,-1}}, {{99,84}}, {{83,85}}, {{84,101}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{90,105}}, {{91,89}}, {{92,90}}, {{108,91}}, {{-1,-1}}, {{95,110}}, {{79,94}},
{{-1,-1}}, {{81,98}}, {{97,99}}, {{98,83}}, {{-1,-1}}, {{85,102}}, {{101,118}}, {{-1,-1}}, {{105,120}}, {{89,104}}, {{-1,-1}}, {{-1,-1}}, {{109,92}}, {{110,108}}, {{94,109}}, {{-1,-1}},
{{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{102, 119}},{{118,-2}}, {{104,-2}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}},
{{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}} , {{151,-2}}, {{137,-2}}, {{153,136}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}},
{{-1,-1}}, {{161,146}}, {{145,147}}, {{146,163}}, {{-1,-1}}, {{-1,-1}}, {{166,151}}, {{150,135}} ,{{-1,-1}}, {{154,137}}, {{170,153}}, {{-1,-1}}, {{157,172}}, {{158,156}}, {{174,157}}, {{-1,-1}},
{{176,161}},{{160,145}}, {{-1,-1}}, {{147,164}}, {{163,165}}, {{164,166}}, {{165,150}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{171,154}}, {{172,170}}, {{156,171}}, {{-1,-1}}, {{175,158}}, {{191,174}},
{{177,160}},{{178,176}}, {{179,177}}, {{180,178}}, {{181,179}}, {{182,180}}, {{198,181}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{202,187}}, {{186,188}}, {{187,189}}, {{188,190}}, {{189,191}}, {{190,175}},
{{208,193}},{{192,194}}, {{193,195}}, {{194,211}}, {{-1,-1}}, {{213,198}}, {{197,182}}, {{-1,-1}}, {{-1,-1}}, {{217,202}}, {{201,186}}, {{-1,-1}}, {{205,220}}, {{206,204}}, {{207,205}}, {{223,206}},
{{209,192}},{{225,208}}, {{-1,-1}}, {{195,212}}, {{211,213}}, {{212,197}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{218,201}}, {{219,217}}, {{220,218}}, {{204,219}}, {{-1,-1}}, {{238,223}}, {{222,207}},
{{-1,-1}}, {{226,209}}, {{227,225}}, {{228,226}}, {{229,227}}, {{245,228}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{250,235}}, {{234,236}}, {{235,237}}, {{236,238}}, {{237,222}}, {{-1,-1}},
{{-1,241}}, {{240,242}},{{241,243}}, {{242,244}}, {{243,245}}, {{244,229}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{-1,-1}}, {{251,234}}, {{252,250}}, {{253,251}}, {{254,252}}, {{255,253}}, {{-1,254}},
},
};
std::array<std::array<int,numberSteps>,4> occupiedFields =
{
{
{{1,2,3,4,5,17,18,19,20,21,32,33,35,36,37,38,48,49,50,51,53,54,64,65,66,67,68,69,80,81,83,84,85,97,98,99,101,102,118}},
{{10,11,12,13,14,26,27,28,29,30,42,43,44,46,47,57,58,60,61,62,63,73,74,75,76,77,78,79,89,90,91,92,94,95,104,105,108,109,110}},
{{145,146,147,150,151,160,161,163,164,165,166,176,177,178,179,180,181,182,192,193,194,195,197,198,208,209,211,212,213,225,226,227,228,229,241,242,243,244,245}},
{{137,153,154,156,157,158,170,171,172,174,175,186,187,188,189,190,191,201,202,204,205,206,207,217,218,219,220,222,223,234,235,236,237,238,250,251,252,253,254}}
}
};
sf::Color playersColors[4] = {
sf::Color(122, 185,246,255),
sf::Color(144, 226,106,255),
sf::Color(255, 163,142,255),
sf::Color(250, 255,117,255),
};
-std::array<std::array<int,3>,efc::diamondsNumber> DIAMONDS_SETUP =
+std::array<std::array<int,3>,DP::diamondsNumber> DIAMONDS_SETUP =
{
{
{{0,0,-1}},{{0,0,-1}},
{{1,0,-1}},{{1,0,-1}},
{{2,0,-1}},{{2,0,-1}},
{{3,0,-1}},{{3,0,-1}},
{{4,0,-1}},{{4,0,-1}},{{4,0,-1}},{{4,0,-1}},{{4,0,-1}},{{4,0,-1}},
{{0,0,-1}},{{0,0,-1}},
{{1,0,-1}},{{1,0,-1}},
{{2,0,-1}},{{2,0,-1}},
{{3,0,-1}},{{3,0,-1}},
{{4,0,-1}},{{4,0,-1}},{{4,0,-1}},{{4,0,-1}},{{4,0,-1}},{{4,0,-1}},
{{0,1,-1}},{{0,1,-1}},
{{1,1,-1}},{{1,1,-1}},
{{2,1,-1}},{{2,1,-1}},
{{3,1,-1}},{{3,1,-1}},
{{4,1,-1}},{{4,1,-1}},{{4,1,-1}},{{4,1,-1}},{{4,1,-1}},{{4,1,-1}},
{{0,1,-1}},{{0,1,-1}},
{{1,1,-1}},{{1,1,-1}},
{{2,1,-1}},{{2,1,-1}},
{{3,1,-1}},{{3,1,-1}},
{{4,1,-1}},{{4,1,-1}},{{4,1,-1}},{{4,1,-1}},{{4,1,-1}},{{4,1,-1}},
{{0,3,-1}},{{0,3,-1}},
{{1,3,-1}},{{1,3,-1}},
{{2,3,-1}},{{2,3,-1}},
{{3,3,-1}},{{3,3,-1}},
{{4,3,-1}},{{4,3,-1}},{{4,3,-1}},{{4,3,-1}},{{4,3,-1}},{{4,3,-1}},
{{0,3,-1}},{{0,3,-1}},
{{1,3,-1}},{{1,3,-1}},
{{2,3,-1}},{{2,3,-1}},
{{3,3,-1}},{{3,3,-1}},
{{4,3,-1}},{{4,3,-1}},{{4,3,-1}},{{4,3,-1}},{{4,3,-1}},{{4,3,-1}},
{{0,2,-1}},{{0,2,-1}},
{{1,2,-1}},{{1,2,-1}},
{{2,2,-1}},{{2,2,-1}},
{{3,2,-1}},{{3,2,-1}},
{{4,2,-1}},{{4,2,-1}},{{4,2,-1}},{{4,2,-1}},{{4,2,-1}},{{4,2,-1}},
{{0,2,-1}},{{0,2,-1}},
{{1,2,-1}},{{1,2,-1}},
{{2,2,-1}},{{2,2,-1}},
{{3,2,-1}},{{3,2,-1}},
{{4,2,-1}},{{4,2,-1}},{{4,2,-1}},{{4,2,-1}},{{4,2,-1}},{{4,2,-1}},
}
} ;
}
diff --git a/src/data.h b/src/data.h
index 9e68566..cca9d57 100644
--- a/src/data.h
+++ b/src/data.h
@@ -1,47 +1,47 @@
#ifndef DATA_H
#define DATA_H
#include <map>
#include <string>
#include <string>
#include <SFML/Graphics.hpp>
-namespace efc {
+namespace DP {
extern std::string seasonsNames[4];
enum directions {
DIR_LEFT,
DIR_RIGHT,
DIR_UP,
DIR_DOWN
};
enum cardType {
FREEZE,
COLLECT_DIAMOND
};
extern int terrainArray[24];
extern sf::Color playersColors[4];
extern std::array<std::array<int,2>,256> boards;
extern int possibleExits[4]; // number of portal's exit where player stops to play
const static int diamondsNumber = 112; // number of all cards / diamonds on the board
- extern std::array<std::array<int,3>,efc::diamondsNumber> DIAMONDS_SETUP;
+ extern std::array<std::array<int,3>,DP::diamondsNumber> DIAMONDS_SETUP;
extern std::array<std::array<int,39>,4> occupiedFields;
const static int numberSteps = 39;
const static int startPlayers[4] = {0,15,255,240};
const static int endPlayers[4] = {119,120,135,136};
const static std::map<std::string, std::string> cardTypes = {
{"stop", "Freezes a player for the one turn time"},
{"diamond", "Collect a diamond from the player area"},
{"card", "Collect a card from the player area"},
};
}
#endif // DATA_H
diff --git a/src/elem.cpp b/src/elem.cpp
index 7aa2f36..6926210 100644
--- a/src/elem.cpp
+++ b/src/elem.cpp
@@ -1,47 +1,47 @@
#include "elem.h"
Elem::Elem()
{
boardPosition = -1;
}
/*!
* \brief Character::getBoardPosition
* \return
*/
int Elem::getBoardPosition()
{
sf::Vector2f currentPos(getPosition());
- sf::Vector2i currentCords(efc::getCords(currentPos));
- int currentBoardPosition = efc::transCords(currentCords);
+ sf::Vector2i currentCords(DP::getCords(currentPos));
+ int currentBoardPosition = DP::transCords(currentCords);
return currentBoardPosition;
}
/*!
* \brief Character::setBoardPosition
* \param boardPosition
*/
void Elem::setBoardPosition(int boardPosition)
{
- sf::Vector2i neededCords(efc::transPosition(boardPosition));
+ sf::Vector2i neededCords(DP::transPosition(boardPosition));
- sf::Vector2f newPos(efc::getScreenPos(neededCords));
+ sf::Vector2f newPos(DP::getScreenPos(neededCords));
setPosition(newPos.x, newPos.y);
this->boardPosition = boardPosition;
// std::array<int,2> movements(getMovements(diceResult));
// std::cout << "board pos >> " << boardPosition << " cords >>" << neededCords.x << " " << neededCords.y
// << "newpos >> " << newPos.x << " " << newPos.y << " "
// << "movements >> " << movements[0] << " " << movements[1]
// << std::endl;
sf::Vector2i newVecPos(getPosition());
// sf::FloatRect newSize(getGlobalBounds());
- float newX = newVecPos.x + (efc::TILE_SIZE/3);
+ float newX = newVecPos.x + (DP::TILE_SIZE/3);
// newX = newX - (newSize.width);
setPosition(newX, newPos.y);
move(202,76);
}
diff --git a/src/game.cpp b/src/game.cpp
index fb8e5e4..e58fab0 100644
--- a/src/game.cpp
+++ b/src/game.cpp
@@ -1,1178 +1,1178 @@
#include "game.h"
#include "particle.h"
#include "calendar.h"
#include <algorithm>
-namespace efc {
+namespace DP {
int initScreenX = 1360;
int initScreenY = 768;
int currentSeason = 1;
int month = 0;
/*!
* \brief The ResultTable struct contains data for the end of the game screen.
*/
struct ResultTable
{
int playerNumber;
int playerResult;
bool reachedPortal;
bool reachedPortalFirst;
ResultTable(int number,int result, bool portal, bool portalFirst) :
playerNumber(number), playerResult(result), reachedPortal(portal), reachedPortalFirst(portalFirst) {}
bool operator < (const ResultTable& otherResult) const
{
if ((playerResult!=otherResult.playerResult) || ((reachedPortal==false) && (otherResult.reachedPortal==false)))
return (playerResult > otherResult.playerResult);
else if (reachedPortalFirst==true){
return true;
} else
{
return false;
}
;
}
};
/*!
* \brief Game::setTxtEndGameAmount orders the results text for the end of the game.
*/
void Game::setTxtEndGameAmount(){
std::string elementNames[4] = {"Water","Earth", "Fire", "Air"};
int width=1360;
// int height = 768;
// int startHeight = 100;
int separator = 40;
std::array<ResultTable, 4> results = {
{
ResultTable(0,players[0].cash, players[0].reachedPortal,players[0].reachedPortalFirst),
ResultTable(1,players[1].cash, players[1].reachedPortal,players[1].reachedPortalFirst),
ResultTable(2,players[2].cash, players[2].reachedPortal,players[2].reachedPortalFirst),
ResultTable(3,players[3].cash, players[3].reachedPortal,players[3].reachedPortalFirst)
}
};
std::vector < ResultTable > resultsVector;
txtSurvivors.clear();
txtLoosers.clear();
for (int i=0;i<4;i++)
{
resultsVector.push_back(results[i]);
};
std::sort(resultsVector.begin(), resultsVector.end());
txtWinner.setFont(gameFont);
txtWinner.setCharacterSize(40);
for (int i=0;i<4;i++)
{
int playerNumber = resultsVector[i].playerNumber;
std::string elementName = elementNames[playerNumber];
sf::Text tmpText;
tmpText.setFont(gameFont);
tmpText.setCharacterSize(25);
tmpText.setString(elementName+ " " + std::to_string(players[playerNumber].cash));
sf::FloatRect rectTxt = tmpText.getLocalBounds();
if (players[playerNumber].reachedPortal==true)
{
int counter = txtSurvivors.size();
tmpText.setPosition((1360/2)-(rectTxt.width/2),200+(counter*separator));
txtSurvivors.push_back(tmpText);
} else
{
int counter = txtLoosers.size();
tmpText.setPosition((width/2)-(rectTxt.width/2),540+(counter*separator));
txtLoosers.push_back(tmpText);
}
}
if (txtSurvivors.size()>0)
{
txtWinner.setString("Winner: " + txtSurvivors[0].getString());
txtSurvivors.erase(txtSurvivors.begin()+0);
}
txtWinner.setCharacterSize(40);
sf::FloatRect rectTxt = txtWinner.getLocalBounds();
txtWinner.setPosition((1360/2)-(rectTxt.width/2),120);
}
void Game::initBoard()
{
time_t t = time(0);
struct tm * now = localtime( & t );
int month = now->tm_mon + 1;
int day = now->tm_mday;
paganHolidayString = getHoliday(month, day);
paganHolidayTxt.setString(paganHolidayString);
sfxClick.setBuffer(sfxClickBuffer);
sfxDone.setBuffer(sfxDoneBuffer);
spriteBackgroundDark.setTexture(textures.backgroundDark);
spriteBackgroundDark.setPosition(0,0);
spriteLestBegin.setTexture(textures.textureLetsBegin);
viewTiles.setViewport(sf::FloatRect(0.15f,0.1f, 1.0f, 1.0f));
viewGui.setViewport(sf::FloatRect(0.806f,0.066f, 1, 1));
groupHud.setFont(&gameFont);
groupHud.setSeason(currentSeason);
groupHud.setRoundName(roundNumber);
cardsDeck.setFonts(&gameFont);
spriteBigDiamond.setTexture(textures.textureBigDiamond);
spriteBigDiamond.setPosition(474,342);
spriteBigDiamond.setColor(sf::Color (255, 255, 255,196));
restartGame();
launchNextPlayer();
endGameTxt.setFont(gameFont);
endGameTxt.setString("End of the Game");
endGameTxt.setCharacterSize(30);
sf::FloatRect ss = endGameTxt.getLocalBounds();
endGameTxt.setPosition((1360/2)-(ss.width/2),60);
setTxtEndGameAmount();
bubble.setPosition(players[turn].characters[0].getPosition().x-30,
players[turn].characters[0].getPosition().y-45);
txtSurvivorsLabel.setString("Survivors");
txtSurvivorsLabel.setFont(gameFont);
txtSurvivorsLabel.setCharacterSize(30);
sf::FloatRect rectSurvivors = txtSurvivorsLabel.getLocalBounds();
txtSurvivorsLabel.setPosition((1360/2)-(rectSurvivors.width/2),200);
txtLoosersLabel.setString("Digested by The Elements");
txtLoosersLabel.setFont(gameFont);
txtLoosersLabel.setCharacterSize(30);
sf::FloatRect rectLoosers = txtLoosersLabel.getLocalBounds();
txtLoosersLabel.setPosition((1360/2)-(rectLoosers.width/2),500);
credits.setTxt(0);
}
/*!
* \brief Game::restartGame sets all the variables to the default value
*/
void Game::restartGame()
{
Player playerHud1(&textures, &gameFont,0);
Player playerHud2(&textures, &gameFont,1);
Player playerHud3(&textures, &gameFont,2);
Player playerHud4(&textures, &gameFont,3);
players[0] = playerHud1;
players[1] = playerHud2;
players[3] = playerHud3;
players[2] = playerHud4;
players[0].setActive(true);
setCurrentNeighbours();
diceResultPlayer = 6;
players[turn].characters[0].diceResult = diceResultPlayer;
roundDice.setColor(turn);
for (int i=0;i<4;i++)
{
players[i].restartPlayer();
players[i].reachedPortal = false;
boardDiamonds.reorder(i);
bubble.setPosition(players[i].characters[0].getPosition().x-30,
players[i].characters[0].getPosition().y-45);
players[i].done=false;
}
numberFinishedPlayers = 0;
turn = 0;
currentSeason = 1;
roundNumber = 1;
month = 0;
cardsDeck.reloadCards();
deerModeActive = false;
deerModeCounter = 16;
}
void Game::setCurrentNeighbours ()
{
currentNeighbours = players[turn].getNeighbours();
}
/*!
* \brief Game::loadAssets
*/
void Game::loadAssets()
{
if (!gameFont.loadFromFile("assets/fnt/metal-mania.regular.ttf"))
{
std::exit(1);
}
if (!menuFont.loadFromFile("assets/fnt/metal-macabre.regular.ttf"))
{
std::exit(1);
}
menuBackground.setTexture(textures.textureMenu);
spriteDeerGod.setTexture(textures.textureDeerGod);
if (!shaderBlur.loadFromFile("assets/shaders/blur.frag", sf::Shader::Fragment))
std::exit(1);
if (!shaderPixel.loadFromFile("assets/shaders/pixelate.frag", sf::Shader::Fragment))
std::exit(1);
if (!shaderDark.loadFromFile("assets/shaders/dark.frag", sf::Shader::Fragment))
std::exit(1);
if (!textureBackgroundArt.loadFromFile("assets/img/background_land.png"))
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);
spriteBackgroundArt.setTexture(textureBackgroundArt);
menuTxt.setFont(gameFont);
menuTxt.setCharacterSize(60);
menuTxt.setString(gameTitle);
int width = menuTxt.getLocalBounds().width;
int height = menuTxt.getLocalBounds().height;
menuTxt.setPosition(1050-(width/2),750-(height/2)-150);
menuTxt.setColor(sf::Color(255, 255, 255, 85));
cardsDeck.setFonts(&gameFont);
paganHolidayTxt.setFont(gameFont);
paganHolidayTxt.setCharacterSize(20);
paganHolidayTxt.setPosition(20,20);
for (int i=0;i<4;i++)
{
playersSprites[i].setTexture(textureBackgroundArt);
playersSprites[i].setTextureRect(sf::IntRect(playersSpritesCords[i][0],
playersSpritesCords[i][1], 280, 280));
playersSprites[i].setPosition(playersSpritesCords[i][0], playersSpritesCords[i][1]);
}
}
void Game::showMenu()
{
musicMenu.play();
musicMenu.setLoop(true);
currentState = state_menu;
}
void Game::hideMenu()
{
musicMenu.stop();
}
void Game::showGameBoard()
{
// musicGame.setVolume(20);
musicGame.play();
musicGame.setLoop(true);
sfx.playLetsBegin();
currentState = state_setup_players;
// currentState = state_lets_begin;
}
void Game::endGame()
{
musicGame.stop();
currentState = state_end_game;
downTimeCounter = 0;
numberFinishedPlayers = 4;
setTxtEndGameAmount();
// musicBackground.stop();
}
void Game::throwDiceMove() {
// Throw a dice action
diceResultPlayer = roundDice.throwDiceSix();
players[turn].characters[0].diceResult=diceResultPlayer;
currentState = state_game;
bubble.state = BubbleState::MOVE;
nextRotateElem.reset();
prevRotateElem.reset();
}
/*!
* \brief Game::playerMakeMove move the player into the position on the map
* \param mousePos
*/
void Game::playerMakeMove(int mousePos) {
players[turn].setFigurePos(mousePos);
commandManager.processField(mousePos);
- const int *possibleExit = std::find(std::begin(efc::endPlayers),
- std::end(efc::endPlayers), mousePos);
- if (possibleExit != efc::endPlayers+4) {
+ const int *possibleExit = std::find(std::begin(DP::endPlayers),
+ std::end(DP::endPlayers), mousePos);
+ if (possibleExit != DP::endPlayers+4) {
players[turn].done=true;
players[turn].reachedPortal=true;
commandManager.removeAllItems(turn);
if (numberFinishedPlayers == 0)
{
players[turn].reachedPortalFirst=true;
int turnover = (rand() % 2)+5;
players[turn].cash += turnover;
players[turn].updatePlayer();
startDeerMode();
}
sfx.soundPortal.play();
numberFinishedPlayers += 1;
if (numberFinishedPlayers > 3)
{
endGame();
return;
}
}
nextPlayer();
return;
}
int Game::mostDiamonds() const
{
std::array<int,4> results = {{players[0].cash,players[1].cash,players[2].cash,players[3].cash}};
auto minmax = std::minmax_element(std::begin(results), std::end(results));
int maxResult = *(minmax.second);
int result = 0;
int pos = -1;
for (int i=0; i<4;i++)
{
if (players[i].cash == maxResult)
{
result += 1;
pos = i;
}
};
if (result==1)
{
return pos;
}
return -1;
}
/*!
* \brief Game::handleLeftClick
* \param pos
* \param posFull
* \param mousePos
*/
void Game::handleLeftClick(sf::Vector2f pos,sf::Vector2f posFull, int mousePos) {
if (currentState==state_game)
{
if (players[turn].human)
{
std::array<int,2> movements = players[turn].getMovements(diceResultPlayer);
if ((mousePos==movements[0]) || (mousePos==movements[1]))
{
playerMakeMove(mousePos);
}
}
}
if (currentState==state_setup_players)
{
for (int i=0;i<4;i++)
{
sf::IntRect spriteHumanRect(players[i].spriteAI.getGlobalBounds());
if (spriteHumanRect.intersects(sf::IntRect(posFull.x, posFull.y, 1, 1)))
{
players[i].swapHuman();
}
}
sf::IntRect startGameRect(580,640,180,80);
if (startGameRect.intersects(sf::IntRect(posFull.x, posFull.y, 1, 1)))
{
bigDiamondActive = true;
banner.setText("start game");
currentState=state_roll_dice;
launchNextPlayer();
return;
}
}
else if (currentState==state_roll_dice)
{
if (players[turn].human){
sf::IntRect diceRect(roundDice.spriteDice.getGlobalBounds());
if (diceRect.intersects(sf::IntRect(posFull.x, posFull.y, 1, 1)))
{
throwDiceMove();
}
}
}
if (currentState==state_menu)
{
downTimeCounter = 0;
hideMenu();
showGameBoard();
return;
}
if (currentState==state_gui_end_round)
{
std::string resultCommand = guiRoundDice.getElem(pos);
command(resultCommand);
}
if (currentState==state_lets_begin)
{
if (downTimeCounter>1)
{
currentState = state_roll_dice;
restartGame();
launchNextPlayer();
return;
}
}
if (currentState==state_end_game)
{
if (downTimeCounter>2)
{
currentState = state_menu;
musicMenu.play();
restartGame();
return ;
// restartGame();
}
}
}
Game::Game(bool newTestMode):
- screenSize(efc::initScreenX,efc::initScreenY),
+ screenSize(DP::initScreenX,DP::initScreenY),
viewFull(sf::FloatRect(00, 00, screenSize.x, screenSize.y)),
viewGui(sf::FloatRect(00, 00, screenSize.x, screenSize.y)),
viewTiles(sf::FloatRect(0, 0, 1360, 768)),
- selector(efc::TILE_SIZE),
+ selector(DP::TILE_SIZE),
character(&textures, 3),
gameTitle("deerportal"),
roundDice(players),
roundNumber(1),
guiRoundDice(&textures),
boardDiamonds(&textures),
- window(sf::VideoMode(efc::initScreenX, efc::initScreenY), "Deerportal - game about how human can be upgraded to the Deer"),
+ window(sf::VideoMode(DP::initScreenX, DP::initScreenY), "Deerportal - game about how human can be upgraded to the Deer"),
turn(0),
oscilator(-1),
oscilatorInc(true),
particleSystem( 430, 230),
commandManager(*this),
cardsDeck(&textures, &menuFont,&commandManager),
banner(&gameFont),
bigDiamondActive(false),
credits(&gameFont),
cpuTimeThinkingInterval(1.0f),
deerModeCounter(4),
deerModeActive(false),
gameVersion()
{
testMode = newTestMode;
// TODO: perhaps get rid of the particles at all...
particleSystem.setDissolve( true );
particleSystem.setDissolutionRate( 10 );
particleSystem.setShape( Shape::CIRCLE );
particleSystem.fuel( 1000 );
playersSpritesCords[0][0] = 202;
playersSpritesCords[0][1] = 76;
playersSpritesCords[1][0] = 562;
playersSpritesCords[1][1] = 76;
playersSpritesCords[3][0] = 202;
playersSpritesCords[3][1] = 436;
playersSpritesCords[2][0] = 562;
playersSpritesCords[2][1] = 436;
textLoading.setString("loading...");
textLoading.setFont(menuFont);
textLoading.setPosition(200,200);
textLoading.setColor(sf::Color::White);
textLoading.setCharacterSize(10);
renderTexture.create(1360,768);
renderTexture.clear(sf::Color::White);
renderTexture.draw(textLoading);
renderTexture.display();
renderSprite.setTexture(renderTexture.getTexture());
numberFinishedPlayers = 0;
sf::Clock frameClock;
guiRoundDice.active = true;
showPlayerBoardElems = false;
window.setVerticalSyncEnabled(true);
std::srand (time(NULL));
window.clear(sf::Color(55,55,55));
renderTexture.draw(textLoading);
window.display();
loadAssets();
textLoading.setFont(menuFont);
textLoading.setPosition(200,200);
textLoading.setColor(sf::Color::White);
textLoading.setCharacterSize(10);
renderTexture.clear(sf::Color::Black);
renderTexture.draw(textLoading);
window.display();
gameVersion.setString("version: " + std::string(DEERPORTAL_VERSION));
gameVersion.setFont(gameFont);
gameVersion.setPosition(10,10);
gameVersion.setColor(sf::Color::White);
gameVersion.setCharacterSize(15);
initBoard();
renderTexture.clear(sf::Color::Black);
renderTexture.draw(textLoading);
renderTexture.display();
showMenu();
// run the main loop
if (testMode){
std::exit(0);
}
while (window.isOpen())
{
sf::Time frameTime = frameClock.restart();
// handle events
sf::Event event;
float xpos = 320.0f;
float ypos = 240.0f;
float xgrv = 0.0f;
float ygrv = 0.0f;
while (window.pollEvent(event))
{
switch (event.type) {
case sf::Event::Closed:
window.close(); break;
case sf::Event::KeyPressed:
if(event.key.code == sf::Keyboard::Escape )
window.close();
if( sf::Keyboard::isKeyPressed( sf::Keyboard::Space ) )
particleSystem.fuel( 200/* * window.getFrameTime() */);
if( sf::Keyboard::isKeyPressed( sf::Keyboard::A ) )
particleSystem.setPosition( --xpos, ypos );
if( sf::Keyboard::isKeyPressed( sf::Keyboard::D ) )
particleSystem.setPosition( ++xpos, ypos );
if( sf::Keyboard::isKeyPressed( sf::Keyboard::W ) )
particleSystem.setPosition( xpos, --ypos );
if( sf::Keyboard::isKeyPressed( sf::Keyboard::S ) )
particleSystem.setPosition( xpos, ++ypos );
if( sf::Keyboard::isKeyPressed( sf::Keyboard::Left ) )
particleSystem.setGravity( --xgrv * 0.1f, ygrv * 0.1f);
if( sf::Keyboard::isKeyPressed( sf::Keyboard::Right ) )
particleSystem.setGravity( ++xgrv * 0.1f, ygrv * 0.1f );
if( sf::Keyboard::isKeyPressed( sf::Keyboard::Up ) )
particleSystem.setGravity( xgrv * 0.1f, --ygrv * 0.1f );
if( sf::Keyboard::isKeyPressed( sf::Keyboard::Down ) )
particleSystem.setGravity( xgrv * 0.1f, ++ygrv * 0.1f );
if( sf::Keyboard::isKeyPressed( sf::Keyboard::G ) )
particleSystem.setGravity( 0.0f, 0.0f );
if( sf::Keyboard::isKeyPressed( sf::Keyboard::P ) )
particleSystem.setPosition( 320.0f, 240.0f );
break;
default:
break;
}
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));
+ int mousePosX = (int)localPosition.x / DP::TILE_SIZE;
+ int mousePosY = (int)localPosition.y / DP::TILE_SIZE;
+ int mousePos = DP::transCords(sf::Vector2i(mousePosX, mousePosY));
if(event.type == sf::Event::Closed)
window.close();
// Showing mouse hover
if (currentState==state_game)
{
- if ((localPosition.x>efc::TILE_SIZE*efc::BOARD_SIZE) || (localPosition.x<0) || (localPosition.y>efc::TILE_SIZE*efc::BOARD_SIZE) || (localPosition.y<0))
+ if ((localPosition.x>DP::TILE_SIZE*DP::BOARD_SIZE) || (localPosition.x<0) || (localPosition.y>DP::TILE_SIZE*DP::BOARD_SIZE) || (localPosition.y<0))
{
showPlayerBoardElems = false;
} else {
showPlayerBoardElems = true;
}
}
- if ((localPosition.x>=0) && (localPosition.y>=0) && (localPosition.x<=efc::BOARD_SIZE*efc::TILE_SIZE) && (localPosition.y<=efc::BOARD_SIZE*efc::TILE_SIZE))
+ if ((localPosition.x>=0) && (localPosition.y>=0) && (localPosition.x<=DP::BOARD_SIZE*DP::TILE_SIZE) && (localPosition.y<=DP::BOARD_SIZE*DP::TILE_SIZE))
{
- selector.setPosition((int) (localPosition.x / efc::TILE_SIZE)*efc::TILE_SIZE, ((int) localPosition.y / efc::TILE_SIZE)*efc::TILE_SIZE);
+ selector.setPosition((int) (localPosition.x / DP::TILE_SIZE)*DP::TILE_SIZE, ((int) localPosition.y / DP::TILE_SIZE)*DP::TILE_SIZE);
}
/*!
* Handling mouse click
*/
if (event.type == sf::Event::MouseButtonReleased)
{
if (event.mouseButton.button == sf::Mouse::Left)
handleLeftClick(localPosition,
localPositionFull, mousePos);
}
}
update(frameTime);
render(frameTime.asSeconds());
}
}
void Game::update(sf::Time frameTime) {
banner.update(frameTime);
credits.update(frameTime);
runningCounter += frameTime.asSeconds();
cpuTimeThinking -= frameTime.asSeconds();
if (oscilatorInc)
{
oscilator += frameTime.asSeconds();
} else {
oscilator -= frameTime.asSeconds();
}
if (oscilator<-1)
oscilatorInc = true;
if (oscilator>1)
oscilatorInc = false;
float modifier = sin(oscilator/2.5)*30.0f;
spriteBigDiamond.setPosition(474,342+modifier);
if (currentState==state_roll_dice)
{
if ((cpuTimeThinking<0) && (players[turn].human==false))
{
cpuTimeThinking = cpuTimeThinkingInterval;
throwDiceMove();
}
}
if (currentState==state_game)
{
std::array<int,2> currentMovements = players[turn].getMovements(diceResultPlayer);
if ((cpuTimeThinking<0) && (players[turn].human==false))
{
std::vector<int> listRandomPos;
if (currentMovements[0]>-1) {
listRandomPos.push_back(currentMovements[0]);
}
if (currentMovements[1]>-1) {
listRandomPos.push_back(currentMovements[1]);
}
unsigned int sizeRndPos = listRandomPos.size();
if (sizeRndPos==0) {
} else if (sizeRndPos==1) {
playerMakeMove(listRandomPos[0]);
} else if (sizeRndPos==2) {
if (deerModeActive)
{
playerMakeMove(listRandomPos[1]);
} else
{
if (players[turn].reachPortalMode == true)
{
playerMakeMove(listRandomPos[1]);
}
else
{
if (boardDiamonds.ifFieldIsEmpty(listRandomPos[1])==false)
{
playerMakeMove(listRandomPos[1]);
return;
}
if (boardDiamonds.ifFieldIsEmpty(listRandomPos[0])==false)
{
playerMakeMove(listRandomPos[0]);
return;
}
if ((boardDiamonds.ifFieldIsEmpty(listRandomPos[0])==false) && (boardDiamonds.ifFieldIsEmpty(listRandomPos[1])==false))
{
playerMakeMove(listRandomPos[1]);
return;
}
int randPos = rand() % 2;
playerMakeMove(listRandomPos[randPos]);
};
}
}
}
if (currentMovements[0]>-1)
{
prevRotateElem.spriteRotate.setPosition(players[turn].characters[0].leftChar.getPosition());
prevRotateElem.spriteRotate.move(10,20);
// Modificator to fit on the bigger view
prevRotateElem.spriteRotate.move(-202,-76);
prevRotateElem.update(frameTime);
prevRotateElem.setColor();
}
if (currentMovements[1]>-1)
{
nextRotateElem.spriteRotate.setPosition(players[turn].characters[0].rightChar.getPosition());
nextRotateElem.spriteRotate.move(10,20);
// Modificator to fit on the bigger view
nextRotateElem.spriteRotate.move(-202,-76);
nextRotateElem.update(frameTime);
nextRotateElem.setColor();
}
}
cardsDeck.update(frameTime);
for (int i=0;i<4;i++)
{
players[i].play();
players[i].update(frameTime);
}
if (currentState==state_lets_begin)
{
downTimeCounter += frameTime.asSeconds();
spriteLestBegin.setColor(sf::Color(255,255,255,255-(downTimeCounter*35)));
if (downTimeCounter>5)
{
currentState = state_roll_dice;
bubble.state = BubbleState::DICE;
}
}
if (currentState==state_end_game)
{
downTimeCounter += frameTime.asSeconds();
}
bubble.update(frameTime);
}
/*!
* \brief Game::nextRound is happening each every 4 months
*/
void Game::nextRound() {
turn = 0;
// std::string result = roundDice.drawRound();
roundNumber += 1;
month++;
if (month==13)
month=1;
if (month%4==0)
currentSeason++;
if (currentSeason>3)
currentSeason=0;
// if (players[turn].done==true)
// nextPlayer();
launchNextPlayer();
}
/*!
* \brief Game::nextPlayer calculates which player should play
*/
void Game::nextPlayer(){
// End of game - we don't calculate more players
if (currentState==state_end_game)
{
return;
}
// End of game - we don't calculate more players
if (numberFinishedPlayers==4)
{
endGame();
return ;
}
// Update old player
players[turn].updatePlayer();
if (turn>2)
{
nextRound();
return;
}
turn++;
launchNextPlayer();
}
void Game::launchNextPlayer(){
if (deerModeActive)
{
deerModeCounter -= 1;
}
if (deerModeCounter<0)
{
endGame();
return ;
}
// Just control
if (players[turn].done==true)
{
nextPlayer();
return;
}
// Frozen player
if (players[turn].frozenLeft>0)
{
players[turn].frozenLeft -= 1;
nextPlayer();
return;
}
// Here we process new player
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();
diceResultPlayer = 6;
roundDice.setDiceTexture(diceResultPlayer);
players[turn].characters[0].diceResult = diceResultPlayer;
groupHud.setRoundName(roundNumber);
if (deerModeActive==false)
{
groupHud.setSeason(currentSeason);
groupHud.setMonthName(month%4);
} else
{
groupHud.setDeerModeActive();
int number = (deerModeCounter/4);
if (deerModeCounter<16)
number += 1;
if (number<0)
{
endGame();
return;
}
groupHud.setDeerModeCounter(number);
}
currentState = state_roll_dice;
bubble.state = BubbleState::DICE;
roundDice.setColor(turn);
bubble.setPosition(players[turn].characters[0].getPosition().x-30,
players[turn].characters[0].getPosition().y-45);
cpuTimeThinking = cpuTimeThinkingInterval;
if (mostDiamonds()==turn)
{
players[turn].reachPortalMode = true;
} else {
players[turn].reachPortalMode = false;
}
}
void Game::drawPlayersGui(){
for (int i=0;i<4;i++)
{
renderTexture.draw(players[i]);
}
}
void Game::drawSquares() {
if (showPlayerBoardElems)
{
renderTexture.draw(selector);
}
}
void Game::drawBaseGame()
{
renderTexture.setView(viewTiles);
for (int i=0;i<4;i++)
{
renderTexture.draw(players[i].elems);
}
drawSquares();
renderTexture.setView(viewGui);
renderTexture.setView(viewTiles);
renderTexture.setView(viewTiles); // Yeah Katia's inspiration
shaderBlur.setParameter("blur_radius", sin(runningCounter*0.01f) );
// renderTexture.draw(gameBackground);
renderTexture.setView(viewFull);
// renderTexture.draw(spriteBackgroundArt, &shaderDark);
// spriteBackgroundArt.setColor(sf::Color(255, 255, 255, 208));
shaderBlur.setParameter("blur_radius", 0.01);
// shaderBlur.setParameter("blur_radius", sin(runningCounter*0.01) );
// shaderBlur.setParameter("blur_radius", sin(runningCounter*0.01) );
shaderPixel.setParameter("pixel_threshold", sin(runningCounter* 0.005f));
renderTexture.draw(spriteBackgroundArt);
spriteBackgroundArt.setColor(sf::Color(255, 255, 255));
shaderBlur.setParameter("blur_radius", sin(runningCounter* 0.05f)/2);
renderTexture.draw(cardsDeck);
if (currentState==state_roll_dice)
{
spriteBackgroundArt.setColor(sf::Color(255, 255, 255));
shaderBlur.setParameter("blur_radius", sin(runningCounter* 0.5f)/4);
renderTexture.draw(roundDice.spriteDice);
}
else
renderTexture.draw(roundDice.spriteDice);
renderTexture.setView(viewTiles);
drawSquares();
}
void Game::drawCharacters(){
if (currentState==state_game)
{
std::array<int,2> currentMovements = players[turn].characters[0].getMovements(diceResultPlayer);
if (currentMovements[1]>-1)
{
if (nextRotateElem.active)
renderTexture.draw(nextRotateElem);
}
if (currentMovements[0]>-1)
{
if (prevRotateElem.active)
renderTexture.draw(prevRotateElem);
}
}
renderTexture.setView(viewFull);
shaderBlur.setParameter("blur_radius", 0.005f);
for (int i=0;i<4;i++)
{
for (auto&& j: players[i].characters)
{
if (currentState==state_game)
j.drawMovements = true;
else
j.drawMovements = false;
renderTexture.draw(j);
// renderTexture.draw(j, &shaderBlur);
}
}
}
/*!
* \brief Game::render main function responsible for drawing all elements
* \param deltaTime
*/
void Game::render(float deltaTime)
{
window.clear();
renderTexture.clear();
if ((currentState==state_game) or (currentState==state_roll_dice))
{
renderTexture.setView(viewFull);
renderTexture.draw(spriteBackgroundDark);
renderTexture.setView(viewTiles);
drawBaseGame();
renderTexture.setView(viewFull);
renderTexture.draw(groupHud);
renderTexture.setView(viewTiles);
drawCharacters();
renderTexture.draw(boardDiamonds);
renderTexture.draw(bubble);
renderTexture.setView(viewFull);
drawPlayersGui();
renderTexture.setView(viewFull);
} else if (currentState==state_setup_players) {
renderTexture.setView(viewFull);
renderTexture.draw(spriteDeerGod);
for (int i=0;i<4;i++)
{
renderTexture.draw(players[i].spriteAI);
}
} else if (currentState==state_gui_elem) {
renderTexture.setView(viewFull);
shaderBlur.setParameter("blur_radius", 2);
renderTexture.draw(spriteBackgroundDark, &shaderBlur);
drawBaseGame();
drawCharacters();
renderTexture.setView(viewFull);
renderTexture.draw(groupHud);
} else if (currentState==state_menu) {
// shaderBlur.setParameter("blur_radius", 15);
renderTexture.draw(menuBackground);
// // renderTexture.draw(menuTxt, &shaderBlur);
// renderTexture.draw(menuTxt);
renderTexture.draw(paganHolidayTxt);
renderTexture.draw(gameVersion);
renderTexture.draw(credits);
} else if (currentState==state_lets_begin) {
renderTexture.setView(viewFull);
shaderBlur.setParameter("blur_radius", 4);
renderTexture.draw(spriteBackgroundDark, &shaderBlur);
renderTexture.setView(viewTiles);
drawBaseGame();
drawCharacters();
renderTexture.draw(boardDiamonds, &shaderBlur);
renderTexture.setView(viewFull);
drawPlayersGui();
renderTexture.draw(spriteLestBegin,&shaderBlur);
} else if (currentState==state_gui_end_round){
renderTexture.setView(viewFull);
renderTexture.draw(spriteBackgroundDark);
drawBaseGame();
shaderBlur.setParameter("blur_radius", 0.05f);
renderTexture.draw(guiRoundDice, &shaderBlur);
renderTexture.setView(viewFull);
renderTexture.draw(groupHud);
}
else if (currentState==state_end_game){
renderTexture.setView(viewFull);
renderTexture.draw(spriteBackgroundDark);
renderTexture.draw(spriteLestBegin,&shaderBlur);
renderTexture.draw(endGameTxt);
// for (int i=0;i<4;i++){
// if (players[i].reachedPortal)
// renderTexture.draw(endGameTxtAmount[i]);
// }
renderTexture.draw(txtWinner);
renderTexture.draw(txtSurvivorsLabel);
for (unsigned int i=0; i<txtSurvivors.size();i++) {
renderTexture.draw(txtSurvivors[i]);
}
renderTexture.draw(txtLoosersLabel);
for (unsigned int i=0; i<txtLoosers.size();i++) {
renderTexture.draw(txtLoosers[i]);
}
}
if (bigDiamondActive)
renderTexture.draw(spriteBigDiamond);
if (banner.active)
renderTexture.draw(banner);
renderTexture.display();
renderSprite.setTexture(renderTexture.getTexture());
shaderBlur.setParameter("blur_radius", sin(deltaTime)*0.015f);
shaderBlur.setParameter("blur_radius", 0.0003f);
window.draw(renderSprite, &shaderBlur);
particleSystem.remove();
particleSystem.update();
particleSystem.render();
window.draw( particleSystem.getSprite() );
window.display();
}
void Game::command(std::string command){
if (command.compare("end_of_round")==0)
{
std::string subResult = command.substr(13);
guiRoundDice.active = true;
guiRoundDice.setTitle(subResult);
currentState = state_gui_end_round;
}
if (command=="end_turn")
nextPlayer();
}
/*!
* \brief Game::startDeerMode launches last episode of the game
*/
void Game::startDeerMode() {
deerModeActive = true;
deerModeCounter = 16;
banner.setText("deer mode");
bigDiamondActive = false;
sfx.soundDeerMode.play();
}
}
diff --git a/src/game.h b/src/game.h
index e70b1c4..f70b1af 100644
--- a/src/game.h
+++ b/src/game.h
@@ -1,221 +1,221 @@
#ifndef GAME_H
#define GAME_H
#include <stdlib.h>
#include <iostream>
#include <ctime>
#include <time.h> /* time */
#include <SFML/Window.hpp>
#include <SFML/Graphics.hpp>
#include <SFML/Audio.hpp>
#include "command.h"
#include "tilemap.h"
#include "selector.h"
#include "playerhud.h"
#include "textureholder.h"
#include "hover.h"
#include "guiwindow.h"
#include "rounddice.h"
#include "guirounddice.h"
#include "grouphud.h"
#include "animatedsprite.h"
#include "character.h"
#include "rotateelem.h"
#include "boarddiamondseq.h"
#include "soundfx.h"
#include "cardsdeck.h"
#include "calendar.h"
#include "particle.h"
#include "bubble.h"
//class Command;
#include "banner.h"
#include "credits.h"
-namespace efc {
+namespace DP {
extern int initScreenX;
extern int initScreenY;
/*!
* \brief Game is a main class of the Deer Portal - contains most logic but also rendering.
*/
class Game
{
public:
sf::Vector2i screenSize;
sf::View viewFull;
sf::View viewGui;
sf::View viewTiles;
void setTxtEndGameAmount();
private:
Selector selector;
Character character;
std::string gameTitle;
std::string paganHolidayString;
RoundDice roundDice;
int roundNumber;
GuiRoundDice guiRoundDice;
public:
Game(bool newTestMode);
BoardDiamondSeq boardDiamonds;
sf::RenderWindow window;
sf::RenderTexture renderTexture;
sf::Sprite renderSprite;
Player players[4];
SoundFX sfx;
int turn;
private:
void initBoard();
void restartGame();
void loadAssets();
void drawPlayersGui();
void drawSquares();
void drawMenu();
float runningCounter;
float oscilator;
bool oscilatorInc;
sf::Sprite playersSprites[4] ;
int playersSpritesCords[4][2];
enum states {
state_init,
state_menu,
state_setup_players,
state_lets_begin,
state_roll_dice,
state_game,
state_gui_elem,
state_select_building,
state_gui_end_round,
state_end_game,
state_quit
};
states currentState;
sf::Sprite spriteDeerGod;
sf::Sprite spriteBackgroundDark;
sf::Sprite spriteLestBegin;
sf::Texture textureBackgroundArt;
sf::Sprite spriteBackgroundArt;
sf::Texture textureTiles;
sf::Texture textureFaces;
sf::Font gameFont;
sf::Font menuFont;
sf::Text menuTxt;
sf::Text endGameTxt;
sf::Text endGameTxtAmount[4];
sf::Text paganHolidayTxt;
sf::Text gameVersion;
sf::Shader shaderBlur;
sf::Shader shaderPixel;
sf::Shader shaderDark;
int mapSize;
int level[256];
int levelElems[256];
TextureHolder textures;
std::set<int> currentNeighbours;
void command(std::string command);
int selectedPos;
void update(sf::Time frameTime);
void render(float deltaTime);
ParticleSystem particleSystem;
void setCurrentNeighbours ();
void nextPlayer();
void launchNextPlayer();
void nextRound();
sf::Sprite menuBackground;
sf::Sprite seasons[4];
sf::Music musicGame;
sf::Music musicMenu;
sf::SoundBuffer sfxClickBuffer;
sf::Sound sfxClick;
sf::SoundBuffer sfxDoneBuffer;
sf::Sound sfxDone;
void showMenu();
void hideMenu();
void showGameBoard();
GroupHud groupHud;
/*!
* \brief showPlayerBoardElems defines if show mouse hover for the player
*/
bool showPlayerBoardElems;
void drawBaseGame();
int month;
Animation walkingAnimationDown;
Animation walkingAnimationUp;
Animation walkingAnimationLeft;
Animation walkingAnimationRight;
Animation* currentAnimation;
AnimatedSprite animatedSprite;
void drawCharacters();
void handleLeftClick(sf::Vector2f pos, sf::Vector2f posFull, int mousePos);
std::set<int> busyTiles;
int diceResultPlayer;
int numberFinishedPlayers;
RotateElem nextRotateElem;
RotateElem prevRotateElem;
void endGame();
float downTimeCounter;
Command commandManager;
sf::Text textLoading;
public:
CardsDeck cardsDeck;
void startDeerMode();
sf::Text txtWinner;
sf::Text txtSurvivorsLabel;
sf::Text txtLoosersLabel;
std::vector<sf::Text> txtSurvivors;
std::vector<sf::Text> txtLoosers;
void throwDiceMove();
void playerMakeMove(int mousePos);
float cpuTimeThinking;
Banner banner;
sf::Sprite spriteBigDiamond;
bool bigDiamondActive;
int mostDiamonds() const;
Credits credits;
float cpuTimeThinkingInterval;
private:
Bubble bubble;
int deerModeCounter;
bool deerModeActive;
public:
bool testMode;
};
}
#endif // GAME_H
diff --git a/src/grouphud.cpp b/src/grouphud.cpp
index 07f9ba9..647fa9f 100644
--- a/src/grouphud.cpp
+++ b/src/grouphud.cpp
@@ -1,74 +1,74 @@
#include "grouphud.h"
#include "data.h"
-namespace efc {
+namespace DP {
GroupHud::GroupHud(sf::Font *gameFont)
{
seasonName.setFont(*gameFont);
}
GroupHud::GroupHud(){
}
void GroupHud::setFont(sf::Font *gameFont) {
seasonName.setFont(*gameFont);
roundName.setFont(*gameFont);
monthName.setFont(*gameFont);
seasonName.setColor(sf::Color(255,255,255));
seasonName.setCharacterSize(30);
roundName.setCharacterSize(30);
monthName.setCharacterSize(30);
roundName.setColor(sf::Color(255,255,250));
// monthName.move(400, 0);
setMonthName(1);
}
void GroupHud::setSeason(int seasonNumber){
- seasonName.setString("Season: " + efc::seasonsNames[seasonNumber]);
+ seasonName.setString("Season: " + DP::seasonsNames[seasonNumber]);
setPosition(440,12);
}
void GroupHud::setDeerModeActive(){
seasonName.setString("Deer Mode");
setPosition(455,12);
}
void GroupHud::setRoundName(int roundNumber){
roundName.setString("Round: " + std::to_string(roundNumber));
roundName.setPosition(30, 700);
}
void GroupHud::setDeerModeCounter(int deerModeCounter)
{
roundName.setString(std::to_string(deerModeCounter));
roundName.setPosition(50, 700);
}
//void
void GroupHud::setMonthName(int monthNumber){
monthName.setString("Month: " + std::to_string(monthNumber));
}
void GroupHud::draw(sf::RenderTarget& target, sf::RenderStates states) const{
states.transform *= getTransform();
target.draw(seasonName, states);
target.draw(roundName, states);
// target.draw(monthName, states);
}
}
diff --git a/src/grouphud.h b/src/grouphud.h
index 6e232d2..3be1f8d 100644
--- a/src/grouphud.h
+++ b/src/grouphud.h
@@ -1,32 +1,32 @@
#ifndef GROUPHUD_H
#define GROUPHUD_H
#include <SFML/Window.hpp>
#include <SFML/Graphics.hpp>
#include <SFML/System.hpp>
-namespace efc {
+namespace DP {
/*!
* \brief The GroupHud is a drawable type describing a season and a round.
*/
class GroupHud: public sf::Drawable, public sf::Transformable
{
public:
explicit GroupHud( sf::Font *gameFont);
GroupHud();
void setFont(sf::Font *gameFont);
sf::Text seasonName;
sf::Text roundName;
sf::Text monthName;
void setSeason(int seasonNumber);
void setRoundName(int roundNumber);
void setMonthName(int monthNumber);
void draw(sf::RenderTarget& target, sf::RenderStates states) const;
void setDeerModeCounter(int deerModeCounter);
void setDeerModeActive();
};
}
#endif // GROUPHUD_H
diff --git a/src/main.cpp b/src/main.cpp
index ded866e..2d3bdca 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,29 +1,29 @@
#include <iostream>
#include "game.h"
using namespace std;
int main(int argc, // Number of strings in array argv
char *argv[] // Array of command-line argument strings
)
{
if (argc>1)
{
std::string commandMe;
commandMe = argv[1];
if ((argc==2) && (commandMe=="--test"))
{
- efc::Game game(true);
+ DP::Game game(true);
} else{
- efc::Game game(false);
+ DP::Game game(false);
}
} else
{
- efc::Game game(false);
+ DP::Game game(false);
}
return 0;
}
diff --git a/src/playerhud.cpp b/src/playerhud.cpp
index 4956100..b98dfa1 100644
--- a/src/playerhud.cpp
+++ b/src/playerhud.cpp
@@ -1,242 +1,242 @@
#include "playerhud.h"
#include "textureholder.h"
#include "boardelem.h"
std::set<int> Player::getTerrainSet(){
std::set<int> terrain;
- for (int i: efc::terrainArray)
+ for (int i: DP::terrainArray)
{
terrain.insert(i);
}
return terrain;
}
std::set<int> Player::getBusy(){
std::set<int> busyTiles;
- for (std::pair<int, efc::BoardElem> i: elems.items_map)
+ for (std::pair<int, DP::BoardElem> i: elems.items_map)
{
busyTiles.insert(i.first);
}
return busyTiles;
}
std::set<int> Player::getNeighbours(){
std::set<int> neighbours;
- for (std::pair<int, efc::BoardElem> i: elems.items_map)
+ for (std::pair<int, DP::BoardElem> i: elems.items_map)
{
std::set<int> terrain = getTerrainSet();
- std::set<int> neighboursVector(efc::getNeighbours(i.second.pos));
+ std::set<int> neighboursVector(DP::getNeighbours(i.second.pos));
for (int j: neighboursVector)
{
if ((elems.items_map.count(j) == 0) && (terrain.count(j)==0))
{
neighbours.insert(j);
}
}
}
return neighbours;
}
void Player::updateTxt(){
txtCash.setString(std::to_string(cash));
}
void Player::updatePlayer(){
updateTxt();
}
Player::Player():
frozenLeft(0),
reachedPortal(false),
reachedPortalFirst(false),
human(false),
reachPortalMode(false)
{
pos = 0;
cash = 0;
energy = 0;
food = 0;
faith = 0;
active = false;
done = false;
tileSize = 0;
textures = nullptr;
number = 0;
}
void Player::setActive(bool newState){
active = newState;
elems.active = newState;
for (auto&& i: characters)
{
i.active = newState;
}
}
Player::Player(TextureHolder *textures, sf::Font *gameFont, int playerNumber):
reachedPortal(false),
reachedPortalFirst(false),
human(false),
reachPortalMode(false)
{
number = playerNumber;
frozenLeft = 0;
done = false;
active = false;
this->textures = textures;
characters.push_back(Character (this->textures, playerNumber));
this->pos = playerNumber;
food = 0;
cash = 0;
energy = 0;
faith = 0;
txtCash.setFont(*gameFont);
txtCash.setCharacterSize(20);
txtFood.setFont(*gameFont);
txtEnergy.setFont(*gameFont);
txtFaith.setFont(*gameFont);
txtNextRound.setFont(*gameFont);
txtNextRound.setString("End Turn");
txtNextRound.setCharacterSize(12);
txtNextRound.setPosition(40,(playerNumber*100)+10);
int posX1 = 82;
int posX2 = 962;
int posY1 = 22;
int posY2 = 720;
std::array<std::array<int,2>,4> textPos = {{{
{posX1,posY1}}, {{posX2,posY1}},{{posX1,posY2}}, {{posX2, posY2}
}}};
txtCash.setPosition(textPos[playerNumber][0],textPos[playerNumber][1] );
buttons.insert({"end_turn",rectangle});
setSpriteAI();
}
std::string Player::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 Player::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
states.transform *= getTransform();
target.draw(txtCash, states);
}
void Player::play()
{
for (auto&& i: characters)
{
i.play();
}
}
void Player::update(sf::Time deltaTime)
{
updateTxt();
if (frozenLeft==0)
{
for (auto&& i: characters)
{
sf::Vector2f movement(0.f, 0.f);
- if (i.currentAnimationIndex==efc::DIR_LEFT)
+ if (i.currentAnimationIndex==DP::DIR_LEFT)
movement = sf::Vector2f (-10.f, 0.f);
- else if (i.currentAnimationIndex==efc::DIR_RIGHT)
+ else if (i.currentAnimationIndex==DP::DIR_RIGHT)
movement = sf::Vector2f (10.f, 0.f);
- else if (i.currentAnimationIndex==efc::DIR_UP)
+ else if (i.currentAnimationIndex==DP::DIR_UP)
movement = sf::Vector2f (0.f, -10.f);
- else if (i.currentAnimationIndex==efc::DIR_DOWN)
+ else if (i.currentAnimationIndex==DP::DIR_DOWN)
movement = sf::Vector2f (0.f, 10.f);
i.update(deltaTime);
}
} else{
- characters[0].currentAnimationIndex=efc::DIR_DOWN;
+ characters[0].currentAnimationIndex=DP::DIR_DOWN;
}
}
std::array<int,2> Player::getMovements(int diceResult)
{
return characters[0].getMovements(diceResult);
}
void Player::setFigurePos(int pos)
{
characters[0].setBoardPosition(pos);
}
void Player::restartPlayer(){
food = 0;
cash = 0;
energy = 0;
faith = 0;
}
void Player::setHuman(bool newHuman)
{
human = newHuman;
setSpriteAI();
}
void Player::swapHuman()
{
if (human)
{
setHuman(false);
return;
} else {
setHuman(true);
return;
}
}
void Player::setSpriteAI()
{
if (human)
spriteAI.setTexture(textures->textureButtonHuman);
else
spriteAI.setTexture(textures->textureButtonCpu);
std::array<std::array<int,2>,4> spriteHumanPos =
{
{
{{220,450}}, {{1050,450}},
{{140,600}}, {{1110, 600}}
}
};
sf::Vector2f spriteHumanPosNew(spriteHumanPos[number][0],spriteHumanPos[number][1]);
spriteAI.setPosition(spriteHumanPosNew);
}
diff --git a/src/rotateelem.cpp b/src/rotateelem.cpp
index 5962a55..f21e8fb 100644
--- a/src/rotateelem.cpp
+++ b/src/rotateelem.cpp
@@ -1,60 +1,60 @@
#include "rotateelem.h"
RotateElem::RotateElem():
timeCounter(0),
active(true)
{
if (!textureRotate.loadFromFile("assets/img/rotate.png"))
std::exit(1);
spriteRotate.setTexture(textureRotate);
spriteRotate.scale(0.7f,0.7f);
spriteRotate.setOrigin(32, 32);
}
void RotateElem::draw(sf::RenderTarget& target, sf::RenderStates states) const{
states.transform *= getTransform();
target.draw(spriteRotate, states);
}
void RotateElem::update(sf::Time deltaTime)
{
float speed;
speed = 0.05f/deltaTime.asSeconds();
spriteRotate.rotate(1.0f*speed);
timeCounter += deltaTime.asSeconds();
if (timeCounter>0.40f)
if (timeCounter>0.40f)
{
if (active)
{
active = false;
} else {
active = true;
};
timeCounter = 0;
}
}
void RotateElem::setColor()
{
-// spriteRotate.setColor(efc::playersColors[playerNumber]);
+// spriteRotate.setColor(DP::playersColors[playerNumber]);
spriteRotate.setColor(sf::Color::White);
}
void RotateElem::reset()
{
active = true;
timeCounter = 0;
}
diff --git a/src/rounddice.cpp b/src/rounddice.cpp
index 4dde32a..4d211a6 100644
--- a/src/rounddice.cpp
+++ b/src/rounddice.cpp
@@ -1,68 +1,68 @@
#include "rounddice.h"
RoundDice::RoundDice(Player (&players)[4])
{
playersHud = players;
diceResult = 1;
diceResultSix = 6;
diceSize = 150;
if (!sfxDiceBuffer.loadFromFile("assets/audio/dice.ogg"))
std::exit(1);
if (!textureDice.loadFromFile("assets/img/diceWhite.png"))
std::exit(1);
spriteDice.setTexture(textureDice);
sfxDice.setBuffer(sfxDiceBuffer);
sfxDice.setVolume(12);
spriteDice.setPosition(1140,550);
setDiceTexture();
}
void RoundDice::setDiceTexture(){
sf::IntRect diceRect(diceSize*diceResultSix, 0, diceSize, diceSize);
spriteDice.setTextureRect(diceRect);
}
void RoundDice::setColor(int playerNumber){
- sf::Color color(efc::playersColors[playerNumber]);
+ sf::Color color(DP::playersColors[playerNumber]);
spriteDice.setColor(color);
}
void RoundDice::setDiceTexture(int diceResult){
this->diceResultSix = diceResult;
setDiceTexture();
}
std::string RoundDice::drawRound(){
throwDice();
if (diceResult<33)
{
return "end_of_round_extra_grow";
} else if (diceResult<66)
{
return "end_of_round_extra_energy";
} else
{
// eventExtraCash();
return "end_of_round_extra_cash";
}
return "end_of_round_"+std::to_string(diceResult);
}
int RoundDice::throwDice(){
sfxDice.play();
int result = rand()%100;
diceResult = result;
return result;
}
int RoundDice::throwDiceSix(){
sfxDice.play();
int result = rand()%6;
diceResultSix = result;
setDiceTexture();
// return 26;
return result+1;
}
diff --git a/src/selector.cpp b/src/selector.cpp
index 3a22e9a..78ece82 100644
--- a/src/selector.cpp
+++ b/src/selector.cpp
@@ -1,27 +1,27 @@
#include "selector.h"
Selector::Selector(int squareSize)
:rectangle(sf::Vector2f(squareSize-1, squareSize-1))
{
this->squareSize = squareSize;
rectangle.setFillColor(sf::Color(150, 250, 150,168));
// rectangle./*setOutlineThickness*/(1);
rectangle.setOutlineColor(sf::Color(0,255,0));
changeColor(3);
}
void Selector::changeColor(int colorNumber)
{
- sf::Color color(efc::playersColors[colorNumber]);
+ sf::Color color(DP::playersColors[colorNumber]);
color.a = 128;
rectangle.setFillColor(color);
}
void Selector::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
// // apply the transform
states.transform *= getTransform();
target.draw(rectangle, states);
}
diff --git a/src/textureholder.cpp b/src/textureholder.cpp
index a6ef808..727eaa7 100644
--- a/src/textureholder.cpp
+++ b/src/textureholder.cpp
@@ -1,154 +1,154 @@
#include <iostream>
#include "textureholder.h"
-namespace efc {
+namespace DP {
std::set<int> getTerrainSet() {
std::set<int> terrain;
- for (int i: efc::terrainArray)
+ for (int i: DP::terrainArray)
{
terrain.insert(i);
}
return terrain;
}
}
TextureHolder::TextureHolder()
{
// "stop", "card", "diamond", "diamond x 2"
std::string cardsImages[4][4] = {
{"card-water-stop.small.png", "card-water-remove-card.small.png","card-water-diam.small.png", "card-water-2-diam.small.png" },
{"card-earth-stop.small.png", "card-earth-remove-card.small.png","card-earth-diam.small.png", "card-earth-2-diam.small.png"},
{"card-fire-stop.small.png", "card-fire-remove-card.small.png","card-fire-diam.small.png", "card-fire-2-diam.small.png"},
{"card-air-stop.small.png", "card-air-remove-card.small.png", "card-air-diam.small.png", "card-air-2-diam.small.png" }
};
for (int i=0;i<4;i++)
{
for (int j=0;j<4;j++)
{
if(!cardsTextures[i][j].loadFromFile("assets/img/cards/"+cardsImages[i][j]))
{
// std::cout << "assets/img/cards/" << cardsImages[i][j];
std::exit(1);
} else {
// std::cout << "assets/img/cards/" << cardsImages[i][j] << " ok " << i << " " << j << " " << std::endl;
}
}
}
if (!textureCardBases[0].loadFromFile("assets/img/card-water-2-diam_m.png"))
std::exit(1);
if (!textureCardBases[1].loadFromFile("assets/img/card-earth-2-diam_m.png"))
std::exit(1);
if (!textureCardBases[2].loadFromFile("assets/img/card-fire-2-diam_m.png"))
std::exit(1);
if (!textureCardBases[3].loadFromFile("assets/img/card-air-2-diam_m.png"))
std::exit(1);
// if (!textureGameBackground.loadFromFile("assets/img/game-ackground.png"))
// std::exit(1);
// 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 (!textureSeasons.loadFromFile("assets/img/seasons.png"))
// std::exit(1);
if (!textureCharacters.loadFromFile("assets/img/characters-new.png"))
std::exit(1);
if (!backgroundDark.loadFromFile("assets/img/background_dark.png"))
std::exit(1);
if (!textureBoardDiamond.loadFromFile("assets/img/board_diamonds.png"))
std::exit(1);
if (!textureMenu.loadFromFile("assets/img/dp_intro_menu.png"))
std::exit(1);
if (!textureLetsBegin.loadFromFile("assets/img/letsbegin.png"))
std::exit(1);
if (!textureButtonCpu.loadFromFile("assets/img/button-cpu.png"))
std::exit(1);
if (!textureButtonHuman.loadFromFile("assets/img/button-human.png"))
std::exit(1);
if (!textureDeerGod.loadFromFile("assets/img/deer-god.png"))
std::exit(1);
if (!textureBigDiamond.loadFromFile("assets/img/diamond-big.png"))
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.\nEnergy is a basic resource in a game,\nneeded by other buildings to running them."});
tilesTxt.insert({442, "Granary, food storehouse.\nFood gives your people ability to live.\nWithout the food your people will face\na death by starvation."});
tilesTxt.insert({585, "Marketplace, generates cash.\nProvides your tribe trading area.\nToday's offer - dog's bone."});
tilesTxt.insert({1100, "Monasterium, increase your faith.\nAs we all know, our world is being ruled\nby four ancient gods..."});
}
diff --git a/src/textureholder.h b/src/textureholder.h
index 40af92c..ede2f44 100644
--- a/src/textureholder.h
+++ b/src/textureholder.h
@@ -1,57 +1,57 @@
#ifndef TEXTUREHOLDER_H
#define TEXTUREHOLDER_H
#include <set>
#include <SFML/Window.hpp>
#include <SFML/Graphics.hpp>
#include "data.h"
#include <array>
-namespace efc {
+namespace DP {
std::set<int> getTerrainSet();
}
/*!
* \brief The TextureHolder contains most textures.
*/
class TextureHolder
{
public:
TextureHolder();
// sf::Texture textureTiles;
// sf::Texture textureFaces;
// sf::Texture textureGui;
sf::Texture textureMenu;
// sf::Texture textureSymbols;
// sf::Texture textureSeasons;
sf::Texture backgroundDark;
sf::Texture textureCharacters;
// sf::Texture textureGameBackground;
sf::Texture textureBoardDiamond;
sf::Texture textureLetsBegin;
sf::Texture textureCardBase0;
sf::Texture textureCardBase1;
sf::Texture textureCardBase2;
sf::Texture textureCardBase3;
sf::Texture textureButtonCpu;
sf::Texture textureButtonHuman;
sf::Texture textureDeerGod;
std::array<sf::Texture, 4> textureCardBases;
std::map<int, std::map<int, int>> tilesDescription;
std::map<int, std::string> tilesTxt;
std::array<std::array<sf::Texture,4>,4> cardsTextures;
sf::Texture textureBigDiamond;
};
#endif // TEXTUREHOLDER_H
diff --git a/src/tilemap.cpp b/src/tilemap.cpp
index 532f0f0..a20c391 100644
--- a/src/tilemap.cpp
+++ b/src/tilemap.cpp
@@ -1,172 +1,172 @@
#include "tilemap.h"
-namespace efc {
+namespace DP {
/*!
* Returns sf::Vector2i cords taking int board position as input.
*/
sf::Vector2i transPosition(int pos) {
- int x = (int) pos % efc::BOARD_SIZE;
- int y = (int) pos / efc::BOARD_SIZE;
+ int x = (int) pos % DP::BOARD_SIZE;
+ int y = (int) pos / DP::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;
+ int x = (int) pos % DP::TILE_BOARD_SIZE;
+ int y = (int) pos / DP::TILE_BOARD_SIZE;
sf::Vector2i cords(x,y);
return cords;
}
/*!
* Returns int cords taking screen sf::Vector2f position
* as the input.
*/
sf::Vector2i getCords(sf::Vector2f position){
- int x = position.x/efc::TILE_BOARD_SIZE;
- int y = position.y/efc::TILE_BOARD_SIZE;
+ int x = position.x/DP::TILE_BOARD_SIZE;
+ int y = position.y/DP::TILE_BOARD_SIZE;
return sf::Vector2i(x, y);
}
/*!
* Returns screen sf::Vector2f pos taking sf::Vector2i cords
* as the input.
*/
sf::Vector2f getScreenPos(sf::Vector2i cords){
- float x = cords.x * efc::TILE_SIZE;
- float y = cords.y * efc::TILE_SIZE;
+ float x = cords.x * DP::TILE_SIZE;
+ float y = cords.y * DP::TILE_SIZE;
return sf::Vector2f(x, y);
}
/*!
* Returns int board position (1-256, 16x16) taking
* sf::Vector2i cords as the input.
*/
int transCords(sf::Vector2i cords) {
// std::cout << cords.x << " " << cords.y << " " << std::endl;
- int pos = (cords.y * efc::BOARD_SIZE)+cords.x;
+ int pos = (cords.y * DP::BOARD_SIZE)+cords.x;
return pos;
}
sf::IntRect transPosIntoRect(int pos)
{
- sf::Vector2i cords = efc::transTilePosition(pos);
- sf::IntRect posRect((int)cords.x*efc::TILE_SIZE, (int)cords.y*efc::TILE_SIZE, efc::TILE_SIZE, efc::TILE_SIZE);
+ sf::Vector2i cords = DP::transTilePosition(pos);
+ sf::IntRect posRect((int)cords.x*DP::TILE_SIZE, (int)cords.y*DP::TILE_SIZE, DP::TILE_SIZE, DP::TILE_SIZE);
// 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);
+ sf::Vector2i cords = DP::transPosition(pos);
std::vector<int> neighbours;
std::set<int> neighboursSet;
- std::set<int> terrain = efc::getTerrainSet();
+ std::set<int> terrain = DP::getTerrainSet();
int value = -1;
if (cords.x>0)
{
neighbours.push_back(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)
+ if (cords.x<DP::BOARD_SIZE-1)
{
neighbours.push_back(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);
- value = pos-efc::BOARD_SIZE;
+ neighbours.push_back(pos-DP::BOARD_SIZE);
+ // neighboursSet.insert(pos-DP::BOARD_SIZE);
+ value = pos-DP::BOARD_SIZE;
if ((value!=-1) && (terrain.count(value)==0))
neighboursSet.insert(value);
}
- if (cords.y<efc::BOARD_SIZE)
+ if (cords.y<DP::BOARD_SIZE)
{
- neighbours.push_back(pos+efc::BOARD_SIZE);
- // neighboursSet.insert(pos+efc::BOARD_SIZE);
- value = pos+efc::BOARD_SIZE;
+ neighbours.push_back(pos+DP::BOARD_SIZE);
+ // neighboursSet.insert(pos+DP::BOARD_SIZE);
+ value = pos+DP::BOARD_SIZE;
if ((value!=-1) && (terrain.count(value)==0))
neighboursSet.insert(value);
}
return neighboursSet;
}
}
TileMap::TileMap()
{
textures = nullptr;
m_tileset = nullptr;
}
//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;
diff --git a/src/tilemap.h b/src/tilemap.h
index 042d1a2..7dd0610 100644
--- a/src/tilemap.h
+++ b/src/tilemap.h
@@ -1,44 +1,44 @@
#ifndef TILEMAP_H
#define TILEMAP_H
#include <iostream>
#include <set>
#include <SFML/Window.hpp>
#include <SFML/Graphics.hpp>
#include <SFML/System.hpp>
#include "textureholder.h"
-namespace efc {
+namespace DP {
enum {
TILE_SIZE = 40,
BOARD_SIZE = 16,
TILE_BOARD_SIZE = 80
};
sf::Vector2i transPosition(int pos);
int transCords(sf::Vector2i cords);
std::set<int> getNeighbours(int pos);
sf::IntRect transPosIntoRect(int pos);
sf::Vector2i transTilePosition(int pos);
sf::Vector2i getCords(sf::Vector2f position);
sf::Vector2f getScreenPos(sf::Vector2i cords);
}
class TileMap : public sf::Drawable, public sf::Transformable
{
public:
// bool load(TextureHolder *textures, sf::Vector2u tileSize, const int* tiles, unsigned int width, unsigned int height);
TileMap();
private:
virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const;
sf::VertexArray m_vertices;
sf::Texture *m_tileset;
TextureHolder *textures;
};
#endif // TILEMAP_H

File Metadata

Mime Type
text/x-diff
Expires
Tue, Jun 16, 12:19 AM (2 w, 1 d ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
70755
Default Alt Text
(110 KB)

Event Timeline