Changeset 12114 for code/branches/wagnis_HS18/src

Timestamp:

Nov 21, 2018, 12:03:16 PM (6 years ago)

Author:

stadlero

Message:

WIP 21 nov

Location:

code/branches/wagnis_HS18/src/modules/wagnis

Files:

• Wagnis.cc (modified) (1 diff)
• Wagnis.h (modified) (2 diffs)
• WagnisGameboard.h (modified) (1 diff)
• WagnisPlayer.cc (modified) (8 diffs)
• WagnisPlayer.h (modified) (4 diffs)
• WagnisProvince.cc (modified) (3 diffs)
• WagnisProvince.h (modified) (2 diffs)

code/branches/wagnis_HS18/src/modules/wagnis/Wagnis.cc

@@ +1 @@
+
+
+
 #include "Wagnis.h"
-#include "WagnisGameboard.h"
-#include "WagnisProvince.h"
 
-       
-        RegisterClass(Wagnis);
-        
-        void Wagnis::createGame()       
-        {   
-            //todo
-            void Wagnis::setPlayers()
-            {
-                //todo
-            }        
-            
-            void Wagnis::chooseProvinces()
-            {
-                //todo
-            }   
-        }
+
+
+namespace orxonox{
+
+RegisterClass(Wagnis);
+
+Wagnis::Wagnis(Context* context) : Deathmatch(context){
+    RegisterObject(Wagnis);
+}
+//Destructor
+Wagnis::~Wagnis(){}
+
+
+}
+
 
         

code/branches/wagnis_HS18/src/modules/wagnis/Wagnis.h

@@ +1 @@
+
+
+
+#ifndef Wagnis_h
+#define Wagnis_h
+
+
 #include "WagnisGameboard.h"
 #include "WagnisProvince.h"
+#include "gametypes/Deathmatch.h"
+
 
 /** Die Wagnis Klasse hat die folgenden Aufgaben:
@@ -18 +27 @@
  **/
 
+
+
 namespace orxonox
 {
-    class _WagnisExport Wagnis : public Deathmatch
+    class /**_WagnisExport**/ Wagnis : public Deathmatch
     {
-        public: 
 
-        // to start the game
-        void createGame();        // creates and links provinces
-
-        
-        // additional checking funtions
-        int troopCounter(int);       // counts how many reinforcements player gets
-        bool attackChecker;     // checks whether an attack move is valid
-                                    // (provinces linked, enough troops, no own province) 
-        bool moveChecker;       // checks whether a troop movement is valid
-                                    // (start and target belong to player, link existing)
-        void attackSimulator;   // calculates outcome of battle 
-        
-    
-    }
-
+    };
 }
+#endif
+ /* Wagnis_h */

code/branches/wagnis_HS18/src/modules/wagnis/WagnisGameboard.h

@@ -37 +37 @@
         void initializeNeighbors(std::string);
 
-    
-    private:
+
         std::vector<WagnisProvince*> provs;
-        
         int parse_int(std::string,unsigned int);
     };

code/branches/wagnis_HS18/src/modules/wagnis/WagnisPlayer.cc

@@ -16 +16 @@
     WagnisPlayer::WagnisPlayer(Context* context) : HumanPlayer(context){
         RegisterObject(WagnisPlayer);
-        this->origin = nullptr;
-        this->target = nullptr;
         this->gameBoard = nullptr;
+        this->is_active = false;
+        this->origin_province = nullptr;
+        this->target_province = nullptr;
+        this->province_selection_changed = false;
     }
     //Destructor
@@ -24 +26 @@
 
     }
