Commit: 3b3df6e74988772308f46e5407407b22c12bae91 - OfficeWork_cocos2d (hg)

Commit MetaInfo

• Revision: 3b3df6e74988772308f46e5407407b22c12bae91 (tree)
• Time: 2016-10-04 03:23:53
• Author: sebastian_ <bugiu@head...>
• Commiter: sebastian_

Log Message

Added gate control.

Change Summary

• modified: Classes/EventProperties.h
• modified: Classes/GameScene.cpp
• modified: Classes/GateChange.cpp
• modified: Classes/GateChange.h
• modified: Classes/GateControl.cpp
• modified: Classes/GateControl.h
• modified: Classes/GenericBitmapChange.h
• modified: Classes/Level.cpp
• modified: Classes/Level.h
• modified: Classes/MissionSelectionScene.cpp
• modified: Classes/Utility.cpp
• modified: Classes/Utility.h

Incremental Difference

diff -r 3eb1fe4e1a7b -r 3b3df6e74988 Classes/EventProperties.h
--- a/Classes/EventProperties.h	Sun Oct 02 23:46:03 2016 +0300
+++ b/Classes/EventProperties.h	Mon Oct 03 21:23:53 2016 +0300
@@ -13,7 +13,12 @@
     bool collided = false;
 
 public:
-    EventProperties(std::unique_ptr<GameEvent::Event> event_) : event(std::move(event_))
+//    EventProperties(std::unique_ptr<GameEvent::Event> event_) : event(std::move(event_))
+//    {
+//        
+//    }
+
+    EventProperties(std::shared_ptr<GameEvent::Event> event_) : event(event_)
     {
         
     }

diff -r 3eb1fe4e1a7b -r 3b3df6e74988 Classes/GameScene.cpp
--- a/Classes/GameScene.cpp	Sun Oct 02 23:46:03 2016 +0300
+++ b/Classes/GameScene.cpp	Mon Oct 03 21:23:53 2016 +0300
@@ -169,9 +169,22 @@
     // We need the playerEntity to create the level.
     auto currentLevelStr = std::string("lvl") + std::string(std::to_string(currentLevel));
     std::string levelImage = currentLevelStr + ".png";
-    std::string levelClc = currentLevelStr + "_map.clc";
+    std::vector<std::string> clcs;
+    if (currentLevel == 6 || currentLevel == 8)
+    {
+        std::string levelClcClosed = currentLevelStr + "_map_closed.clc";
+        std::string levelClcOpened = currentLevelStr + "_map_opened.clc";
+        clcs.push_back(levelClcClosed);
+        clcs.push_back(levelClcOpened);
+    }
+    else
+    {
+        std::string levelClc = currentLevelStr + "_map.clc";
+        clcs.push_back(levelClc);
+    }
+    
     std::string levelCfg = currentLevelStr + "_cfg";
-    auto levelPtr = loadLevel(levelImage, levelClc, levelCfg, *world, *this);
+    auto levelPtr = loadLevel(levelImage, clcs, levelCfg, *world, *this);
 
     auto& level = world->createEntity();
     level.addComponent(new LevelProperties(levelPtr, halfVisibleSize));

diff -r 3eb1fe4e1a7b -r 3b3df6e74988 Classes/GateChange.cpp
--- a/Classes/GateChange.cpp	Sun Oct 02 23:46:03 2016 +0300
+++ b/Classes/GateChange.cpp	Mon Oct 03 21:23:53 2016 +0300
@@ -1,9 +1,16 @@
 #include "GateChange.h"
 
-GateChangeEvent::GateChangeEvent(artemis::World& world_): Event(world_)
+GateChangeEvent::GateChangeEvent(artemis::World& world_, artemis::Entity& entity_, artemis::Entity& gateControlEntity_) 
+    : GenericBitmapChangeEvent(world_, entity_), gateControlEntity(gateControlEntity_)
 {
 }
 
 void GateChangeEvent::operator()()
 {
+//    auto eventProperties = eventPropertiesMapper.get(entity);
+    auto gateControlEventProperties = eventPropertiesMapper.get(gateControlEntity);
+    if (gateControlEventProperties->getEventDone())
+    {
+        GenericBitmapChangeEvent::operator()();
+    }
 }

