assign4.tar

Ant_Bodyguard.cpp0000700000641100504040000000213013304130141013703 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_Bodyguard.cpp
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Bodyguard class
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include "Insect_GP.h"
#include "Ant_P.h"
#include "Ant_Bodyguard.h"

using namespace std;

/********************************************************************* 
** Function: Bodyguard()
** Description: Constructor
** Parameters: N/A
** Pre-Conditions: Constructs the Bodyguard 
** Post-Conditions: 
*********************************************************************/ 
Bodyguard::Bodyguard(){
    food_cost = 4;
    armor = 2;
    name = "BG";
}

/********************************************************************* 
** Function: attack_enemy()
** Description: N/A
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: N/A
*********************************************************************/ 
void Bodyguard::attack_enemy(){
    // Doesn't use
}Ant_Bodyguard.h0000700000641100504040000000110113304072064013356 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_Bodyguard.h
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Bodyguard .h file
** Input: N/A
** Output: N/A
*********************************************************************/ 
 
#include <iostream>
#include <string>
#include "Insect_GP.h"
#include "Ant_P.h"
#ifndef ANT_BODYGUARD_H
#define ANT_BODYGUARD_H

using namespace std;

class Bodyguard: public Ant{
    public:
        Bodyguard();
        virtual void attack_enemy();
};

#endifAnt_Fire.cpp0000700000641100504040000000231313304130147012661 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_Fire.cpp
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Fire class
** Input: N/A
** Output: N/A
*********************************************************************/ 
#include <iostream>
#include "Ant_P.h"
#include "Ant_Fire.h"

using namespace std;

/********************************************************************* 
** Function: Fire()
** Description: Constructor
** Parameters: N/A
** Pre-Conditions: Constructs the Fire 
** Post-Conditions: 
*********************************************************************/ 
Fire::Fire(){
    food_cost = 4;
    armor = 1;
    name = "FR";
}

/********************************************************************* 
** Function: attack_enemy()
** Description: Attacks Bees
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: N/A
*********************************************************************/ 
void Fire::attack_enemy(/*game * board,*Bee**bees, int * num_bees */){
    // if(board[i].bees != NULL){
    //     for(int i = 0; i < num_bees; i++){
    //         board[i].bees = NULL;
    //     }
    // }
}

Ant_Fire.h0000700000641100504040000000100713304070375012333 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_Fire.h
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Fire .h file
** Input: N/A
** Output: N/A
*********************************************************************/ 
 
#include <iostream>
#include <string>
#ifndef ANT_FIRE_H
#define ANT_FIRE_H

using namespace std;

class Fire: public Ant{
    protected:
    public:
        Fire();
        virtual void attack_enemy();
};

#endifAnt_Harvester.cpp0000700000641100504040000000210013304131245013731 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_Harvester.cpp
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Harvester class
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include "Ant_P.h"
#include "Ant_Harvester.h"

using namespace std;

/********************************************************************* 
** Function: Harvester()
** Description: Constructor
** Parameters: N/A
** Pre-Conditions: Constructs the Harvester 
** Post-Conditions: 
*********************************************************************/ 
Harvester::Harvester(){
    food_cost = 2;
    armor = 1;
    name = "HV";
}

/********************************************************************* 
** Function: attack_enemy()
** Description: N/A
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: N/A
*********************************************************************/ 
void Harvester::attack_enemy(){
    // Doesn't use
}Ant_Harvester.h0000700000641100504040000000107013304130510013375 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_Harvester.h
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Harvester .h file
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include <string>
#include "Ant_P.h"
#ifndef ANT_HARVESTER_H
#define ANT_HARVESTER_H

using namespace std;

class Harvester: public Ant{
    protected:
    public:
        Harvester();
        virtual void attack_enemy();
};

#endifAnt_Long_Thrower.cpp0000700000641100504040000000227713304130764014423 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_Long_Thrower.cpp
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: LongThrower class
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include "Ant_P.h"
#include "Ant_Long_Thrower.h"

using namespace std;

/********************************************************************* 
** Function: LongThrower()
** Description: Constructor
** Parameters: N/A
** Pre-Conditions: Constructs the LongThrower 
** Post-Conditions: 
*********************************************************************/ 
LongThrower::LongThrower(){
    food_cost = 3;
    armor = 1;
    name = "LT";
}

