Extract ZIP contents

Author: LB--

BASE.cpp

@@ -0,0 +1,102 @@
+#include "Building.hpp"
+
+
+sf::Sprite* BASE::draw()
+{
+    if(Selected)
+    {
+        Sprite2.SetPosition(Pos);
+        return &Sprite2;
+    }
+    
+    Sprite.SetPosition(Pos);
+    return &Sprite;
+}
+
+
+
+bool BASE::Hit(BASE* Obj)
+{
+    if(Test(Pos, Obj->Pos, RB, Obj->RB))
+    {
+        return true;
+    }
+    
+    return false;
+}
+
+
+bool BASE::Test(sf::Vector2f A, sf::Vector2f B, sf::Vector2f RBA, sf::Vector2f RBB)
+{
+    if((A.x > B.x) && (A.x < RBB.x) && (A.y > B.y) && (A.y < RBB.y))
+    {
+        /* if(A.x > B.x)
+        {
+            std::cout << " A.x Greater Then B.x\n";
+        }
+        if(A.x < RBB.x)
+        {
+            std::cout << " A.x Less Then RBB.x\n";
+        }
+        
+        if(A.y > B.y)
+        {
+            std::cout << " A.y Greater Then B.y\n";
+        }
+        if(A.y < RBB.y)
+        {
+            std::cout << " A.y Less Then RBB.y\n";
+        } */
+
+        
+        return true;
+    }
+    
+    if((RBA.x > B.x) && (RBA.x < RBB.x) && (RBA.y > B.y) && (RBA.y < RBB.y))
+    {
+        /* if(RBA.x > B.x)
+        {
+            std::cout << " RBA.x Greter Then B.x\n";
+        }
+        if(RBA.x < RBB.x)
+        {
+            std::cout << " RBA.x Less Then RBB.x\n";
+        }
+        
+        if(RBA.y > B.y)
+        {
+            std::cout << " RBA.y Greater Then B.y\n";
+        }
+        if(RBA.y < RBB.y)
+        {
+            std::cout << " RBA.y Less Then RBB.y\n";
+        } */
+
+        
+        return true;
+    }
+
+    return false;
+}
+
+
+std::string BASE::GetData()
+{
+    return "Hello";
+}
+
+
+std::string BASE::TYPE()
+{
+    switch(Type)
+    {
+        case HUMAN:
+            return " Human ";
+        case ZOMBIE:
+            return " Zombie ";
+        case TER:
+            return " Building ";
+        default:
+            return " NULL ";
+    }
+}

Building.cpp

@@ -0,0 +1 @@
+#include "Building.hpp"

Building.hpp

@@ -0,0 +1,39 @@
+#include "Units.hpp"
+
+#ifndef __BUILDING__BUILDING
+    #define __BUILDING__BUILDING
+
+struct BUILDING: BASE
+{
+    private:
+
+    public:
+        BUILDING(sf::Image* img, float X, float Y)
+        {
+            Img = img;
+            Type = 3;
+            
+            Pos.x = X;
+            Pos.y = Y;
+            
+            Right = Img->GetWidth();
+            Bottom = Img->GetHeight();
+            
+            RB.x = Right;
+            RB.y = Bottom;
+            
+            
+            Sprite.SetImage(*Img);
+            
+            //std::cout << "X: " << Pos.x << " Y: " << Pos.y << " Right: " << Right << " Bottom: " << Bottom << "\n";
+            Sprite.SetPosition(Pos);
+        }
+        
+        //bool Hit(sf::Vector2f Pos);
+    
+};
+
+
+
+
+#endif

Enemy.cpp