diff -r 3eb1fe4e1a7b -r 3b3df6e74988 Classes/GateChange.h
--- a/Classes/GateChange.h	Sun Oct 02 23:46:03 2016 +0300
+++ b/Classes/GateChange.h	Mon Oct 03 21:23:53 2016 +0300
@@ -1,12 +1,14 @@
 #ifndef _GATE_CHANGE_H_
 #define _GATE_CHANGE_H_
-#include "Event.h"
+#include "GenericBitmapChange.h"
 
-class GateChangeEvent : public GameEvent::Event
+class GateChangeEvent : public GenericBitmapChangeEvent
 {
+private:
+    artemis::Entity& gateControlEntity;
 public:
 
-    explicit GateChangeEvent(artemis::World& world_);
+    explicit GateChangeEvent(artemis::World& world_, artemis::Entity& entity_, artemis::Entity& gateControlEntity_);
 
     void operator()() override;
 };

diff -r 3eb1fe4e1a7b -r 3b3df6e74988 Classes/GateControl.cpp
--- a/Classes/GateControl.cpp	Sun Oct 02 23:46:03 2016 +0300
+++ b/Classes/GateControl.cpp	Mon Oct 03 21:23:53 2016 +0300
@@ -1,11 +1,22 @@
 #include "GateControl.h"
 
-GateControlEvent::GateControlEvent(artemis::World& world_) 
-    : Event(world_)
+GateControlEvent::GateControlEvent(artemis::World& world_, Level& level_, artemis::Entity& entity_)
+    : Event(world_), level(level_), entity(entity_)
 {
+//    entityPropertiesMapper.init(world);
+    eventPropertiesMapper.init(world);
+//    timedEventPropertiesMapper.init(world);
 }
 
 void GateControlEvent::operator()()
 {
+//    auto entityProperties = entityPropertiesMapper.get(entity);
+    auto eventProperties = eventPropertiesMapper.get(entity);
+//    auto timedEventProperties = timedEventPropertiesMapper.get(entity);
 
+    if (!eventProperties->getEventDone())
+    {
+        level.setCurentCollisionSet(1);
+        eventProperties->setEventDone(true);
+    }
 }

diff -r 3eb1fe4e1a7b -r 3b3df6e74988 Classes/GateControl.h
--- a/Classes/GateControl.h	Sun Oct 02 23:46:03 2016 +0300
+++ b/Classes/GateControl.h	Mon Oct 03 21:23:53 2016 +0300
@@ -1,13 +1,22 @@
 #ifndef _GATE_CONTROL_H_
 #define _GATE_CONTROL_H_
 #include "Event.h"