/********************************************************************* 
** Function: attack_enemy()
** Description: N/A
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: N/A
*********************************************************************/ 
void LongThrower::attack_enemy(/*game * board,*Bee**bees, int * num_bees */){
    // if(board[i+2].bees != NULL){
    //       board[i+2].bees = NULL;
    // }
}Ant_Long_Thrower.h0000700000641100504040000000110313304130474014051 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_LongThrower.h
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: LongThrower.h file
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include <string>
#include "Ant_P.h"
#ifndef ANT_LONGTHROWER_H
#define ANT_LONGTHROWER_H

using namespace std;

class LongThrower: public Ant{
    protected:
    public:
        LongThrower();
        virtual void attack_enemy();
};

#endifAnt_Ninja.cpp0000700000641100504040000000221513304131275013037 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_Ninja.cpp
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Ninja class
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include "Ant_P.h"
#include "Ant_Ninja.h"

using namespace std;

/********************************************************************* 
** Function: Ninja()
** Description: Constructor
** Parameters: N/A
** Pre-Conditions: Constructs the Ninja 
** Post-Conditions: 
*********************************************************************/ 
Ninja::Ninja(){
    food_cost = 6;
    armor = 1;
    name = "NJ";
}

/********************************************************************* 
** Function: attack_enemy()
** Description: N/A
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: N/A
*********************************************************************/ 
void Ninja::attack_enemy(/*game * board,*Bee**bees, int * num_bees */){
    // if(board[i+2].bees != NULL){
    //       board[i+2].bees = NULL;
    // }
}Ant_Ninja.h0000700000641100504040000000104013304130501012466 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_Ninja.h
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Ninja .h file
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include <string>
#include "Ant_P.h"
#ifndef ANT_NINJA_H
#define ANT_NINJA_H

using namespace std;

class Ninja: public Ant{
    protected:
    public:
        Ninja();
        virtual void attack_enemy();
};

#endifAnt_P.cpp0000700000641100504040000000215413304130656012203 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_P.cpp
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Ant class
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include <string>
#include "Insect_GP.h"
#include "Ant_P.h"

using namespace std;

/********************************************************************* 
** Function: set_food_cost()
** Description: set food_cost
** Parameters: int food_cost
** Pre-Conditions: takes in food_cost
** Post-Conditions: sets the food_cost
*********************************************************************/
void Ant::set_food_cost(int food_cost){
    this->food_cost = food_cost;
}

/********************************************************************* 
** Function: get_food_cost()
** Description: get food_cost
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: returns food_cost
*********************************************************************/
int Ant::get_food_cost(){
    return food_cost;
}Ant_P.h0000700000641100504040000000106513304056043011645 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant.h
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Ant .h file
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include <string>
#include "Insect_GP.h"
#ifndef ANT_P_H
#define ANT_P_H

using namespace std;

class Ant: public Insect{
    protected:
        int food_cost;
    public:
        void set_food_cost(int);
        int get_food_cost();
};

#endifAnt_Short_Thrower.cpp0000700000641100504040000000230713304131046014607 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_Short_Thrower.cpp
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: ShortThrower class
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include "Ant_P.h"
#include "Ant_Short_Thrower.h"

using namespace std;

/********************************************************************* 
** Function: ShortThrower()
** Description: Constructor
** Parameters: N/A
** Pre-Conditions: Constructs the ShortThrower 
** Post-Conditions: 
*********************************************************************/ 
ShortThrower::ShortThrower(){
    food_cost = 3;
    armor = 1;
    name = "ST";
}

/********************************************************************* 
** Function: attack_enemy()
** Description: N/A
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: N/A
*********************************************************************/ 
void ShortThrower::attack_enemy(/*game * board,*Bee**bees, int * num_bees */){
    // if(board[i+2].bees != NULL){
    //       board[i+1].bees = NULL;
    // }
}Ant_Short_Thrower.h0000700000641100504040000000112413304056040014250 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_ShortThrower.h
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: ShortThrower .h file
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include <string>
#include "Ant_P.h"
#ifndef ANT_SHORTTHROWER_H
#define ANT_SHORTTHROWER_H

using namespace std;

class ShortThrower: public Ant{
    protected:
    public:
        ShortThrower();
        
