added cell and organism

Author: wario2k

cell.cpp

@@ -0,0 +1,39 @@
+#include "cell.hpp"
+/**
+ * Brief: Default Constructor
+ * Description: empty constructor to prevent default compiler generated constructur
+ * */
+Cell::Cell()
+{ 
+}
+
+/**
+ * Brief: Constructor with x and y co-ordinates provided 
+ * Description : Initializes a cell with x and y co-ordinates
+ * @param: int xVal - x co-ordinate
+ * @param: int yVal - y co-ordinate
+ * */
+Cell::Cell(int xVal, int yVal) : x(xVal), y(yVal)
+{ }
+
+/**
+ * Brief: Overladed equality operator
+ * Description : Utility overload to compare to cells
+ * @param: const Cell& a - first cell to be compared 
+ * @param: const Cell& b - second cell to be compared 
+ * @return : true if equal
+ * */
+bool operator ==(const Cell& a, const Cell& b)
+{
+    return ((a.x == b.x) && (a.y == b.y));
+}
+
+/**
+ * Brief: Utility function to return string notation of cell
+ * Description : Returns a string representation of the cell with its x and y co-ordinates
+ * @return : string representation of cell
+ * */
+std::string Cell::str() const
+{
+    return '(' + std::to_string(x) + ',' + std::to_string(y) + ')';
+}

cell.hpp

@@ -0,0 +1,24 @@
+///implementation of cell class 
+#ifndef CELL_H
+#define CELL_H
+
+#include <string>
+#include <vector>
+
+class Cell
+{
+public:
+    ///default constructor 
+    Cell();
+    //initialize cell with x and y chords 
+    Cell(int xVal, int yVal);
+    //overladed operator to check for equality 
+    friend bool operator ==(const Cell& cell1, const Cell& cell2);
+    int x;
+    int y;
+    std::string str() const;
+};
+///vector to hold cells
+typedef std::vector<Cell> CellVector;
+
+#endif /* CELL_H */

controller.cpp

@@ -0,0 +1,63 @@
+#include "organism.hpp"
+
+/**
+ * Description : Constructor to initialize an organism
+ * @param : int requiredSurvivalTime - time before breed
+ * @param : char organismSymbol - type of organism
+ * @param : const Cell& cell - cell location 
+ * */
+Organism::Organism(
+    int requiredSurvivalTime,
+    char organismSymbol,
+    const Cell& cell
+) :
+    myCell(cell),
+    required_survival_time_for_breeding(requiredSurvivalTime),
+    symbol(organismSymbol),
+    timeSurvived(0)
+{ }
+
+/**
+ * Default Destructor
+ * */
+Organism::~Organism() {}
+
+/**
+ * Description : Get what organism is residing in cell
+ * @param  : Organism* organism - organism pointer to cell 
+ * @return : Symbol of organism if present else empty space symbol
+ * */
+ 
+char getSymbolOrEmptyChar(Organism* organism)
+{
+    if (organism == NULL)
+        return EMPTY_SPACE_CHAR;
+    else
+        return organism->symbol;
+}
+
+/**
+ * Brief : compare cells to see what organism resides there
+ * @param : char value - value to be compared
+ * */
+OrganismComparator::OrganismComparator(char value) :
+    compareValue(value)
+{ }
+/**
+ * Brief : compare cells to see what organism resides there
+ * Description : Uses the organism object to compare value
+ * @param : Organism* organism - pointer to organism in cell
+ * 
+ * */
+OrganismComparator::OrganismComparator(Organism* organism) :
+    compareValue(getSymbolOrEmptyChar(organism))
+{ }
+
+/**
+ * Description : Overloaded operator to compare organism values 
+ * @return : true if the match else false
+ * */
+bool OrganismComparator::compare(Organism* organism)
+{
+    return (compareValue == getSymbolOrEmptyChar(organism));
+}

controller.hpp

@@ -0,0 +1,49 @@
+#ifndef ORGANISM_H
+#define ORGANISM_H
+
+#include "cell.hpp"
+#include <vector>
+
+const char ROADRUNNER_CHAR = 'o';
+const char COYOTE_CHAR = 'X';
+const char EMPTY_SPACE_CHAR = '-';
+
+class Organism
+{
+public:
+    Organism(int requiredSurvivalTime, char organismSymbol, const Cell& cell);
+    ///destructor
+    virtual ~Organism() = 0;
+    //virtual functions to be implemented in base classes 
+    virtual void move(const Cell& newCell) = 0;
+    virtual Cell getCell() const = 0;
+    virtual void setCell(const Cell& cell) = 0;
+    virtual int getTimeSurvived() const = 0;
+    virtual void incrementTimeSurvived() = 0;
+    virtual bool readyToBreed() const = 0;
+    const char symbol;
+    //gets type of organism 
+    friend char getSymbolOrEmptyChar(Organism* organism);
+protected:
+    const int required_survival_time_for_breeding;
+    int timeSurvived;
+    Cell myCell;
+};
+
+///vector of organism pointers
+typedef std::vector<Organism*> OrganismVector;
+
+/**
+ * Utility class to compare organisms 
+ * */
+class OrganismComparator
+{
+public:
+    OrganismComparator(char value);
+    OrganismComparator(Organism* organism);
+    bool compare(Organism* organism);
+private:
+    const char compareValue;
+};
+
+#endif /* ORGANISM_H */