-#include <memory>
+#include "Level.h"
+//#include "TimedEventProperties.h"
+//#include "EntityProperties.h"
+#include "EventProperties.h"
+#include "artemis/src/Artemis/ComponentMapper.h"
 
 class GateControlEvent : public GameEvent::Event
 {
 private:
+    Level& level;
+    artemis::Entity& entity;
+//    artemis::ComponentMapper<EntityProperties> entityPropertiesMapper;
+    artemis::ComponentMapper<EventProperties> eventPropertiesMapper;
+//    artemis::ComponentMapper<TimedEventProperties> timedEventPropertiesMapper;
 public:
-    explicit GateControlEvent(artemis::World& world_);
+    explicit GateControlEvent(artemis::World& world_, Level& level_, artemis::Entity& entity_);
 
     void operator()() override;
 

diff -r 3eb1fe4e1a7b -r 3b3df6e74988 Classes/GenericBitmapChange.h
--- a/Classes/GenericBitmapChange.h	Sun Oct 02 23:46:03 2016 +0300
+++ b/Classes/GenericBitmapChange.h	Mon Oct 03 21:23:53 2016 +0300
@@ -14,7 +14,7 @@
 
 class GenericBitmapChangeEvent : public GameEvent::Event
 {
-private:
+protected:
     artemis::Entity& entity;
     artemis::ComponentMapper<EntityProperties> entityPropertiesMapper;
     artemis::ComponentMapper<EventProperties> eventPropertiesMapper;

diff -r 3eb1fe4e1a7b -r 3b3df6e74988 Classes/Level.cpp
--- a/Classes/Level.cpp	Sun Oct 02 23:46:03 2016 +0300
+++ b/Classes/Level.cpp	Mon Oct 03 21:23:53 2016 +0300
@@ -13,6 +13,7 @@
 #include "EventList.h"
 #include "GenericBitmapChange.h"
 #include "TimedEvent.h"
+#include "GateChange.h"
 
 USING_NS_CC;
 
@@ -132,7 +133,7 @@
             else
             {
                 // We have a rotation in coords.y
-                sprite->setRotation(coords.y);
+                sprite->setRotation(getRotationFromFileFormat(coords.y));
             }
             entity.addComponent(entityProperties);
             auto powerupProperties = new PowerupProperties(type);
@@ -188,6 +189,14 @@
             auto& entity = world.createEntity();
             auto entityProperties = new EntityProperties(*sprite);
             entityProperties->setMapPos(Vec2(coords.x, coords.y));
+            if (vec.size() == 2)
+            {
+                if (vec[1].x == -1)
+                {
+                    // We also have a rotation.
+                    sprite->setRotation(getRotationFromFileFormat(vec[1].y));
+                }
+            }
             entity.addComponent(entityProperties);
             std::unique_ptr<GameEvent::Event> genericBitmapChange(new GenericBitmapChangeEvent(world, entity));
             std::unique_ptr<EventList> events(new EventList(world));
@@ -210,6 +219,71 @@
     return genericBitmapChangeList;
 }
 
+std::vector<std::reference_wrapper<artemis::Entity>> Level::createBoilerConsoleList()
+{
+    std::vector<std::reference_wrapper<artemis::Entity>> boilerAndConsoleList;
+    auto pair = coordsMap.find(BOILER_CONSOLE);
+    if (pair != coordsMap.end())
+    {
+        
+    }
+    return boilerAndConsoleList;
+}
+
+std::vector<std::reference_wrapper<artemis::Entity>> Level::createGateList()
+{
+    std::vector<std::reference_wrapper<artemis::Entity>> gateAndGateControlList;
+    auto pair = coordsMap.find(GATE);
+    if (pair != coordsMap.end())
+    {
+        for (auto& vec : pair->second)
+        {
+            auto gatePosCoords = vec[0];
+            auto gateControlPosCoords = vec[1];
+
+            auto gateSprite = Sprite::createWithSpriteFrameName("gate.png");
+            auto& gateEntity = world.createEntity();
+            auto gateEntityProperties = new EntityProperties(*gateSprite);
+            gateEntityProperties->setMapPos(Vec2(gatePosCoords.x, gatePosCoords.y));
+            gateEntity.addComponent(gateEntityProperties);
+
+            auto gateControlSprite = Sprite::createWithSpriteFrameName("gate_control.png");
+            auto& gateControlEntity = world.createEntity();
+            auto gateControlEntityProperties = new EntityProperties(*gateControlSprite);
+            gateControlEntityProperties->setMapPos(Vec2(gateControlPosCoords.x, gateControlPosCoords.y));
+            gateControlEntity.addComponent(gateControlEntityProperties);
+
+            std::shared_ptr<GameEvent::Event> gateBitmapChange(new GateChangeEvent(world, gateEntity, gateControlEntity));
+            std::unique_ptr<GameEvent::Event> gateControlBitmapChange(new GenericBitmapChangeEvent(world, gateControlEntity));
+            std::unique_ptr<EventList> events(new EventList(world));
+
+            events->addEvent(gateBitmapChange);
+            events->addEvent(std::move(gateControlBitmapChange));
+
+            std::unique_ptr<GameEvent::TimedEvent> timedEvent(new GameEvent::TimedEvent(world, gateEntity, std::move(events)));
+
+            auto gateEventProperties = new EventProperties(gateBitmapChange);
+            auto gateTimedEventProperties = new TimedEventProperties();            
+            gateTimedEventProperties->setBrokenBitmap("gate_opened.png");
+            gateEntity.addComponent(gateEventProperties);
+            gateEntity.addComponent(gateTimedEventProperties);
+            gateEntity.refresh();
+
+            auto gateControlEventProperties = new EventProperties(std::move(timedEvent));
+            auto gateControlTimedEventProperties = new TimedEventProperties();
+            gateControlTimedEventProperties->setTotalCollidingTime(1000);
+            gateControlTimedEventProperties->setBrokenBitmap("gate_control_opened.png");
+            gateControlEntity.addComponent(gateControlEventProperties);
+            gateControlEntity.addComponent(gateControlTimedEventProperties);
+            gateControlEntity.refresh();
+
+            gateAndGateControlList.push_back(std::reference_wrapper<artemis::Entity>(gateEntity));
+            gateAndGateControlList.push_back(std::reference_wrapper<artemis::Entity>(gateControlEntity));
+        }
+    }
+    return gateAndGateControlList;
+}
+
 void Level::extractBeginAndEndPositions()
 {
     auto beginningPosCoords = coordsMap.find(BEGINNING_POS)->second[0][0];
@@ -232,6 +306,8 @@
     auto assemblyLineList = createGenericBitmapChangeList(ASSEMBLY_);
     auto waterCollerList = createGenericBitmapChangeList(WATER_COOLER_);
 
+    auto gateAndGateControlList = createGateList();
+
     addToScene(fileList);
     addToScene(foodList);
     addToScene(pinkSlipList);
@@ -244,6 +320,8 @@
     addToScene(assemblyLineList);
     addToScene(waterCollerList);
 
+    addToScene(gateAndGateControlList);
+
     extractBeginAndEndPositions();
 
     auto endConditions = coordsMap.find(COND_END)->second[0];
@@ -261,8 +339,8 @@
     }
 }
 