        virtual void attack_enemy();
};

#endifAnt_Thrower.cpp0000700000641100504040000000227613304131116013433 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_Thrower.cpp
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Thrower class
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include "Ant_P.h"
#include "Ant_Thrower.h"

using namespace std;

/********************************************************************* 
** Function: Thrower()
** Description: Constructor
** Parameters: N/A
** Pre-Conditions: Constructs the Thrower 
** Post-Conditions: 
*********************************************************************/ 
Thrower::Thrower(){
    food_cost = 4;
    armor = 1;
    name = "TH";
}

/********************************************************************* 
** Function: attack_enemy()
** Description: N/A
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: N/A
*********************************************************************/ 
void Thrower::attack_enemy(/*game * board,*Bee**bees, int * num_bees */){
    // if(board[i].bees != NULL){
    //       board[i].bees->set_armor(board[i].bees->get_armor() - 1 );
    // }
}Ant_Thrower.h0000700000641100504040000000105413304131332013071 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_Thrower.h
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Thrower .h file
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include <string>
#include "Ant_P.h"
#ifndef ANT_THROWER_H
#define ANT_THROWER_H

using namespace std;

class Thrower: public Ant{
    protected:
    public:
        Thrower();
        virtual void attack_enemy();
};

#endifAnt_Wall.cpp0000700000641100504040000000206613304131155012700 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_Wall.cpp
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Wall class
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include "Ant_P.h"
#include "Ant_Wall.h"

using namespace std;

/********************************************************************* 
** Function: Wall()
** Description: Constructor
** Parameters: N/A
** Pre-Conditions: Constructs the Wall 
** Post-Conditions: 
*********************************************************************/ 
Wall::Wall(){
    food_cost = 4;
    armor = 4;
    name = "WL";
}

/********************************************************************* 
** Function: attack_enemy()
** Description: N/A
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: N/A
*********************************************************************/ 
void Wall::attack_enemy(/*game * board,*Bee**bees, int * num_bees */){
    
}Ant_Wall.h0000700000641100504040000000103213304056071012340 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Ant_Wall.h
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Wall .h file
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include <string>
#include "Ant_P.h"
#ifndef ANT_WALL_H
#define ANT_WALL_H

using namespace std;

class Wall: public Ant{
    protected:
    public:
        Wall();
        virtual void attack_enemy();
};

#endifBee_P.cpp0000700000641100504040000000202713304131437012151 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Bee_P.cpp
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Bee class
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include "Insect_GP.h"
#include "Bee_P.h"

using namespace std;

/********************************************************************* 
** Function: Bee()
** Description: Constructor
** Parameters: N/A
** Pre-Conditions: Constructs the Bee 
** Post-Conditions: 
*********************************************************************/ 
Bee::Bee(){
    armor = 4;
    damage = 1;
    name = "BEE";
}

/********************************************************************* 
** Function: attack_enemy()
** Description: N/A
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: N/A
*********************************************************************/
void Bee::attack_enemy(){
    // Player function
}


Bee_P.h0000700000641100504040000000103013304131412011600 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Bee.h
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Bee .h file
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include <string>
#include "Insect_GP.h"
#include "Player.h"
#ifndef Bee_P_H
#define Bee_P_H

using namespace std;

class Bee: public Insect{
    public:
        Bee();
        virtual void attack_enemy();
};

#endifInsect_GP.cpp0000700000641100504040000000462513304057215013021 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Insect_GP.cpp
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Insect class
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include <string>
#include "Insect_GP.h"

using namespace std;

/********************************************************************* 
** Function: set_armor()
** Description: set armor
** Parameters: int armor
** Pre-Conditions: takes in armor
** Post-Conditions: sets the armor
*********************************************************************/
void Insect::set_armor(int armor){
    this->armor = armor;
}

/********************************************************************* 
** Function: get_armor()
** Description: get armor
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: returns armor
*********************************************************************/
int Insect::get_armor(){
    return armor;
}

/********************************************************************* 
** Function: set_damage()
** Description: set damage
** Parameters: int damage
** Pre-Conditions: takes in damage
** Post-Conditions: sets the damage
*********************************************************************/
void Insect::set_damage(int damage){
    this->damage = damage;
}

