Page MenuHomePhabricator (Chris)
Files F102483

No OneTemporary
Actions

Size
22 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/character.cpp b/character.cpp
index a1aa401..54b7e16 100644
--- a/character.cpp
+++ b/character.cpp
@@ -1,174 +1,209 @@
#include "character.h"
-
void Character::setDir(int direction)
{
if (direction==efc::DIR_LEFT)
currentAnimation = &walkingAnimationLeft;
}
void Character::setDir()
{
setDir(currentAnimationIndex);
}
void Character::setDirIndex(int direction)
{
currentAnimationIndex = direction;
}
void Character::play()
{
// animatedSprite.play(*currentAnimation);
animatedSprite.play(animations[currentAnimationIndex]);
sf::Vector2f a(getPosition());
sf::Vector2i position(efc::getCords(a));
- std::cout << a.x << " " << a.y << " " << position.x << " " << position.y << "" << efc::transCords(position) << std::endl;
+
+// std::cout << a.x << " " << a.y << " "
+// << position.x << " " << position.y << " pos > "
+// << getBoardPosition() << std::endl;
}
Character::Character(TextureHolder *textures, int playerNumber):
animatedSprite(sf::seconds(0.2), true, false),
nextRedirect(0.f)
{
this->textures = textures;
int offset = playerNumber*16;
walkingAnimationDown.setSpriteSheet(textures->textureCharacters);
walkingAnimationDown.addFrame(sf::IntRect(offset, 0, 16, 24));
walkingAnimationDown.addFrame(sf::IntRect(offset, 23, 16, 24));
walkingAnimationRight.setSpriteSheet(textures->textureCharacters);
walkingAnimationRight.addFrame(sf::IntRect(offset, 48, 16, 24));
walkingAnimationRight.addFrame(sf::IntRect(offset, 72, 16, 24));
walkingAnimationLeft.setSpriteSheet(textures->textureCharacters);
walkingAnimationLeft.addFrame(sf::IntRect(offset, 96, 16, 24));
walkingAnimationLeft.addFrame(sf::IntRect(offset, 120, 16, 24));
walkingAnimationUp.setSpriteSheet(textures->textureCharacters);
walkingAnimationUp.addFrame(sf::IntRect(offset, 144, 16, 24));
walkingAnimationUp.addFrame(sf::IntRect(offset, 168, 16, 24));
currentAnimation = &walkingAnimationRight;
animations[efc::DIR_LEFT] = walkingAnimationLeft;
animations[efc::DIR_RIGHT] = walkingAnimationRight;
animations[efc::DIR_UP] = walkingAnimationUp;
animations[efc::DIR_DOWN] = walkingAnimationDown;
setDirIndex(efc::DIR_LEFT);
setDir();
sf::Vector2f positions[4] = {
sf::Vector2f(0, 0),
sf::Vector2f(20, 40),
sf::Vector2f(20, 240),
sf::Vector2f(40, 240)
};
- setPosition(positions[playerNumber]);
+
+ std::array<int, 4> boardPositions{0,15,255-15,255};
+// std::cout << "define " << playerNumber << std::endl;
+ 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, std::set<int> &busyTiles)
{
sf::Vector2f a(getPosition());
sf::Vector2i position(efc::getCords(a));
int charPos = efc::transCords(position);
// std::cout << a.x << " " << a.y << " " << position.x << " " << position.y << " " << charPos << std::endl;
nextRedirect -= deltaTime.asSeconds();
if (nextRedirect<0)
{
int number = rand() % 2;
if ((currentAnimationIndex==efc::DIR_LEFT) || (currentAnimationIndex==efc::DIR_RIGHT))
{
if (number==0){
setDirIndex(efc::DIR_DOWN);
setDir();
} else if (number==1)
{
setDirIndex(efc::DIR_UP);
setDir();
}
} else if ((currentAnimationIndex==efc::DIR_UP) || (currentAnimationIndex==efc::DIR_DOWN))
{
if (number==0){
setDirIndex(efc::DIR_LEFT);
setDir();
} else if (number==1)
{
setDirIndex(efc::DIR_RIGHT);
setDir();
}
}
nextRedirect = rand() % 4;
}
if (currentAnimationIndex==efc::DIR_UP)
{
if (position.y<2)
{
setDirIndex(efc::DIR_DOWN);
setDir();
}
} else if (currentAnimationIndex==efc::DIR_DOWN)
{
if (position.y>efc::BOARD_SIZE-1)
{
setDirIndex(efc::DIR_UP);
setDir();
}
} else if (currentAnimationIndex==efc::DIR_LEFT)
{
if (position.x<2)
{
setDirIndex(efc::DIR_RIGHT);
setDir();
}
} else if (currentAnimationIndex==efc::DIR_RIGHT)
{
if (position.x>efc::BOARD_SIZE-1)
{
setDirIndex(efc::DIR_LEFT);
setDir();
}
}
animatedSprite.update(deltaTime);
}
sf::FloatRect Character::getLocalBounds() const
{
return sf::FloatRect(0.f, 0.f, 0, 0);
}
sf::FloatRect Character::getGlobalBounds() const
{
return getTransform().transformRect(getLocalBounds());
}
+
+/*!
+ * \brief Character::getBoardPosition
+ * \return
+ */
+int Character::getBoardPosition()
+{
+ sf::Vector2f currentPos(getPosition());
+ sf::Vector2i currentCords(efc::getCords(currentPos));
+ int currentBoardPosition = efc::transCords(currentCords);
+ return currentBoardPosition;
+}
+
+/*!
+ * \brief Character::setBoardPosition
+ * \param boardPosition
+ */
+void Character::setBoardPosition(int boardPosition)
+{
+ sf::Vector2i neededCords(efc::transPosition(boardPosition));
+
+ sf::Vector2f newPos(efc::getScreenPos(neededCords));
+ std::cout << "board pos >> " << boardPosition << " cords >>" << neededCords.x << " " << neededCords.y
+ << "newpos >> " << newPos.x << " " << newPos.y
+ << std::endl;
+ setPosition(newPos.x, newPos.y);
+
+}
+
+
diff --git a/character.h b/character.h
index 46dc270..dd2b64f 100644
--- a/character.h
+++ b/character.h
@@ -1,43 +1,46 @@
#ifndef CHARACTER_H
#define CHARACTER_H
#include <random>
#include <iostream>
#include "data.h"
#include "textureholder.h"
#include "animatedsprite.h"
#include "tilemap.h"
class Character: public sf::Drawable, public sf::Transformable
{
public:
Character(TextureHolder *textures, int playerNumber);
TextureHolder *textures;
Animation walkingAnimationDown;
Animation walkingAnimationUp;
Animation walkingAnimationLeft;
Animation walkingAnimationRight;
Animation animations[4];
Animation* currentAnimation;
int currentAnimationIndex;
AnimatedSprite animatedSprite;
sf::FloatRect getLocalBounds() const;
sf::FloatRect getGlobalBounds() const;
void setDirUp();
void setDirDown();
void setDirLeft();
void setDirRight();
virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const;
void update(sf::Time deltaTime, std::set<int>& busyTiles);
void play();
void setDir();
void setDir(int direction);
void setDirIndex(int direction);
float nextRedirect;
+
+ void setBoardPosition(int boardPosition);
+ int getBoardPosition();
int tile_pos;
};
#endif // CHARACTER_H
diff --git a/playerhud.cpp b/playerhud.cpp
index 42c847b..7c46b33 100644
--- a/playerhud.cpp
+++ b/playerhud.cpp
@@ -1,306 +1,306 @@
#include "playerhud.h"
#include "textureholder.h"
#include "boardelem.h"
bool PlayerHud::addElem(int pos, int type) {
int price = textures->tilesDescription[type][0];
if (price<=cash)
{
efc::BoardElem startElem(textures, pos,type);
startElem.setColor(efc::playersColors[this->pos]);
elems.items.push_back(startElem);
elems.items_map.insert({pos, startElem});
cash -= price;
updateTxt();
characters.push_back(Character (this->textures, this->pos));
return true;
}
return false;
}
std::set<int> PlayerHud::getTerrainSet(){
std::set<int> terrain;
for (int i: efc::terrainArray)
{
// std::cout << i << std::endl;
terrain.insert(i);
}
return terrain;
}
std::set<int> PlayerHud::getBusy(){
std::set<int> busyTiles;
for (std::pair<int, efc::BoardElem> i: elems.items_map)
{
busyTiles.insert(i.first);
}
return busyTiles;
}
std::set<int> PlayerHud::getNeighbours(){
std::set<int> neighbours;
for (std::pair<int, efc::BoardElem> i: elems.items_map)
{
std::set<int> terrain = getTerrainSet();
std::set<int> neighboursVector(efc::getNeighbours(i.second.pos));
for (int j: neighboursVector)
{
if ((elems.items_map.count(j) == 0) && (terrain.count(j)==0))
{
// std::cout << j << " " << terrain.count(j) << std::endl;
neighbours.insert(j);
}
}
}
// // Fill in s1 and s2 with values
// std::set<int> result;
// std::set_difference(neighbours.begin(), neighbours.end(), terrain.begin(), terrain.end(),
// std::inserter(result, result.end()));
// for (int i: result)
// {
// std::cout << i << std::endl;
// }
return neighbours;
}
void PlayerHud::updateTxt(){
txtCash.setString( "Cash: " + std::to_string(cash));
txtFood.setString( "Food: " + std::to_string(food));
txtEnergy.setString("Enrg: " + std::to_string(energy));
txtFaith.setString( "Gods: " + std::to_string(faith));
}
void PlayerHud::updatePlayer(){
for (const efc::BoardElem &i: elems.items)
{
int cashUpd = textures->tilesDescription[i.type][1];
int foodUpd = textures->tilesDescription[i.type][3];
int enrgUpd = textures->tilesDescription[i.type][5];
int faithUpd = textures->tilesDescription[i.type][7];
cash += cashUpd;
energy += enrgUpd;
food += foodUpd;
faith += faithUpd;
updateTxt();
}
}
PlayerHud::PlayerHud()
{
}
void PlayerHud::setActive(bool newState){
active = newState;
elems.active = newState;
}
PlayerHud::PlayerHud(TextureHolder *textures, int faceNumber, sf::Font *gameFont, int faceSize, int pos)
{
static int startPlayers[4] = {0,15,240,255};
active = false;
this->textures = textures;
Character character(this->textures, pos);
characters.push_back(Character (this->textures, pos));
efc::BoardElem startElem(textures, startPlayers[pos],444);
startElem.setColor(efc::playersColors[pos]);
elems.items.push_back(startElem);
elems.items_map.insert({startPlayers[pos], startElem});
this->faceSize = faceSize;
spriteFace.setTexture(textures->textureFaces);
this->pos = pos;
symbol.setTexture(this->textures->textureSymbols);
sf::IntRect symbolsRect[4] = {sf::IntRect(0,0,255,255), sf::IntRect(256,0,512,255), sf::IntRect(0,255, 255, 512), sf::IntRect(255,255,512, 512)};
symbol.setTextureRect(symbolsRect[pos]);
symbol.setScale(sf::Vector2f(0.2f, 0.20f));
symbol.setColor(sf::Color(25, 25, 25, 105));
symbol.setPosition(60, (pos*100)+40);
food = 0;
cash = 20;
energy = 0;
faith = 0;
int x = faceNumber % 10;
int y = (int) faceNumber /10;
txtCash.setFont(*gameFont);
txtFood.setFont(*gameFont);
txtEnergy.setFont(*gameFont);
txtFaith.setFont(*gameFont);
txtNextRound.setFont(*gameFont);
txtNextRound.setString("End Turn");
// txtNextRound.setScale(sf::Vector2f(0.25f, 1.f));
txtNextRound.setCharacterSize(12);
txtNextRound.setPosition(40,(pos*100)+10);
txtCash.setPosition(1,(pos*100)+40);
// txtCash.setString("Cash: " + std::to_string(cash));
txtCash.setCharacterSize(10);
// txtCash.setScale(sf::Vector2f(0.25f, 1.f));
txtFood.setPosition(1,(pos*100)+55);
// txtFood.setString("Food: " + std::to_string(food));
txtFood.setCharacterSize(10);
// txtFood.setScale(sf::Vector2f(0.25f, 1.f));
txtEnergy.setPosition(1,(pos*100)+70);
// txtEnergy.setString("Enrg: " + std::to_string(energy));
txtEnergy.setCharacterSize(10);
// txtEnergy.setScale(sf::Vector2f(0.25f, 1.f));
txtFaith.setPosition(1,(pos*100)+85);
// txtEnergy.setString("Enrg: " + std::to_string(energy));
txtFaith.setCharacterSize(10);
// txtFaith.setScale(sf::Vector2f(0.25f, 1.f));
updateTxt();
spriteFace.setTextureRect(sf::IntRect(x*faceSize, y*faceSize, faceSize, faceSize));
// spriteFace.setScale(sf::Vector2f(0.25f, 1.f));
spriteFace.setPosition(0,pos*100);
rectangle.setSize(sf::Vector2f((this->faceSize)*7, this->faceSize));
rectangle2.setSize(sf::Vector2f((this->faceSize)*7, (this->faceSize*2)+3));
if (pos==0)
{
rectangle.setFillColor(sf::Color(50, 50, 200,68));
rectangle2.setFillColor(sf::Color(100, 100, 150,38));
rectangle.setOutlineColor(sf::Color(0,0,128,68));
}
else if (pos==1)
{
rectangle.setFillColor(sf::Color(50, 150, 50,68));
rectangle2.setFillColor(sf::Color(100, 150,100,38));
rectangle.setOutlineColor(sf::Color(0,128,0,68));
}
else if (pos==2)
{
rectangle.setFillColor(sf::Color(150, 50, 50,68));
rectangle2.setFillColor(sf::Color(150, 100,100,38));
rectangle.setOutlineColor(sf::Color(128,0,0,68));
}
else if (pos==3)
{
rectangle.setFillColor(sf::Color(150, 150, 150,68));
rectangle2.setFillColor(sf::Color(200, 200,200,38));
rectangle.setOutlineColor(sf::Color(128,128,128,68));
}
rectangle.setOutlineThickness(1);
rectangle.setPosition(0, pos*100);
rectangle2.setPosition(0, (pos*100)+faceSize+1);
buttons.insert({"end_turn",rectangle});
}
std::string PlayerHud::getElem(sf::Vector2f mousePosition) {
std::string result = "";
sf::Vector2f hoverPos = getPosition();
for (std::pair<std::string, sf::RectangleShape> i: buttons)
{
sf::FloatRect spriteBounds = i.second.getLocalBounds();
sf::FloatRect closeRect;
closeRect.left = i.second.getPosition().x;
closeRect.top = i.second.getPosition().y;
closeRect.width = spriteBounds.width;
closeRect.height = spriteBounds.height;
// std::cout << closeRect.left << " " << closeRect.top << " " << closeRect.width << " " << closeRect.height
// << hoverPos.x << " " << hoverPos.y << " OK"
// << std::endl;
if (closeRect.contains(mousePosition.x - hoverPos.x,mousePosition.y - hoverPos.y))
{
return i.first;
}
}
return result;
}
void PlayerHud::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
// // apply the transform
states.transform *= getTransform();
// Color rectangles making the gui on the right side
// sf::RectangleShape rectangle(sf::Vector2f(faceSize, faceSize));
// sf::RectangleShape rectangle2(sf::Vector2f(faceSize, (faceSize*2)+3));
target.draw(rectangle, states);
target.draw(rectangle2, states);
target.draw(txtCash, states);
target.draw(txtFood, states);
target.draw(txtEnergy, states);
target.draw(txtFaith, states);
if (active)
target.draw(txtNextRound, states);
target.draw(symbol, states);
target.draw(spriteFace, states);
}
void PlayerHud::play()
{
for (auto&& i: characters)
{
i.play();
}
}
void PlayerHud::update(sf::Time deltaTime, std::set<int>& busyTiles)
{
for (auto&& i: characters)
{
sf::Vector2f movement(0.f, 0.f);
if (i.currentAnimationIndex==efc::DIR_LEFT)
movement = sf::Vector2f (-10.f, 0.f);
else if (i.currentAnimationIndex==efc::DIR_RIGHT)
movement = sf::Vector2f (10.f, 0.f);
else if (i.currentAnimationIndex==efc::DIR_UP)
movement = sf::Vector2f (0.f, -10.f);
else if (i.currentAnimationIndex==efc::DIR_DOWN)
movement = sf::Vector2f (0.f, 10.f);
- i.move(movement * deltaTime.asSeconds());
+// i.move(movement * deltaTime.asSeconds());
i.update(deltaTime, busyTiles);
}
}
diff --git a/tilemap.cpp b/tilemap.cpp
index f91595d..2e5c51c 100644
--- a/tilemap.cpp
+++ b/tilemap.cpp
@@ -1,150 +1,170 @@
#include "tilemap.h"
namespace efc {
+/*!
+ * 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;
sf::Vector2i cords(x,y);
return cords;
}
sf::Vector2i transTilePosition(int pos) {
int x = (int) pos % efc::TILE_BOARD_SIZE;
int y = (int) pos / efc::TILE_BOARD_SIZE;
sf::Vector2i cords(x,y);
return cords;
}
+/*!
+ * 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;
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;
+ 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;
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);
// std::cout << "debug transPosIntoRect " << pos << " "<< cords.x << " " << cords.y << " " << posRect.left << " " << posRect.top << std::endl;
return posRect;
}
std::set<int> getNeighbours(int pos) {
sf::Vector2i cords = efc::transPosition(pos);
std::vector<int> neighbours;
std::set<int> neighboursSet;
std::set<int> terrain = efc::getTerrainSet();
int value = -1;
if (cords.x>0)
{
neighbours.push_back(pos-1);
// neighboursSet.insert(pos-1);
value = pos-1;
if ((value!=-1) && (terrain.count(value)==0))
neighboursSet.insert(value);
}
if (cords.x<efc::BOARD_SIZE-1)
{
neighbours.push_back(pos+1);
// neighboursSet.insert(pos+1);
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;
if ((value!=-1) && (terrain.count(value)==0))
neighboursSet.insert(value);
}
if (cords.y<efc::BOARD_SIZE)
{
neighbours.push_back(pos+efc::BOARD_SIZE);
// neighboursSet.insert(pos+efc::BOARD_SIZE);
value = pos+efc::BOARD_SIZE;
if ((value!=-1) && (terrain.count(value)==0))
neighboursSet.insert(value);
}
return neighboursSet;
}
}
TileMap::TileMap()
{
}
bool TileMap::load(TextureHolder *textures, sf::Vector2u tileSize, const int* tiles, unsigned int width, unsigned int height)
{
this->m_tileset = &textures->textureTiles;
// resize the vertex array to fit the level size
m_vertices.setPrimitiveType(sf::Quads);
m_vertices.resize(width * height * 4);
// populate the vertex array, with one quad per tile
for (unsigned int i = 0; i < width; ++i)
for (unsigned int j = 0; j < height; ++j)
{
// get the current tile number
int tileNumber = tiles[i + j * width];
// find its position in the tileset texture
int tu = tileNumber % (m_tileset->getSize().x / tileSize.x);
int tv = tileNumber / (m_tileset->getSize().x / tileSize.x);
// get a pointer to the current tile's quad
sf::Vertex* quad = &m_vertices[(i + j * width) * 4];
// define its 4 corners
quad[0].position = sf::Vector2f(i * tileSize.x, j * tileSize.y);
quad[1].position = sf::Vector2f((i + 1) * tileSize.x, j * tileSize.y);
quad[2].position = sf::Vector2f((i + 1) * tileSize.x, (j + 1) * tileSize.y);
quad[3].position = sf::Vector2f(i * tileSize.x, (j + 1) * tileSize.y);
// define its 4 texture coordinates
quad[0].texCoords = sf::Vector2f(tu * tileSize.x, tv * tileSize.y);
quad[1].texCoords = sf::Vector2f((tu + 1) * tileSize.x, tv * tileSize.y);
quad[2].texCoords = sf::Vector2f((tu + 1) * tileSize.x, (tv + 1) * tileSize.y);
quad[3].texCoords = sf::Vector2f(tu * tileSize.x, (tv + 1) * tileSize.y);
}
return true;
}
void TileMap::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
// apply the transform
states.transform *= getTransform();
// apply the tileset texture
states.texture = m_tileset;
// draw the vertex array
target.draw(m_vertices, states);
}
sf::VertexArray m_vertices;
sf::Texture m_tileset;
diff --git a/tilemap.h b/tilemap.h
index 0af8c99..2b987ee 100644
--- a/tilemap.h
+++ b/tilemap.h
@@ -1,42 +1,42 @@
#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 {
enum {
TILE_SIZE = 25,
BOARD_SIZE = 16,
TILE_BOARD_SIZE = 40
};
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
Mon, Feb 2, 9:01 PM (2 d, 18 m ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
55557
Default Alt Text
(22 KB)

Event Timeline