-Level::Level(cocos2d::Sprite& _map, CollisionSet _collisionSet, CoordsMap _coordsMap, artemis::World& world_, GameScene& gameScene_) :
-	map(_map), collisionSet(std::move(_collisionSet)), coordsMap(std::move(_coordsMap)), world(world_), gameScene(gameScene_)
+Level::Level(cocos2d::Sprite& _map, std::vector<CollisionSet> collisionSetList_, CoordsMap _coordsMap, artemis::World& world_, GameScene& gameScene_) :
+	map(_map), collisionSetList(std::move(collisionSetList_)), coordsMap(std::move(_coordsMap)), world(world_), gameScene(gameScene_)
 {
     extractDataFromCoordsMap();
 
@@ -282,8 +360,8 @@
     unsigned int currentBottom = ((short)currentX) << 16 | ((short)rightLowerCorner.y);
     for (unsigned int i = 0; i < iterCount; ++i)
     {
-        CollisionSet::iterator xy1It = collisionSet.lower_bound(currentTop);
-        CollisionSet::iterator xy2It = collisionSet.upper_bound(currentBottom);
+        CollisionSet::iterator xy1It = collisionSetList[curentCollisionSet].lower_bound(currentTop);
+        CollisionSet::iterator xy2It = collisionSetList[curentCollisionSet].upper_bound(currentBottom);
 
         unsigned int leftX = (*xy1It) >> 16;
         unsigned int leftY = (*xy1It) & 0xffff;
@@ -444,18 +522,25 @@
 	return false;
 }
 
-LevelPtr loadLevel(std::string levelFile, std::string levelCollisionDataFile, std::string levelConfig, artemis::World& world, GameScene& gameScene)
+LevelPtr loadLevel(std::string levelFile, std::vector<std::string> clcs, std::string levelConfig, artemis::World& world, GameScene& gameScene)
 {
 	auto mapSprite = Sprite::create(levelFile);
 
-	CollisionSet collisionSet;
+	std::vector<CollisionSet> collisionSetList;
+    
 	LevelPtr value1;
-	if (getLevelCollisionData(levelCollisionDataFile, collisionSet, value1)) return value1;
+    for (auto& levelCollisionDataFile : clcs)
+    {
+        CollisionSet collisionSet;
+        if (getLevelCollisionData(levelCollisionDataFile, collisionSet, value1)) return value1;
+        collisionSetList.push_back(std::move(collisionSet));
+    }
+	
 
 	CoordsMap coordsMap;
 	if (getLevelConfig(levelConfig, coordsMap, value1)) return value1;
 
-	LevelPtr levelPtr(new Level(*mapSprite, collisionSet, coordsMap, world, gameScene));
+	LevelPtr levelPtr(new Level(*mapSprite, collisionSetList, coordsMap, world, gameScene));
 
 	return levelPtr;
 }

diff -r 3eb1fe4e1a7b -r 3b3df6e74988 Classes/Level.h
--- a/Classes/Level.h	Sun Oct 02 23:46:03 2016 +0300
+++ b/Classes/Level.h	Mon Oct 03 21:23:53 2016 +0300
@@ -49,7 +49,7 @@
 
 enum GenericBitmapEventType
 {
-    ASSEMBLY_, WATER_COOLER_
+    ASSEMBLY_, WATER_COOLER_, BOILER_CONSOLE_, GATE_
 };
 
 class Level
@@ -58,6 +58,8 @@
     GameScene& gameScene;
 	cocos2d::Sprite& map;
 	CollisionSet collisionSet;
+    std::vector<CollisionSet> collisionSetList;
+    unsigned int curentCollisionSet = 0;
 	CoordsMap coordsMap;
     artemis::World& world;
     cocos2d::Vec2 beginningPos;
@@ -68,13 +70,15 @@
     std::vector<std::reference_wrapper<artemis::Entity>> createWorkerList(WorkerType type);
     std::vector<std::reference_wrapper<artemis::Entity>> createPowerupList(PowerupType type);
     std::vector<std::reference_wrapper<artemis::Entity>> createGenericBitmapChangeList(GenericBitmapEventType type);
+    std::vector<std::reference_wrapper<artemis::Entity>> createBoilerConsoleList();
+    std::vector<std::reference_wrapper<artemis::Entity>> createGateList();
     void extractBeginAndEndPositions();
     void extractDataFromCoordsMap();
     void addToScene(std::vector<std::reference_wrapper<artemis::Entity>>& spriteList);
 
 public:
 
-	Level(cocos2d::Sprite& map, CollisionSet _collisionSet, CoordsMap coordsMap, artemis::World& world, GameScene& gameScene);
+	Level(cocos2d::Sprite& map, std::vector<CollisionSet> collisionSetList_, CoordsMap coordsMap, artemis::World& world, GameScene& gameScene);
 
 	bool checkCollisionCoarse(const cocos2d::Vec2& leftUpperCorner, const cocos2d::Vec2& rightLowerCorner);
 
@@ -110,12 +114,23 @@
     {
         return endCondition;
     }
+
+
+    unsigned getCurentCollisionSet() const
+    {
+        return curentCollisionSet;
+    }
+
+    void setCurentCollisionSet(const unsigned curent_collision_set)
+    {
+        curentCollisionSet = curent_collision_set;
+    }
 };
 
 typedef std::unique_ptr<Level> LevelPtr;
 typedef std::shared_ptr<Level> LevelPtrShared;
 