/********************************************************************* 
** Function: get_damage()
** Description: get damage
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: returns damage
*********************************************************************/
int Insect::get_damage(){
    return damage;
}

/********************************************************************* 
** Function: set_name()
** Description: set name
** Parameters: string name
** Pre-Conditions: takes in name
** Post-Conditions: sets the name
*********************************************************************/
void Insect::set_name(string name){
    this->name = name;
}

/********************************************************************* 
** Function: get_name()
** Description: get name
** Parameters: N/A
** Pre-Conditions: 
** Post-Conditions: returns name
*********************************************************************/
string Insect::get_name(){
    return name;
}Insect_GP.h0000700000641100504040000000141613304131426012456 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Insect_GP.h
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Insect .h file
** Input: N/A
** Output: N/A
*********************************************************************/ 

#include <iostream>
#include <string>
#ifndef INSECT_H
#define INSECT_H

using namespace std;

class Insect{
    protected:
        int armor;
        int damage;  
        string name;      
    public:
        void set_armor(int armor);
        int get_armor();
        
        void set_damage(int damage);
        int get_damage();
        
        void set_name(string);
        string get_name();
        
        virtual void attack_enemy() = 0;
};

#endifMain.cpp0000700000641100504040000000163413304134441012064 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Main.cpp
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Main File
** Input: N/A
    ** Output: Runs all code
*********************************************************************/ 

#include <iostream>
#include <string>
#include "Player.h"
#include "Bee_P.h"

using namespace std;

int main(){
    cout << endl;
    cout << "[ WELCOME TO ANTLIEN VS BEENATOR ]" << endl;
    Player player;
    Bee bee;
    player.set_food_bank(50);
    player.set_board(player.init_gameboard());
    player.print_gameboard();    
    do{
        player.run_game(bee);
    } while(player.bees_win() != true && player.ants_win() != true);
    player.print_gameboard();
    if(player.bees_win() == true){ cout << "BEES WIN!" << endl; }
    if(player.ants_win() == true){ cout << "ANTS WIN!" << endl; }
}
Player.cpp0000700000641100504040000004433613304150257012445 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Player.cpp
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Player class
** Input: N/A
** Output: Stores all codes
*********************************************************************/ 

#include <iostream>
#include <string>
#include <cmath>
#include <vector>
#include "Player.h"
#include "Insect_GP.h"
#include "Ant_P.h"
#include "Bee_P.h"
#include "Ant_Fire.h"
#include "Ant_Harvester.h"
#include "Ant_Long_Thrower.h"
#include "Ant_Ninja.h"
#include "Ant_Short_Thrower.h"
#include "Ant_Thrower.h"
#include "Ant_Wall.h"

using namespace std;

/********************************************************************* 
** Function: Player()
** Description: Constructor
** Parameters: N/A
** Pre-Conditions: Constructs the board 
** Post-Conditions: 
*********************************************************************/
Player::Player(){
    
}

/********************************************************************* 
** Function: Player(const Player & copy)
** Description: copy Constructor
** Parameters: const Player & copy
** Pre-Conditions: copy the board 
** Post-Conditions: 
*********************************************************************/
Player::Player(const Player & copy){
    board = new game[10];
    for(int i = 0; i < 10; i++){
        board[i].ants = copy.board[i].ants;
    }
    for(int j = 0; j < 10; j++){
        board[j].bees = copy.board[j].bees;
    }
    for(int k = 0; k < 10; k++){
        board[k].bodyguard = copy.board[k].bodyguard;
    }
}

