Fixing indentation

Everything should be tabs now

1 files changed, 319 insertions, 321 deletions

diff --git a/fungi.cpp b/fungi.cpp
index 097ca74..b361602 100644
--- a/fungi.cpp
+++ b/fungi.cpp
@@ -29,8 +29,8 @@ const int SCREEN_HEIGHT = 480;
  * Keeps track of window position
  */
 struct Window_Pos {
-    uint16_t posx;
-    uint16_t posy;
+	uint16_t posx;
+	uint16_t posy;
 };
 
 /*
@@ -38,8 +38,8 @@ struct Window_Pos {
  * Keeps track of window size
  */
 struct Window_Size {
-    uint16_t width;
-    uint16_t height;
+	uint16_t width;
+	uint16_t height;
 };
 
 /*
@@ -47,8 +47,8 @@ struct Window_Size {
  * Keeps track of where we are
  */
 struct Location {
-    uint16_t posx;
-    uint16_t posy;
+	uint16_t posx;
+	uint16_t posy;
 };
 
 /*
@@ -56,10 +56,10 @@ struct Location {
  * Keeps track of the appearance of the fungus
  */
 struct Color {
-    uint8_t red;
-    uint8_t green;
-    uint8_t blue;
-    uint8_t alpha;
+	uint8_t red;
+	uint8_t green;
+	uint8_t blue;
+	uint8_t alpha;
 };
 
 /*
@@ -68,67 +68,67 @@ struct Color {
  */
 class Fungus {
 private:
-   struct Location local;
-   struct Color color;
-   uint8_t growthPoints;
-   uint8_t hp;
+	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; }
+	/**
+	 * Creates a useless Fungus
+	 */
+	Fungus() {
+		hp = 0;
+		growthPoints = 0;
+	}
 
-   /**
-    * Get the color of the fungus
-    * @return The color of the fungus
-    */
-   Color getColor() const { return color; }
+	/**
+	 * 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;
+	}
 
-   /**
-    * Adds growth to the fungus
-    * @param val Amount to grow the fungus
-    */
-   void addGrowth(uint8_t val) { growthPoints += val; }
+	~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; }
+	/**
+	 * 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; }
 };
 
 /*
@@ -137,71 +137,71 @@ public:
  */
 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());
+	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;
 	}
-	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);
+	/**
+	 * 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
-     */
+	/**
+	 * Copy construction
+	 * Doesn't work right apparently
+	 */
     /*
     Petri(const Petri& p) {
 	dish.reserve(p.getSize());
@@ -217,93 +217,91 @@ public:
     }
     */
 
-    /**
-     * 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;
-	    }
+	/**
+	 * 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* 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];
+	/**
+	 * 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;
+	/**
+	 * 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;
 		}
-	    }
-	} 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);
-		    }
+	/**
+	 * 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; }
+	/**
+	 * 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; }
+	/**
+	 * 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; }
 };
 
 /*
@@ -312,130 +310,130 @@ public:
  */
 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;
+	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;
 	}
-	sdlRenderer = SDL_CreateRenderer(sdlWindow, -1,
-	SDL_RENDERER_SOFTWARE);
-	if (sdlRenderer == nullptr){
-	    logSDLError(std::cout, "CreateRenderer");
-	    SDL_DestroyWindow(sdlWindow);
-	    sdlWindow = nullptr;
-	    SDL_Quit();
-	    bad = true;
+
+	/**
+	 * 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);
 	}
-	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);
-    }
+	/**
+	 * 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);
+	/**
+	 * Creates a SDLWindow without anything to show
+	 */
+	SDLWindow() {
+		bad = false;
+		init({100, 100}, {SCREEN_WIDTH, SCREEN_HEIGHT});
 	}
-	if(sdlRenderer != nullptr) {
-	    SDL_DestroyRenderer(sdlRenderer);
+
+	/**
+	 * 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});
 	}
-	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;
+	/**
+	 * Destroyer of the window
+	 */
+	~SDLWindow() {
+		if(sdlWindow != nullptr) {
+			SDL_DestroyWindow(sdlWindow);
 		}
-	    }
-
-	    for(int i = 0; i < petri.getSize(); i++) {
-		if(petri[i] != nullptr) {
-		    drawFungus(*petri[i]);
+		if(sdlRenderer != nullptr) {
+			SDL_DestroyRenderer(sdlRenderer);
 		}
-	    }
-
-	    SDL_RenderPresent(sdlRenderer);
+		SDL_Quit();
+	}
 
-	    petri.grow();
+	/**
+	 * 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);
-	}
+			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; }
+	/**
+	 * 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,14 +441,14 @@ public:
 
 int main(int argv, char* argc[]) {
     
-    srandom(11);
+	srandom(11);
 
-    Window_Size ws = {SCREEN_WIDTH, SCREEN_HEIGHT};
-    Petri* p = new Petri(SCREEN_HEIGHT * SCREEN_WIDTH, ws);
+	Window_Size ws = {SCREEN_WIDTH, SCREEN_HEIGHT};
+	Petri* p = new Petri(SCREEN_HEIGHT * SCREEN_WIDTH, ws);
 
-    p->addFungus(new Fungus({0, 0}, {255, 0, 0, 0}));
-    p->addFungus(new Fungus({0, 1}, {0, 255, 0, 0}));
-    p->addFungus(new Fungus({0, 2}, {0, 0, 255, 0}));
+	p->addFungus(new Fungus({0, 0}, {255, 0, 0, 0}));
+	p->addFungus(new Fungus({0, 1}, {0, 255, 0, 0}));
+	p->addFungus(new Fungus({0, 2}, {0, 0, 255, 0}));
 
     /*
     for(int i = 0; i < 255; i++) {
@@ -460,12 +458,12 @@ int main(int argv, char* argc[]) {
     }
     */
     
-    SDLWindow win(*p);
-    if(!win.isBad()) {
-	win.doFungus();
-    }
+	SDLWindow win(*p);
+	if(!win.isBad()) {
+		win.doFungus();
+	}
 
     //delete p;
 
-    return 0;
+	return 0;
 }