@@ -0,0 +1,134 @@
+#include "Enemy.hpp"
+
+int ENEMY::Enemy = 0;
+
+sf::Sprite* ENEMY::draw()
+{
+    if(Selected)
+    {
+        Sprite2.SetPosition(Pos);
+        return &Sprite2;
+    }
+    
+    return &Sprite;
+}
+
+
+std::string ENEMY::GetData()
+{
+    if(!Alive)
+    {
+        return "DEAD";
+    }
+    
+    std::ostringstream Stream;
+    Stream << "LID: " << LID << "\nHit Points: " << HP << "\nTarget: " << Target;
+    
+    return Stream.str();
+}
+
+
+bool ENEMY::RightClick(float X, float Y)
+{
+    if(X >= Pos.x && X <= Right && Y >= Pos.y && Y <= Bottom)
+    {
+        Targeted = true;
+        return true;
+    }
+    else
+    {
+        Targeted = false;
+        return false;
+    }
+}
+
+
+
+int ENEMY::Attack(UNIT* Unit)
+{
+    if(!Alive)
+    {
+        return 0;
+    }
+    
+    if(!Unit->Alive)
+    {
+        if(Unit->LID == Target)
+        {
+            Target = -1;
+        }
+        
+        return 0;
+    }
+    
+    float NewRange = fabs(sqrt(pow(Unit->Pos.y, 2) + pow(Unit->Pos.x, 2)) - sqrt(pow(Pos.x, 2) + pow(Pos.y, 2)));
+    TRange = fabs(sqrt((pow(TargetLoc.y, 2) + pow(TargetLoc.x, 2))) - sqrt(pow(Pos.x, 2) + pow(Pos.y, 2)));
+    
+    if(Unit->Type == HUMAN)
+    {
+        if(Target == -1 && Unit->Alive == true) //If Enemy Has No Target AND The Unit Being Looked At Is Alive
+        {
+            Target = Unit->LID;
+        }
+        
+        if(Unit->LID == Target) //Chase Target
+        {
+            Dest = Unit->Pos;
+            TargetLoc = Unit->Pos;
+        }
+    }
+        
+    if(Test(Pos, Unit->Pos, RB, Unit->RB)) //Test For Impact With Target
+    {
+        if(Unit->Type == ZOMBIE)
+        {
+            MoveAway(Unit);
+            return 0;
+        }
+        
+        std::cout << LID << " Is Attacking " << Unit->LID << std::endl;
+        
+        int Roll = rand() % 4;
+        switch(Roll)
+        {
+            case 1: 
+                Unit->Hit(); 
+                Kills++; 
+                std::cout << LID << " Hit: " << Unit->LID << "\n";
+                
+                //Target = -1;
+            return 1;
+                
+            case 2:
+                //std::cout << "\nZombifying " << Id << "\n";
+                //Target = -1;
+            return 3;
+                    
+            default:
+                //std::cout << Unit->ID << " Got Away From " << Id << std::endl;
+            break;
+        }
+    }
+    
+    return 0;
+}
+
+
+void ENEMY::Hit()
+{
+    HP--;
+    
+    if(HP <= 0)
+    {
+        Die();
+    }
+}
+
+
+void ENEMY::Die()
+{
+    Alive = false;
+    Selected = false;
+    Id--;
+    Enemy--;
+}

Enemy.hpp

@@ -0,0 +1,81 @@
+#include "Units.hpp"
+
+struct ENEMY : UNIT
+{
+    private:
+        
+    public:
+        ENEMY(sf::Image* img, int Z): Targeted(false)
+        {   
+            scale = SCALE;
+            
+            Enemy++;
+            
+            HP = 2;
+            
+            LID = Id; //Id Is A Static Data Member
+            PID = Id;
+            Id++;   //Increament Id Everytime Constructor Is Called
+            Alive = true;
+            Selected = false;
+            Mode = NORMAL;
+            Speed = .5;
+            
+            Kills = 0;
+            
+            Pos = sf::Vector2f(0,0);
+            
+            Img = img; //Inherited From Base Class 
+            Type = Z; //Inherited From Base Class
+            
+            Time.Reset();
+            Target = -1;
+            
+            /////*Generate Units Position Until It Is Within The Bounds Of The Screen*/////
+            do
+            {
+                Pos.x = rand() % 200; //Start Somewhere between 0 and 200
+                Right = Pos.x + (25 * scale);
+            }while(Pos.x < 0 || Right > WIDTH);
+            
+            do
+            {
+                Pos.y = rand() % HEIGHT;
+                Bottom = Pos.y + (50 * scale);
+            }while(Pos.y < 0 || Bottom > HEIGHT);
+            
+            RB.x = Right;
+            RB.y = Bottom;
+            
+            Sprite.SetImage(*Img);
+                Sprite.SetScale(scale, scale);
+                Sprite.SetSubRect(sf::IntRect(0, 0, 24, 50));
+            
+            Sprite2.SetImage(*Img);
+                Sprite2.SetScale(scale, scale);
+                Sprite2.SetSubRect(sf::IntRect(25, 0, 50, 50));
+                
+            Sprite3.SetImage(*Img);
+                Sprite3.SetScale(scale, scale);
+                Sprite3.SetSubRect(sf::IntRect(51, 0, 75, 50));
+
+            
+            Sprite.SetPosition(Pos);
+            Sprite2.SetPosition(Pos);
+            Sprite3.SetPosition(Pos);
+            
+            Dest = Pos;
+        }
+    
+    sf::Sprite* draw();
+    std::string GetData();
+    bool RightClick(float X, float Y);
+    int Attack(UNIT* Unit);
+    void Hit();
+    void Die();
+    
+    bool Targeted;
+    sf::Sprite Sprite3;
+    
+    static int Enemy;
+};