/********************************************************************* 
** Function: Player & operator=(const Player & copy
** Description: AOO
** Parameters: N/A
** Pre-Conditions: Over loads = 
** Post-Conditions: 
*********************************************************************/
Player & Player::operator=(const Player & copy){
    for(int i = 0; i < 10; i++){
        if(board[i].ants != NULL){ delete [] board[i].ants; }
    }
    for(int j = 0; j < 10; j++){
        if(board[j].bees.size() != 0){
            for(int p = 0; p < board[j].bees.size(); p++){ board[j].bees.clear(); }
        }
    }
    for(int k = 0; k < 10; k++){
        if(board[k].bodyguard != NULL){ delete [] board[k].bodyguard; }
    }
    if(board != NULL){ delete [] board; }
    board = new game[10];
    for(int i = 0; i < 10; i++){ board[i].ants = copy.board[i].ants; }
    for(int j = 0; j < 10; j++){ board[j].bees = copy.board[j].bees; }
    for(int k = 0; k < 10; k++){ board[k].bodyguard = copy.board[k].bodyguard; }
}
/********************************************************************* 
** Function: ~Player()
** Description: deconstructor
** Parameters: N/A
** Pre-Conditions: Destructs the board 
** Post-Conditions: 
*********************************************************************/ 
Player::~Player(){
    for(int i = 0; i < 10; i++){
        if(board[i].ants != NULL){
            delete [] board[i].ants;
        }
    }
    for(int j = 0; j < 10; j++){
        if(board[j].bees.size() != 0){
            for(int p = 0; p < board[j].bees.size(); p++){
                board[j].bees.clear();
            }
        }
    }
    for(int k = 0; k < 10; k++){
        if(board[k].bodyguard != NULL){
            delete [] board[k].bodyguard;
        }
    }
    delete [] board;
}

/********************************************************************* 
** Function: set_food_bank()
** Description: set food_bank
** Parameters: int food_bank
** Pre-Conditions: takes in food_bank
** Post-Conditions: sets the food_bank
*********************************************************************/
void Player::set_food_bank(int food_bank){
    this->food_bank = food_bank;
}

/********************************************************************* 
** Function: get_food_bank()
** Description: get food_bank
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: returns food_bank
*********************************************************************/
int Player::get_food_bank(){
    return food_bank;
}

void Player::set_board(game * board){
    this->board = board;
}

/********************************************************************* 
** Function: get_board()
** Description: get board
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: returns board
*********************************************************************/
game * Player::get_board(){
    return board;
}

/********************************************************************* 
** Function: init_gameboard()
** Description: builds board
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: returns board
*********************************************************************/
game * Player::init_gameboard(){
    game * board = new game[10];
    return board;
}

/********************************************************************* 
** Function: print_mainpart_gameboard()
** Description: prints main board
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: prints main board
*********************************************************************/
void Player::print_mainpart_gameboard(){
    for(int i = 0; i < 10; i++){
        if(board[i].ants != NULL)
            cout << "| " << board[i].ants->get_name() << "  Armor: " << board[i].ants->get_armor() << " |";
        else cout << "| " << "            " << " |" ;
    }
    cout << endl;
    for(int j = 0; j < 10; j++){
        if(board[j].bees.size() != 0){
            cout << "| " << board[j].bees.at(0).get_name() << "  " << board[j].num_bees << "      " << " |";
        }
        else cout << "| " << "            " << " |" ;
    }
    cout << endl;
    for(int l = 0; l < 10 ; l++){
        if(board[l].bodyguard != NULL)
            cout << "| " << board[l].bodyguard->get_name() << "  Armor: " << board[l].bodyguard->get_armor() << " |";
        else cout << "| " << "            " << " |" ;
    }
}

/********************************************************************* 
** Function: print_gameboard()
** Description: prints board
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: prints board
*********************************************************************/
void Player::print_gameboard(){
    cout << endl;
    cout << "[ ANT NEST ]                                                                                                                                        [ BEE HIVE ]" << endl;
    for(int c = 0; c < 10; c++){ cout << "  " << "------------" << "  "; }
    cout << endl;
    print_mainpart_gameboard();
    cout << endl;
    for(int c = 0; c < 10; c++){ cout << "  " << "------------" << "  " ; }
    cout << endl;
    cout << "Food left in the food bank: " << food_bank << " units of food" << endl;
}

/********************************************************************* 
** Function: to_int()
** Description: turn string to int
** Parameters: string num
** Pre-Conditions: takes in a string
** Post-Conditions: returns an int
*********************************************************************/
int Player::to_int(string num){
	int res = 0, i = 0;
	for(i; i < num.length(); i++){
		res += (num[i] - 48) * pow(10,num.length()-i-1);
	}
	return res;
}

/********************************************************************* 
** Function: generate_bees()
** Description: generates bees
** Parameters: Bee bee
** Pre-Conditions: takes in a bee object
** Post-Conditions: push_back it into the vector
*********************************************************************/
void Player::generate_bees(Bee bee){
    board[9].bees.push_back(bee);
}

