Breaking things out into different filesrefactor

1 files changed, 9 insertions, 416 deletions

diff --git a/fungi.cpp b/fungi.cpp
index b361602..fc22bd1 100644
--- a/fungi.cpp
+++ b/fungi.cpp
@@ -7,16 +7,17 @@
  * GPL v3
  */
 
-#include <vector>
 #include <iostream>
 #include <stdlib.h>
 #include <stdint.h>
-#include <SDL2/SDL.h>
+#include "petri.h"
+#include "window.h"
 
+#include "sdlwindow.h"
 
 /** Important Constants **/
 
-const uint8_t GROWTH_RATE = 4; /* A percent out of 100 */
+uint8_t GROWTH_RATE = 4; /* A percent out of 100 */
 const uint8_t TICKS = 10; /*Time to wait between growths */
 
 const int SCREEN_WIDTH  = 640;
@@ -24,417 +25,6 @@ const int SCREEN_HEIGHT = 480;
 
 /** Important Objects **/
 
-/*
- * Window Position
- * Keeps track of window position
- */
-struct Window_Pos {
-	uint16_t posx;
-	uint16_t posy;
-};
-
-/*
- * Window Size
- * Keeps track of window size
- */
-struct Window_Size {
-	uint16_t width;
-	uint16_t height;
-};
-
-/*
- * Location
- * Keeps track of where we are
- */
-struct Location {
-	uint16_t posx;
-	uint16_t posy;
-};
-
-/*
- * Color
- * Keeps track of the appearance of the fungus
- */
-struct Color {
-	uint8_t red;
-	uint8_t green;
-	uint8_t blue;
-	uint8_t alpha;
-};
-
-/*
- * Fungus
- * More or less just a pixel
- */
-class Fungus {
-private:
-	struct Location local;
-	struct Color color;
-	uint8_t growthPoints;
-	uint8_t hp;
-
-public:
-	/**
-	 * Creates a useless Fungus
-	 */
-	Fungus() {
-		hp = 0;
-		growthPoints = 0;
-	}
-
-	/**
-	 * Creates a Fungus
-	 * @param l The location the fungus should live in
-	 * @param c The color the fungus should be
-	 */
-	Fungus(const Location& l, const Color& c) {
-		local.posx = l.posx;
-		local.posy = l.posy;
-		color.red = c.red;
-		color.green = c.green;
-		color.blue = c.blue;
-		color.alpha = c.alpha;
-		hp = 10;
-		growthPoints = 0;
-	}
-
-	~Fungus() {}
-
-	/**
-	 * Get the location of the fungus
-	 * @return The location of the fungus
-	 */
-	Location getLocation() const { return local; }
-
-	/**
-	 * Get the color of the fungus
-	 * @return The color of the fungus
-	 */
-	Color getColor() const { return color; }
-
-	/**
-	 * Adds growth to the fungus
-	 * @param val Amount to grow the fungus
-	 */
-	void addGrowth(uint8_t val) { growthPoints += val; }
-   
-	/**
-	 * Gets the current growth of the fungus
-	 * @return Current growth points of fungus
-	 */
-	uint8_t getGrowthPoints() const { return growthPoints; }
-
-	/**
-	 * Gets the current health of the fungus
-	 * @return Current health points of the fungus
-	 */
-	uint8_t getHP() const { return hp; }
-};
-
-/*
- * Petri
- * Where the fungus live, grow, and die
- */
-class Petri {
-private:
-	uint32_t maxSize;
-	std::vector<Fungus*> population; // Holds only the living fungus
-	std::vector< std::vector<Fungus*> > dish; // Keeps track of each position
-											  // a fungus may live
-
-	/**
-	 * Grows a fungus
-	 * @param f The fungus to grow
-	 * @return Either a new fungus or nullptr if no children spawn
-	 */
-	Fungus* growFungus(Fungus& f) {
-		uint8_t val = random();
-		while(val > 100) {
-			val = random();
-		}
-		if(val < GROWTH_RATE) {
-			f.addGrowth(1);
-		}
-		Fungus* child = nullptr;
-		if(f.getGrowthPoints() >= 10) {
-			f.addGrowth(255 - f.getGrowthPoints());
-			Location home = f.getLocation();
-			home.posx += 1;
-			home.posy += 1;
-			child = new Fungus(home, f.getColor());
-		}
-		return child;
-	}
-
-public:
-	/**
-	 * Creates a useless Petri dish
-	 */
-	Petri() {
-		maxSize = 0;
-		//population = nullptr;
-		//dish = nullptr;
-	}
-
-	/**
-	 * Creates a Petri dish for the fungus to live in
-	 * @param maxSize Maximum number of fungi that we will have
-	 * @param ws The size of the window the petri dish should fill 
-	 */
-	Petri(uint32_t maxSize, const Window_Size& ws) {
-		this->maxSize = maxSize;
-		population.reserve(maxSize);
-		for(int i = 0; i < maxSize; i++) {
-			population.push_back(nullptr);
-		}
-		dish.reserve(ws.width);
-		std::vector<Fungus*> temp(ws.height);
-		for(int i = 0; i < ws.height; i++) {
-			temp.push_back(nullptr);
-		}
-		for(int i = 0; i < ws.width; i++) {
-			dish.push_back(temp);
-		}
-	
-	}
-
-	/**
-	 * Copy construction
-	 * Doesn't work right apparently
-	 */
-    /*
-    Petri(const Petri& p) {
-	dish.reserve(p.getSize());
-	for(int i = 0; i < p.getSize(); i++) {
-	    dish.push_back(nullptr);
-	}
-	for(int i = 0; i < dish.size(); i++) {
-	    Fungus* temp = p.getFungus(i);
-	    if(temp != nullptr) {
-		addFungus(new Fungus(temp->getLocation(), temp->getColor()));
-	    }
-	}
-    }
-    */
-
-	/**
-	 * Destroyer of dishes
-	 */
-	~Petri() {
-		for(int i = 0; i < population.size(); i++) {
-			if(population[i] != nullptr) {
-				Fungus* temp = population[i];
-				population[i] = nullptr;
-				delete temp;
-			}
-		}
-	}
-
-	/**
-	 * Gets a Fungus from the dish
-	 * @param i The position of the fungus from the dish we want
-	 */
-	Fungus* operator[](const uint32_t& i) { return getFungus(i); }
-    
-	/**
-	 * Gets a Fungus from the dish
-	 * @param i The position of the fungus from the dish we want
-	 */
-	Fungus* getFungus(const uint32_t& i) const {
-		if(i >= population.size()) {
-			return nullptr;
-		} else {
-			return population[i];
-		}
-	}
-
-	/**
-	 * Adds a fungus to the dish, unless that spot is full, then the fungus is
-	 * deleted from existence.
-	 * @param f The fungus to add
-	 */
-	void addFungus(Fungus* f) {
-		if(dish[f->getLocation().posy][f->getLocation().posx] == nullptr) {
-			dish[f->getLocation().posy][f->getLocation().posx] = f;
-			for(int i = 0; i < population.size(); i++) {
-				if(population[i] == nullptr) {
-					population[i] = f;
-					break;
-				}
-			}
-		} else {
-			delete f;
-		}
-	}
-
-	/**
-	 * Simulates one round of fungus life
-	 *
-	 */
-	void grow() {
-		for(int i = 0; i < dish.size(); i++) {
-			for(int j = 0; j < dish[i].size(); j++) {
-				if(dish[i][j] != nullptr) {
-					Fungus* newFungus = growFungus(*dish[i][j]);
-						if(newFungus != nullptr) {
-							addFungus(newFungus);
-						}
-				}
-			}
-		}
-    
-	}
-
-	/**
-	 * Get size of dish
-	 * @return Max number of fungus we can hold in dish
-	 */
-	uint32_t getSize() const { return maxSize; }
-    
-	/**
-	 * Gives the fungus
-	 * @return The 2D vector of fungus
-	 */
-	std::vector<std::vector<Fungus*> > & getDish() { return dish; }
-
-	/**
-	 * Get list of living fungus
-	 * @return Vector of fungus in the dish
-	 */
-	std::vector<Fungus*> & getPopulation() { return population; }
-};
-
-/*
- * SDLWindow
- * The display into our fungus world
- */
-class SDLWindow {
-private:
-	SDL_Window* sdlWindow;
-	SDL_Renderer* sdlRenderer;
-	Petri petri;
-	bool bad;
-
-	/**
-	 * Log an SDL error with some error message to the output stream of our choice
-	 * @param os The output stream to write the message to
-	 * @param msg The error message to write, format will be msg error: SDL_GetError()
-	 */
-	void logSDLError(std::ostream &os, const std::string &msg) {
-		os << msg << " error: " << SDL_GetError() << std::endl;
-	}
-
-	/**
-	 * Brings up all the SDL objects we will need to draw our window
-	 * @param winpos The position we want for the window
-	 * @param winsize The size we want for the window
-	 */
-	void init(const Window_Pos& winpos, const Window_Size& winsize) {
-		if (SDL_Init(SDL_INIT_EVERYTHING) != 0){
-			logSDLError(std::cout, "SDL_Init");
-			bad = true;
-		}
-		sdlWindow = SDL_CreateWindow("Fungi", winpos.posx, winpos.posy,
-										winsize.width, winsize.height,
-										SDL_WINDOW_OPENGL);
-		if (sdlWindow == nullptr){
-			logSDLError(std::cout, "CreateWindow");
-			SDL_Quit();
-			bad = true;
-		}
-		sdlRenderer = SDL_CreateRenderer(sdlWindow, -1,
-											SDL_RENDERER_SOFTWARE);
-		if (sdlRenderer == nullptr){
-			logSDLError(std::cout, "CreateRenderer");
-			SDL_DestroyWindow(sdlWindow);
-			sdlWindow = nullptr;
-			SDL_Quit();
-			bad = true;
-		}
-		SDL_SetRenderDrawColor(sdlRenderer, 0, 0, 0, 255);
-		SDL_RenderClear(sdlRenderer);
-		SDL_RenderPresent(sdlRenderer);
-	}
-
-	/**
-	 * Draws a fungus on the screen
-	 * @param f The fungus we want to draw
-	 */
-	void drawFungus(const Fungus& f) {
-		Color color = f.getColor();
-		Location loc = f.getLocation();
-		SDL_SetRenderDrawColor(sdlRenderer, color.red, color.green, color.blue,
-								color.alpha);
-		SDL_RenderDrawPoint(sdlRenderer, loc.posx, loc.posy);
-	}
-
-public:
-	/**
-	 * Creates a SDLWindow without anything to show
-	 */
-	SDLWindow() {
-		bad = false;
-		init({100, 100}, {SCREEN_WIDTH, SCREEN_HEIGHT});
-	}
-
-	/**
-	 * Creates a SDLWindow with an attached Petri dish
-	 * @param p A petri dish
-	 */
-	SDLWindow(const Petri& p) {
-		petri = p;
-		bad = false;
-		init({100, 100}, {SCREEN_WIDTH, SCREEN_HEIGHT});
-	}
-
-	/**
-	 * Destroyer of the window
-	 */
-	~SDLWindow() {
-		if(sdlWindow != nullptr) {
-			SDL_DestroyWindow(sdlWindow);
-		}
-		if(sdlRenderer != nullptr) {
-			SDL_DestroyRenderer(sdlRenderer);
-		}
-		SDL_Quit();
-	}
-
-	/**
-	 * Runs the growth of the fungus till the end of time
-	 */
-	void doFungus() {
-
-		SDL_Event event;
-		bool end = false;
-		while(!end) {
-			while(SDL_PollEvent(&event)) {
-				if(event.type == SDL_QUIT) {
-					end = true;
-				}
-			}
-
-			for(int i = 0; i < petri.getSize(); i++) {
-				if(petri[i] != nullptr) {
-					drawFungus(*petri[i]);
-				}
-			}
-
-			SDL_RenderPresent(sdlRenderer);
-
-			petri.grow();
-	    
-			SDL_Delay(TICKS);
-		}
-    
-	}
-
-	/**
-	 * Tells if the windows is bad, aka an SDL error
-	 * @return True if window is bad, False if not
-	 */
-	bool isBad() const { return bad; }
-};
 
 /** Important Functions **/
 
@@ -443,8 +33,11 @@ int main(int argv, char* argc[]) {
     
 	srandom(11);
 
+	Window_Pos wp = {100, 100};
 	Window_Size ws = {SCREEN_WIDTH, SCREEN_HEIGHT};
-	Petri* p = new Petri(SCREEN_HEIGHT * SCREEN_WIDTH, ws);
+	Dish_Size ds = {SCREEN_WIDTH, SCREEN_HEIGHT};
+	uint32_t max = SCREEN_WIDTH * SCREEN_HEIGHT;
+	Petri* p = new Petri(max, ds, GROWTH_RATE);
 
 	p->addFungus(new Fungus({0, 0}, {255, 0, 0, 0}));
 	p->addFungus(new Fungus({0, 1}, {0, 255, 0, 0}));
@@ -458,7 +51,7 @@ int main(int argv, char* argc[]) {
     }
     */
     
-	SDLWindow win(*p);
+	SDLWindow win(wp ,ws, *p);
 	if(!win.isBad()) {
 		win.doFungus();
 	}