-LevelPtr loadLevel(std::string levelFile, std::string levelCollisionDataFile, std::string levelConfig, artemis::World& world, GameScene& gameScene);
+LevelPtr loadLevel(std::string levelFile, std::vector<std::string> clcs, std::string levelConfig, artemis::World& world, GameScene& gameScene);
 
 #endif
 

diff -r 3eb1fe4e1a7b -r 3b3df6e74988 Classes/MissionSelectionScene.cpp
--- a/Classes/MissionSelectionScene.cpp	Sun Oct 02 23:46:03 2016 +0300
+++ b/Classes/MissionSelectionScene.cpp	Mon Oct 03 21:23:53 2016 +0300
@@ -20,7 +20,7 @@
     labelMainMenu->setPosition(getMenuTitlePosition(*labelMainMenu));
     addChild(labelMainMenu, 1);
 
-    int maxLevelReached = getMaxLevelReached();
+    int maxLevelReached = 8;// getMaxLevelReached();
     std::vector<std::string> titleList;
     int titleStart = FIRST_LEVEL;
     for (int i = 0; i < maxLevelReached; ++i)

diff -r 3eb1fe4e1a7b -r 3b3df6e74988 Classes/Utility.cpp
--- a/Classes/Utility.cpp	Sun Oct 02 23:46:03 2016 +0300
+++ b/Classes/Utility.cpp	Mon Oct 03 21:23:53 2016 +0300
@@ -59,3 +59,19 @@
 {
     return pre + " x: " + std::to_string(vec.x) + " y: " + std::to_string(vec.y);
 }
+
+float getRotationFromFileFormat(int rotation)
+{
+    switch (rotation)
+    {
+    case 0:
+        return 0.0f;
+    case 1:
+        return 90.0f;
+    case 2:
+        return 180.0f;
+    case 3:
+        return 270.0f;
+    }
+    return 0.0f;
+}

diff -r 3eb1fe4e1a7b -r 3b3df6e74988 Classes/Utility.h
--- a/Classes/Utility.h	Sun Oct 02 23:46:03 2016 +0300
+++ b/Classes/Utility.h	Mon Oct 03 21:23:53 2016 +0300
@@ -38,5 +38,7 @@
 
 std::string toString(Vec2 vec, std::string pre);
 
+float getRotationFromFileFormat(int rotation);
+
 #endif