/********************************************************************* 
** Function: move_bees()
** Description: moves bees
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: moves bees to the left
*********************************************************************/
void Player::move_bees(){
    for(int i = 1; i < 10; i++){
        if(((board[i].ants == NULL || board[i].ants->get_name() == "NJ") && board[i].bodyguard == NULL)  && board[i].bees.size() != 0){
            board[i-1].bees = board[i].bees;
        }
        if(board[i-1].ants != NULL || board[i-1].bodyguard != NULL){
            board[i].num_bees++;
        }
    }
}

/********************************************************************* 
** Function: print_ant()
** Description: prints ants
** Parameters: N/A
** Pre-Conditions: N/A
** Post-Conditions: prints ants
*********************************************************************/
void Player::print_ant(){
    cout << endl;
    cout << "[ LIST OF AVALIABLE ANTS ]" << endl;
    cout << endl;
    cout << "[1] Harvester, Cost: 2, Armor: 1" << endl;
    cout << "[2] Thrower, Cost: 4, Armor: 1" << endl;
    cout << "[3] Fire, Cost: 4, Armor: 1" << endl;
    cout << "[4] Long Thrower, Cost: 3, Armor: 1" << endl;
    cout << "[5] Short Thrower, Cost: 3, Armor: 1" << endl;
    cout << "[6] Wall, Cost: 4, Armor: 4" << endl;
    cout << "[7] Ninja, Cost: 6, Armor: 1" << endl;
    cout << "[8] Bodyguard, Cost: 4, Armor: 2" << endl;
}

/********************************************************************* 
** Function: valid_ant()
** Description: checks if input for ant is true
** Parameters: string ant
** Pre-Conditions: Checks if input is valid
** Post-Conditions: returns true or false
*********************************************************************/
bool Player::valid_ant(string ant){
    if(ant == "1"){ return true; }
    if(ant == "2"){ return true; }
    if(ant == "3"){ return true; }
    if(ant == "4"){ return true; }
    if(ant == "5"){ return true; }
    if(ant == "6"){ return true; }
    if(ant == "7"){ return true; }
    if(ant == "8"){ return true; }
    return false;
}

/********************************************************************* 
** Function: get_ant()
** Description: returns user input int form
** Parameters: N/A
** Pre-Conditions: Asks the user for input
** Post-Conditions: returns the user input
*********************************************************************/
int Player::get_ant(){
    string r = "";
    do{
        cout << "Choose an ant: ";
        getline(cin, r);
    } while(valid_ant(r) == false);
    int a = to_int(r);
    return a;
}

/********************************************************************* 
** Function: not_occupied_ant_space()
** Description: checks if a space is occupied
** Parameters: string position
** Pre-Conditions: checks if a space is occupied
** Post-Conditions: returns true or false
*********************************************************************/
bool Player::not_occupied_ant_space(string position){
    if(board[to_int(position)-1].ants != NULL && board[to_int(position)-1].bodyguard == NULL){
        return true;
    }
    if(board[to_int(position)-1].ants == NULL){
        return true;
    }
    return false;
}

/********************************************************************* 
** Function: valid_position()
** Description: checks if user input is valid
** Parameters: string position
** Pre-Conditions: checks if position is valid
** Post-Conditions: returns true or false
*********************************************************************/
bool Player::valid_position(string position){
    if(position == "1"){ return true; }
    if(position == "2"){ return true; }
    if(position == "3"){ return true; }
    if(position == "4"){ return true; }
    if(position == "5"){ return true; }
    if(position == "6"){ return true; }
    if(position == "7"){ return true; }
    if(position == "8"){ return true; }
    if(position == "9"){ return true; }
    if(position == "10"){ return true; }
    return false;
}

/********************************************************************* 
** Function: get_position()
** Description: returns user input int form
** Parameters: N/A
** Pre-Conditions: Asks the user for input
** Post-Conditions: returns the user input
*********************************************************************/
int Player::get_position(){
    string r = "";
    do{
        cout << "Position to place the ant: ";
        getline(cin, r);
    } while(valid_position(r) == false || !not_occupied_ant_space(r));
    int a = to_int(r);
    return a;
}

