Main Class
#include "Game.h"
int main(){
Game snakeGame;
snakeGame.Run();
return 0;
}
Game Class
#include "Game.h"
Game::Game()
{
//ctor
}
Game::~Game()
{
//dtor
}
void Game::getDefualtValues(){
}
void Game::Run(){
srand(time(NULL));
//Set output to console
std::cout << "Starting" << std::endl;
sf::Clock clock;
m_snakes.push_back(Snake("Player1"));
//m_snakes.push_back(Snake("Player2"));
Collectable m_collect[5];
Planets m_planets;
//Main loop that continues till we call close()
while(m_window.isOpen()){
while(isAlive){
if(sf::Event::Closed){
m_window.close();
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Escape)){
m_window.close();
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::P)){
for(Snake& s : m_snakes){
s.popBack(1);
}
}
if(sf::Keyboard::isKeyPressed(sf::Keyboard::R)){
//m_window.restart();
}
//Check to see how many collectables there already are
int activeCollect = 0;
for(int i = 0; i<5; i++){
if(m_collect[i].getIsVisable() == true){
activeCollect++;
}
}
//Respawns the collectables
if(activeCollect < 5 && (rand()%100 + 1) == 5){
for(int i = 0; i<5; i++){
if(m_collect[i].getIsVisable() == false){
bool accepted = false;
do{
m_collect[i].respawn();
for(int j = 0; i<5; i++){
if(i != j){
if((m_collect[j].getSize()+m_collect[i].getSize())>sqrt(pow((m_collect[j].getPosition().x-m_collect[i].getPosition().x),2)+pow((m_collect[j].getPosition().y-m_collect[i].getPosition().y),2))){
m_collect[i].respawn();
}else{
accepted = true;
}
}
}
}while(!accepted);
break;
}
}
}
//Check the collison of the collectable and the snake
for(Snake& s : m_snakes){
for(int i = 0; i<5; i++){
if((s.getSize()+m_collect[i].getSize())>sqrt(pow((s.getPosition().x-m_collect[i].getPosition().x),2)+pow((s.getPosition().y-m_collect[i].getPosition().y),2))){
m_collect[i].setIsVisable(false);
s.addGrowAmount(1);
std::cout<<"Grow"<<std::endl;
break;
}
}
float resultantSize = s.getSize()+m_planets.getSize("sun");
float xResultant = sqrt(pow((s.getPosition().x-m_planets.GetPosition("sunX")),2));
float yResultant = sqrt(pow((s.getPosition().y-m_planets.GetPosition("sunY")),2));
if(resultantSize > xResultant + yResultant){
std::cout<<"Dead"<<std::endl;
//isAlive = false;
}
}
//move all the snakes
for (Snake& s : m_snakes){
s.Movement();
}
//We must clear the window at the end of each loop
m_window.clear();
//Render the snakes
for (Snake& s : m_snakes){
s.Render(m_window);
}
//Render the collecables
for (Collectable& c : m_collect){
c.Render(m_window);
}
//Render Planets
m_planets.Render(m_window);
//Get the window to display content
m_window.display();
//Delay
while(clock.getElapsedTime().asMilliseconds()<16.67);
clock.restart();
}
}
std::cout << "Finished" << std::endl;
}
Game Header
#ifndef GAME_H
#define GAME_H
#include <iostream>
#include <vector>
#include <cstdlib>
#include <SFML/Graphics.hpp>
#include "Snake.h"
#include "Collectable.h"
#include "Planets.h"
class Game
{
public:
Game();
~Game();
void Run();
void getDefualtValues();
protected:
private:
int m_screenWidth{1280};
int m_screenHeight{720};
std::vector<Snake> m_snakes;
bool isAlive = true;
// Initialise Window and title text
sf::RenderWindow m_window{sf::VideoMode(m_screenWidth, m_screenHeight), "C++ Snake ICA : T7048271"};
};
#endif // GAME_H
Snake Class
#include "Snake.h"
Snake::Snake(std::string name) : m_name(name)
{
//ctor
//Set the shapes fill colour attribute to green
m_snakeHead.setFillColor(sf::Color::Magenta);
m_segmentList.push_front(m_snakePosition);
}
Snake::~Snake()
{
//dtor
}
void Snake::Movement(){
m_horDirection = sf::Keyboard::isKeyPressed(sf::Keyboard::Right) - sf::Keyboard::isKeyPressed(sf::Keyboard::Left);
m_angle += m_horDirection*m_angleDis;
m_snakePosition.x += m_mag*cos(m_angle);
m_snakePosition.y += m_mag*sin(m_angle);
m_segmentList.push_front(m_snakePosition);
if(m_growAmount>0){
m_growAmount = 0;
}else{
m_segmentList.pop_back();
}
}
void Snake::Render(sf::RenderWindow& m_window){
//draw our circle shape to the window
//m_window.draw(m_snakeHead);
for (auto& s: m_segmentList)
{
m_snakeHead.setPosition(s);
m_window.draw(m_snakeHead);
}
}
int Snake::getSize(){
return m_snakeSize;
}
sf::Vector2f Snake::getPosition(){
return m_snakePosition;
}
std::list<sf::Vector2f> Snake::getSegmentList(){
return m_segmentList;
}
void Snake::addGrowAmount(int amount){
m_growAmount += amount;
}
void Snake::popBack(int amount){
for(int i = 0; i < amount; i++){
m_segmentList.pop_back();
}
}
Snake Header
#ifndef SNAKE_H
#define SNAKE_H
#include <SFML/Graphics.hpp>
#include <string>
#include <list>
class Snake
{
public:
Snake(std::string name);
virtual ~Snake();
void Movement();
void Render(sf::RenderWindow& m_window);
int getSize();
sf::Vector2f getPosition();
std::list<sf::Vector2f> getSegmentList();
void addGrowAmount(int amount);
void popBack(int amount);
private:
std::string m_name;
sf::Vector2f m_snakePosition{300,200};
std::list<sf::Vector2f> m_segmentList;
const int m_snakeSize{12};
//Create an instance of the SFMl Circle shape and initialise it
sf::CircleShape m_snakeHead{m_snakeSize};
int m_horDirection{0};
int m_growAmount{0};
float m_angle{0};
float m_mag{3};
float m_angleDis{0.1};
};
#endif // SNAKE_H
Collectable Class
#include "Collectable.h"
Collectable::Collectable()
{
//ctor
m_collectPosition.x = rand()%(800-10)+10;
m_collectPosition.y = rand()%(600-10)+10;
m_collect.setPosition(m_collectPosition);
m_collect.setFillColor(sf::Color::Red);
}
Collectable::~Collectable()
{
//dtor
}
void Collectable::Render(sf::RenderWindow& m_window){
//draw our circle shape to the window
if(isVisable == true){
m_window.draw(m_collect);
}
}
bool Collectable::getIsVisable(){
return isVisable;
}
void Collectable::setIsVisable(bool visability){
isVisable = visability;
}
int Collectable::getSize(){
return m_collectSize;
}
sf::Vector2f Collectable::getPosition(){
return m_collectPosition;
}
void Collectable::respawn(){
m_collectPosition.x = rand()%(800-20)+10;
m_collectPosition.y = rand()%(600-20)+10;
m_collect.setPosition(m_collectPosition);
isVisable = true;
}
Collectable Header
#ifndef COLLECTABLE_H
#define COLLECTABLE_H
#include <SFML/Graphics.hpp>
#include <string>
class Collectable
{
public:
Collectable();
virtual ~Collectable();
void Render(sf::RenderWindow& m_window);
bool getIsVisable();
void setIsVisable(bool visability);
int getSize();
sf::Vector2f getPosition();
void respawn();
protected:
private:
sf::Vector2f m_collectPosition{400,300};
const int m_collectSize{9};
//Create an instance of the SFMl Circle shape and initialise it
sf::CircleShape m_collect{m_collectSize};
bool isVisable{false};
};
#endif // COLLECTABLE_H
Planets Class
#include "Planets.h"
Planets::Planets()
{
m_sun.setPosition(m_sunPosition);
m_sun.setFillColor(sf::Color::Yellow);
m_ast.setFillColor(sf::Color::Blue);
m_ast.setPosition(m_astPosition);
m_ast2.setFillColor(sf::Color::Green);
m_ast2.setPosition(m_ast2Position);
}
Planets::~Planets()
{
//dtor
}
void Planets::Render(sf::RenderWindow& m_window){
//draw our circle shape to the window
m_window.draw(m_sun);
m_window.draw(m_ast);
m_window.draw(m_ast2);
m_astPosition.x = (cos(m_astRotationAngle) * m_astRadius) + (640-m_astSize);
m_astPosition.y = (sin(m_astRotationAngle) * -m_astRadius) + (360-m_astSize);
m_ast.setPosition(m_astPosition);
m_astRotationAngle+= 0.01;
m_ast2Position.x = (cos(m_ast2RotationAngle) * m_ast2Radius) + (640-m_ast2Size);
m_ast2Position.y = (sin(m_ast2RotationAngle) * m_ast2Radius) + (360-m_ast2Size);
m_ast2.setPosition(m_ast2Position);
m_ast2RotationAngle+= 0.05;
}
int Planets::getSize(std::string planet){
if(planet == "sun"){
int size = m_sunSize;
return size;
}else if(planet == "ast"){
int size = m_sunSize;
return size;
}else if(planet == "ast2"){
int size = m_sunSize;
return size;
}
}
int Planets::GetPosition(std::string planet){
if(planet == "sunX"){
int posX = m_sunPosition.x;
return posX;
} else if(planet == "sunY"){
int posY = m_sunPosition.y;
return posY;
}
}
Planets Header
#ifndef PLANETS_H
#define PLANETS_H
#include <SFML/Graphics.hpp>
#include <string>
#include <iostream>
class Planets
{
public:
Planets();
~Planets();
void Render(sf::RenderWindow& m_window);
int getSize(std::string planet);
int GetPosition(std::string planet);
private:
const int m_sunSize = 50;
sf::Vector2f m_sunPosition{(640-m_sunSize),(360-m_sunSize)};
sf::CircleShape m_sun{m_sunSize};
float m_astRotationAngle = 0;
float m_astRadius = 200;
const int m_astSize = 15;
sf::Vector2f m_astPosition{0,0};
sf::CircleShape m_ast{m_astSize};
float m_ast2RotationAngle = 0;
float m_ast2Radius = 100;
const int m_ast2Size = 10;
sf::Vector2f m_ast2Position{0,0};
sf::CircleShape m_ast2{m_ast2Size};
};
#endif // PLANETS_H