+    //Tick
+    void WagnisPlayer::tick(float dt){
+        SUPER(WagnisPlayer, tick, dt);
+
+        if(this->is_active){
+            for(WagnisProvince* prov:this->gameBoard->provs){
+                if(prov->getHealth() < prov->getMaxHealth()){
+                    if(prov->getHealth() <= prov->getMaxHealth()-1000.0f){
+                        this->target_province = prov;
+                        this->province_selection_changed = true;
+                    }else{
+                        this->origin_province = prov;
+                        this->province_selection_changed = true;
+                    }
+                }
+            }
+
+            if(this->province_selection_changed && this->origin_province != nullptr && this->target_province != nullptr){
+                this->province_selection_changed = false;
+                switch(gamestage){
+                    case CHOOSE_PROVINCE_STAGE: 
+                    {   
+                        break;
+                    }
+                    case REINFORCEMENT_STAGE:
+                    {
+                        break;
+                    }
+                    case ATTACK_STAGE:{
+                        break;
+                    }
+                    case MOVE_STAGE:{
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+
+
     //Manages a Players turn
     void WagnisPlayer::playerTurn(){
@@ -33 +76 @@
         if (move_type == ATTACK)
         {
-            if (isNeighbour(this->origin, this->target))//TODO: provinces neighbours
+            if (isNeighbour(this->origin_province, this->target_province))//TODO: provinces neighbours
             {
-                if (this->origin->getOwner_ID() == this->Player_ID) //origin belongs to player
+                if (this->origin_province->getOwner_ID() == this->Player_ID) //origin belongs to player
                 {
-                    if (this->target->getOwner_ID() != this->Player_ID)//target belongs to enemy
+                    if (this->target_province->getOwner_ID() != this->Player_ID)//target belongs to enemy
                         return true;
                 }
@@ -45 +88 @@
         if (move_type == MOVE)
         {
-            if (existPath(this->origin, this->target))//TODO: path exists, all belong to same player
+            if (existPath(this->origin_province, this->target_province))//TODO: path exists, all belong to same player
             {
-                if (this->origin->getOwner_ID() == this->Player_ID)//origin belongs to player
+                if (this->origin_province->getOwner_ID() == this->Player_ID)//origin belongs to player
                     return true;
             }
@@ -55 +98 @@
         if (move_type == SET_TROOPS)
         {
-            if (this->target->getOwner_ID() == this->Player_ID)//target belongs to player
+            if (this->target_province->getOwner_ID() == this->Player_ID)//target belongs to player
                 return true;
         }
@@ -61 +104 @@
         if (move_type == SET_TROOPS_INITIAL)
         {
-            if (this->target->getOwner_ID() == 0)//target belongs to nobody
+            if (this->target_province->getOwner_ID() == 0)//target belongs to nobody
                 return true;
         }
@@ -89 +132 @@
     bool WagnisPlayer::isNeighbour(WagnisProvince*,WagnisProvince*)
     {
-        for (unsigned int i = 0; i < this->origin->neighbors.size(); ++i)
+        for (unsigned int i = 0; i < this->origin_province->neighbors.size(); ++i)
         {
-            if (this->target == this->origin->neighbors[i])
+            if (this->target_province == this->origin_province->neighbors[i])
                 return true;
         }
@@ -102 +145 @@
     bool WagnisPlayer::existPath(WagnisProvince*,WagnisProvince*)
     {
-        if (this->origin->getOwner_ID() == this->target->getOwner_ID() && isNeighbour(this->origin, this->target))
+        if (this->origin_province->getOwner_ID() == this->target_province->getOwner_ID() && isNeighbour(this->origin_province, this->target_province))
             return true;
         
-        for (unsigned int i = 0; i < this->origin->neighbors.size(); ++i)
+        for (unsigned int i = 0; i < this->origin_province->neighbors.size(); ++i)
         {
-            if (this->origin->getOwner_ID() == this->origin->neighbors[i]->getOwner_ID())
-                return existPath(this->origin->neighbors[i], this->target);
+            if (this->origin_province->getOwner_ID() == this->origin_province->neighbors[i]->getOwner_ID())
+                return existPath(this->origin_province->neighbors[i], this->target_province);
         }
             

code/branches/wagnis_HS18/src/modules/wagnis/WagnisPlayer.h

@@ -7 +7 @@
 #define Wagnis_Player_h
 
+#include "Wagnis.h"
 #include "OrxonoxPrereqs.h"
 #include "core/CoreIncludes.h"
@@ -17 +18 @@
 
 enum MoveType { ATTACK, MOVE, SET_TROOPS, SET_TROOPS_INITIAL };
+enum GameStagexyz { CHOOSE_PROVINCE_STAGE, REINFORCEMENT_STAGE, ATTACK_STAGE, MOVE_STAGE };
 
 
@@ -22 +24 @@
 namespace orxonox
 {
-    class WagnisPlayer : public HumanPlayer
+    class WagnisPlayer : public HumanPlayer, public Tickable
     {
     public:
         WagnisPlayer(Context*);
         virtual ~WagnisPlayer();
+        void tick(float);
 
         void playerTurn();
@@ -35 +38 @@
         std::string toString();
 
-    private:
+
+
+        GameStagexyz gamestage;
+        bool province_selection_changed;
+        bool is_active;
         int Player_ID;
         WagnisGameboard* gameBoard;
-        WagnisProvince* origin;
-        WagnisProvince* target;
+        WagnisProvince* origin_province;
+        WagnisProvince* target_province;
         bool isNeighbour(WagnisProvince*,WagnisProvince*);
         bool existPath(WagnisProvince*,WagnisProvince*);

code/branches/wagnis_HS18/src/modules/wagnis/WagnisProvince.cc

@@ +1 @@
+
+
 #include "WagnisProvince.h"
 #include "core/CoreIncludes.h"
@@ -32 +34 @@
     WagnisProvince::~WagnisProvince(){
 
-    }
-
-    //Tick
-    void WagnisProvince::tick(float dt){
-        SUPER(WagnisProvince, tick, dt);
-
-        if(this->health_ < this->maxHealth_){
-            this->health_ = this->maxHealth_;
-            orxout() << "Health test ok" << endl;        }
     }
 
@@ -107 +100 @@
         neighbors.push_back(prov);
     }
+
+    void WagnisProvince::setBillbardVisibility(bool b){
+        //TODO set visibility of billboard
+    }
 }

code/branches/wagnis_HS18/src/modules/wagnis/WagnisProvince.h

@@ -22 +22 @@
         WagnisProvince(Context*);
         virtual ~WagnisProvince();
-        void tick(float);
 
 
@@ -40 +39 @@
 
         void addNeighbor(WagnisProvince*);
+        void setBillbardVisibility(bool);
+
+
         std::vector<WagnisProvince*> neighbors;
-
- 
         int owner_ID;
         int troops;