/********************************************************************* 
** Function: place_ant()
** Description: returns user input int form
** Parameters: int ant, int position
** Pre-Conditions: takes int ant and position
** Post-Conditions: places the ant on the board
*********************************************************************/
void Player::place_ant(int ant, int position){
    if(food_bank > 0){
        if(ant > 0 && ant < 8){
            if(ant == 1){ board[position-1].ants = new Harvester(); }
            if(ant == 2){ board[position-1].ants = new Thrower(); }
            if(ant == 3){ board[position-1].ants = new Fire(); }
            if(ant == 4){ board[position-1].ants = new LongThrower(); }
            if(ant == 5){ board[position-1].ants = new ShortThrower(); }
            if(ant == 6){ board[position-1].ants = new Wall(); }
            if(ant == 7){ board[position-1].ants = new Ninja(); }
            food_bank = food_bank - board[position-1].ants->get_food_cost();
        }
        if(ant == 8){ 
            board[position-1].bodyguard = new Bodyguard(); 
            food_bank = food_bank - board[position-1].bodyguard->get_food_cost();
        }  
    }  
} 

/********************************************************************* 
** Function: each_move()
** Description: runs user turn functions
** Parameters: N?A
** Pre-Conditions: N/A
** Post-Conditions: places the ant on the board
*********************************************************************/
void Player::each_move(){
    int ant = get_ant();
    int position = get_position();
    place_ant(ant, position);
}

/********************************************************************* 
** Function: harvester_attack()
** Description: Adds one to food if harvester is present
** Parameters: N?A
** Pre-Conditions: N/A
** Post-Conditions: Adds one to food if harvester is present
*********************************************************************/
void Player::harvester_attack(){
    for(int i = 0; i < 10; i++){
        if(board[i].ants != NULL && board[i].ants->get_name() == "HV"){
            food_bank+=1;
        }
    }
}

/********************************************************************* 
** Function: ants_win()
** Description: checks if ants won
** Parameters: string position
** Pre-Conditions: checks if ants won
** Post-Conditions: returns true or false
*********************************************************************/
bool Player::ants_win(){
    int bee_count = 0;
    for(int i = 0; i < 10; i++){
        if(board[i].bees.size() != 0){
            bee_count++;
        }
    }
    if(bee_count == 0){
        return true;
    }
    return false;
}

/********************************************************************* 
** Function: bees_win()
** Description: checks if bees won
** Parameters: string position
** Pre-Conditions: checks if bees won
** Post-Conditions: returns true or false
*********************************************************************/
bool Player::bees_win(){
    if(board[0].bees.empty() == false){
        return true;
    }
    return false;
}

/********************************************************************* 
** Function: bee_attack()
** Description: bees attack ants
** Parameters: N/A
** Pre-Conditions: bees attack 
** Post-Conditions: attack ants
*********************************************************************/
void Player::bee_attack(){
    for(int i = 0; i < 10; i++){
        if(board[i].bees.size() != 0) {
            if(board[i].bodyguard != NULL){
                board[i].bodyguard->set_armor(board[i].bodyguard->get_armor() - 1) ;
            }
        }
        if(board[i].bees.size() != 0){
            if(board[i].ants != NULL){
                board[i].ants->set_armor(board[i].ants->get_armor() - 1);
            }
        }
    }
}

/********************************************************************* 
** Function: remove_dead_ants()
** Description: removes dead ants
** Parameters: N/A
** Pre-Conditions: checks for dead ants
** Post-Conditions: deletes them
*********************************************************************/
void Player::remove_dead_ants(){
    for(int i = 0; i < 10; i++){
        if(board[i].ants != NULL){
            if(board[i].ants->get_armor() == 0){
                delete [] board[i].ants;
                board[i].ants = NULL;
            }
        }
        if(board[i].bodyguard != NULL){
            if(board[i].bodyguard->get_armor() == 0){
                delete [] board[i].bodyguard;
                board[i].bodyguard = NULL;
            }
        }
    }
}

/********************************************************************* 
** Function: run_game()
** Description: runs the game
** Parameters: Bee bee
** Pre-Conditions: takes in bee object
** Post-Conditions: runs game
*********************************************************************/
void Player::run_game(Bee bee){
    print_ant();
    cout << endl;
    each_move();
    generate_bees(bee);
    print_gameboard();
    bee_attack();
    move_bees();
    harvester_attack();
    remove_dead_ants();
}

/********************************************************************* 
** Function: run_attack()
** Description: runs all ant attacks
** Parameters: N/A
** Pre-Conditions: runs all ant attacks
** Post-Conditions: deletes them
*********************************************************************/
void Player::run_attack(){
    // for(int j = 0; j < 10; j++){
    //     Bee** bees = new *Bee[10];
    //     for(int i -0; i < 10; i++){
    //         bees[i] = baord[i].bees;
    //     }
    //     int* num_bees = new int[10];
    //     for(int i = 10; i < 10; i++){
    //         num_bees[i] = board[i].num_bees;
    //     }
    //     if(board[j].ants != NULL)
    //     board[j].ants->attack_enemy(bees, num_bees, j)
    // }
}



Player.h0000700000641100504040000000326413304147645012114 0ustar  bajracaeupg3337/********************************************************************* 
** Program Filename: Player.h
** Author: Aeijan Bajracharya
** Date: 5/30/18
** Description: Player .h file
** Input: N/A
** Output: N/A
*********************************************************************/ 

#ifndef PLAYER_H
#define PLAYER_H
#include <iostream>
#include <string>
#include <vector>
#include "Ant_P.h"
#include "Bee_P.h"
#include "Ant_Bodyguard.h"

using namespace std;

struct game{
    Ant * ants;
    Bodyguard * bodyguard;
    vector<Bee> bees;
    int num_bees;
};

class Player{
    protected:
        int food_bank;
        game * board;

    public:
        Player();
        Player(const Player &);
        Player & operator=(const Player &);
        ~Player();
        void set_food_bank(int);
        int get_food_bank();
        void set_board(game *);
        game * get_board();
    
                
        game * init_gameboard();
        void print_mainpart_gameboard();
        void print_gameboard();
                
        void generate_bees( Bee);
        void move_bees();

        int to_int(string);

        void print_ant();
        bool valid_ant(string);
        int get_ant();
                
        bool not_occupied_ant_space(string);
        int get_position();
        bool valid_position(string);
        
        void place_ant(int, int);

        void each_move();
        
        void harvester_attack();
        
        bool ants_win();
        bool bees_win();
        
        void bee_attack();
        void remove_dead_ants();\
        
        void run_game(Bee);
        void run_attack();
};

#endifMakefile0000700000641100504040000000206713302706662012145 0ustar  bajracaeupg3337CC = g++
exe_file = ants
$(exe_file): Main.o Insect_GP.o Ant_P.o Bee_P.o Player.o Ant_Bodyguard.o Ant_Fire.o Ant_Harvester.o Ant_Long_Thrower.o Ant_Ninja.o Ant_Short_Thrower.o Ant_Thrower.o Ant_Wall.o 
	$(CC)  Main.o Insect_GP.o Ant_P.o Bee_P.o Player.o Ant_Bodyguard.o Ant_Fire.o Ant_Harvester.o Ant_Long_Thrower.o Ant_Ninja.o Ant_Short_Thrower.o Ant_Thrower.o Ant_Wall.o -o $(exe_file)
Main.o: Main.cpp
	$(CC) -c Main.cpp
Insect_GP.o: Insect_GP.cpp
	$(CC) -c Insect_GP.cpp
Ant_P.o: Ant_P.cpp
	$(CC) -c Ant_P.cpp
Bee_P.o: Bee_P.cpp
	$(CC) -c Bee_P.cpp
Player.o: Player.cpp
	$(CC) -c Player.cpp
Ant_Bodyguard.o: Ant_Bodyguard.cpp
	$(CC) -c Ant_Bodyguard.cpp
Ant_Fire.o: Ant_Fire.cpp
	$(CC) -c Ant_Fire.cpp
Ant_Harvester.o: Ant_Harvester.cpp
	$(CC) -c Ant_Harvester.cpp
Ant_Long_Thrower.o: Ant_Long_Thrower.cpp
	$(CC) -c Ant_Long_Thrower.cpp
Ant_Ninja.o: Ant_Ninja.cpp
	$(CC) -c Ant_Ninja.cpp
Ant_Short_Thrower.o: Ant_Short_Thrower.cpp
	$(CC) -c Ant_Short_Thrower.cpp
Ant_Wall.o: Ant_Wall.cpp
	$(CC) -c Ant_Wall.cpp
clean:
	rm -f *.out *.o $(exe_file)