summary refs log tree commit diff stats
diff options
context:
space:
mode:
authorKelly Rauchenberger <fefferburbia@gmail.com>2015-03-18 18:23:54 -0400
committerKelly Rauchenberger <fefferburbia@gmail.com>2015-03-18 18:23:54 -0400
commit103587c2d5f9deb20e549a86cdf5023b429cc6a1 (patch)
treef1e2fc60b86395e0cc40646ad1e4396a835b682f
parent2ec163612042bfa5e4e1bf220b489506f7039677 (diff)
downloadtherapy-103587c2d5f9deb20e549a86cdf5023b429cc6a1.tar.gz
therapy-103587c2d5f9deb20e549a86cdf5023b429cc6a1.tar.bz2
therapy-103587c2d5f9deb20e549a86cdf5023b429cc6a1.zip
Wrote an XML Schema describing maps file and also changed the spec a bit
Diffstat
-rw-r--r--CMakeLists.txt1


-rw-r--r--res/maps.xml8


-rw-r--r--res/maps.xsd92


-rw-r--r--src/components/map_collision.cpp16


-rw-r--r--src/game.cpp164


-rw-r--r--src/game.h7


-rw-r--r--src/map.cpp107


-rw-r--r--src/map.h35


-rw-r--r--src/world.cpp134


-rw-r--r--src/world.h21


-rw-r--r--tools/mapedit/src/frame.cpp188


-rw-r--r--tools/mapedit/src/map.cpp162


-rw-r--r--tools/mapedit/src/map.h44


-rw-r--r--tools/mapedit/src/widget.cpp16


-rw-r--r--tools/mapedit/src/world.cpp397


15 files changed, 620 insertions, 772 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7c9084e..c5e8f71 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt

@@ -53,6 +53,7 @@ add_executable(Aromatherapy

53  src/game.cpp
53  src/game.cpp

54  src/muxer.cpp
54  src/muxer.cpp

55  src/entityfactory.cpp
55  src/entityfactory.cpp


56  src/world.cpp

56  src/components/map_collision.cpp
57  src/components/map_collision.cpp

57  src/components/map_render.cpp
58  src/components/map_render.cpp

58  src/components/physics_body.cpp
59  src/components/physics_body.cpp
diff --git a/res/maps.xml b/res/maps.xml
index 594cd18..444e59f 100644
--- a/res/maps.xml
+++ b/res/maps.xml

@@ -1,5 +1,5 @@

1<?xml version="1.0" encoding="ISO-8859-1"?>
1<?xml version="1.0" encoding="ISO-8859-1"?>

2<world><nextmapid>5</nextmapid><lastmap>4</lastmap><root>0</root><startpos id="0" pos="203,44"/><map id="0"><name>Everything Is Embarrassing</name><environment>0,0,0,0,0,0,0,0,0,0,19,0,0,0,0,0,20,0,0,0,0,0,0,0,18,9,8,10,8,11,8,10,10,8,11,8,9,10,21,0,
2<world nextmap="5" lastmap="4" startx="203" starty="44" startmap="0"><root>0</root><map id="0" title="Everything Is Embarrassing" expanded="true"><environment type="0">0,0,0,0,0,0,0,0,0,0,19,0,0,0,0,0,20,0,0,0,0,0,0,0,18,9,8,10,8,11,8,10,10,8,11,8,9,10,21,0,

30,0,0,0,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,8,8,17,0,0,0,0,0,0,0,0,0,0,0,0,0,22,21,
30,0,0,0,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,8,8,17,0,0,0,0,0,0,0,0,0,0,0,0,0,22,21,

40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,8,8,8,8,17,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,
40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,8,8,8,8,17,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,

50,19,0,0,0,0,0,0,0,0,0,0,0,18,8,8,17,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,
50,19,0,0,0,0,0,0,0,0,0,0,0,18,8,8,17,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,
@@ -23,7 +23,7 @@

230,0,0,0,24,3,1,2,1,1,25,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,27,1,3,2,26,0,0,0,0,0,0,
230,0,0,0,24,3,1,2,1,1,25,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,27,1,3,2,26,0,0,0,0,0,0,

241,2,3,1,25,0,0,0,0,0,20,0,0,0,0,0,0,19,0,0,0,0,0,0,20,0,0,0,0,0,0,0,0,27,1,2,2,4,3,1,
241,2,3,1,25,0,0,0,0,0,20,0,0,0,0,0,0,19,0,0,0,0,0,0,20,0,0,0,0,0,0,0,0,27,1,2,2,4,3,1,

250,0,0,0,0,0,19,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0,0,0,0,0,0,0,0,
250,0,0,0,0,0,19,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0,0,0,0,0,0,0,0,

26</environment><leftmap type="warp" map="1"/><rightmap type="wall"/><upmap type="wall"/><downmap type="wall"/><entities/><child>1</child><child>4</child><expanded>1</expanded></map><map id="1"><name>It's A Trap!</name><environment>0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
26</environment><adjacent dir="left" type="warp" map="1" /><child>1</child><child>4</child></map><map id="1" title="It's A Trap!"><environment type="0">0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

270,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0,0,0,0,0,
270,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0,0,0,0,0,

280,0,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,0,0,0,0,0,0,0,0,0,0,0,0,
280,0,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,0,0,0,0,0,0,0,0,0,0,0,0,

290,0,0,0,0,0,0,19,0,0,0,0,0,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
290,0,0,0,0,0,0,19,0,0,0,0,0,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -47,7 +47,7 @@

470,0,0,27,2,2,3,3,3,4,26,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
470,0,0,27,2,2,3,3,3,4,26,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,

480,20,0,0,0,0,0,19,0,0,27,1,1,1,2,2,2,26,0,0,0,0,0,0,0,0,0,0,24,4,2,2,1,3,2,2,1,2,2,3,
480,20,0,0,0,0,0,19,0,0,27,1,1,1,2,2,2,26,0,0,0,0,0,0,0,0,0,0,24,4,2,2,1,3,2,2,1,2,2,3,

490,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,19,0,0,0,0,0,
490,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,19,0,0,0,0,0,

50</environment><leftmap type="wall"/><rightmap type="warp" map="0"/><upmap type="wall"/><downmap type="warp" map="4"/><entities><entity><entity-type>checkpoint</entity-type><entity-position>262,156</entity-position></entity></entities></map><map id="4"><name>The Visitors</name><environment>0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,
50</environment><entity type="checkpoint" x="262" y="156" /><adjacent dir="right" type="warp" map="0" /><adjacent dir="down" type="warp" map="4" /></map><map id="4" title="The Visitors"><environment type="0">0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,

510,0,0,0,0,0,0,19,0,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,13,0,0,0,0,0,0,20,0,0,0,0,
510,0,0,0,0,0,0,19,0,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,13,0,0,0,0,0,0,20,0,0,0,0,

520,0,0,0,0,0,0,0,0,0,0,20,0,0,0,0,0,15,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,
520,0,0,0,0,0,0,0,0,0,0,20,0,0,0,0,0,15,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,

530,0,0,0,19,0,0,0,0,0,0,0,0,0,20,0,0,15,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,
530,0,0,0,19,0,0,0,0,0,0,0,0,0,20,0,0,15,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,
@@ -71,4 +71,4 @@

710,0,0,0,0,0,20,0,0,0,0,0,0,0,0,0,0,15,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,
710,0,0,0,0,0,20,0,0,0,0,0,0,0,0,0,0,15,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,

720,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,15,0,0,0,0,0,0,0,0,0,0,13,0,0,0,0,0,0,0,0,0,0,0,
720,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,15,0,0,0,0,0,0,0,0,0,0,13,0,0,0,0,0,0,0,0,0,0,0,

730,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,
730,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,

74</environment><leftmap type="wall"/><rightmap type="wall"/><upmap type="warp" map="1"/><downmap type="wall"/><entities/></map></world>
74</environment><adjacent dir="up" type="warp" map="1" /><adjacent dir="down" type="wrap" /></map></world>
diff --git a/res/maps.xsd b/res/maps.xsd
new file mode 100644
index 0000000..9d36fab
--- /dev/null
+++ b/res/maps.xsd

@@ -0,0 +1,92 @@


1<?xml version="1.0"?>


2<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">


3  <xs:simpleType name="map">


4    <xs:restriction base="xs:integer">


5      <xs:minInclusive value="0" />


6    </xs:restriction>


7  </xs:simpleType>


8  


9  <xs:simpleType name="move-type">


10    <xs:restriction base="xs:string">


11      <xs:enumeration value="wall" />


12      <xs:enumeration value="wrap" />


13      <xs:enumeration value="warp" />


14      <xs:enumeration value="reverseWarp" />


15    </xs:restriction>


16  </xs:simpleType>


17  


18  <xs:simpleType name="direction">


19    <xs:restriction base="xs:string">


20      <xs:enumeration value="left" />


21      <xs:enumeration value="right" />


22      <xs:enumeration value="up" />


23      <xs:enumeration value="down" />


24    </xs:restriction>


25  </xs:simpleType>


26


27  <xs:element name="world">


28    <xs:complexType>


29      <xs:sequence>


30        <xs:element name="root" type="map" maxOccurs="unbounded" />


31      


32        <xs:element name="map" maxOccurs="unbounded">


33          <xs:complexType>


34            <xs:sequence>


35              <xs:element name="environment">


36                <xs:complexType>


37                  <xs:simpleContent>


38                    <xs:extension base="xs:string">


39                      <xs:attribute name="type" use="required">


40                        <xs:simpleType>


41                          <xs:restriction base="xs:integer">


42                            <xs:minInclusive value="0" />


43                            <xs:maxExclusive value="5" />


44                          </xs:restriction>


45                        </xs:simpleType>


46                      </xs:attribute>


47                    </xs:extension>


48                  </xs:simpleContent>


49                </xs:complexType>


50              </xs:element>


51        


52              <xs:element name="entity" minOccurs="0" maxOccurs="unbounded">


53                <xs:complexType>


54                  <xs:attribute name="type" type="xs:string" use="required" />


55                  <xs:attribute name="x" type="xs:integer" use="required" />


56                  <xs:attribute name="y" type="xs:integer" use="required" />


57                </xs:complexType>


58              </xs:element>


59              


60              <xs:element name="adjacent" minOccurs="0" maxOccurs="4">


61                <xs:complexType>


62                  <xs:attribute name="dir" type="direction" use="required" />


63                  <xs:attribute name="type" type="move-type" use="required" />


64                  <xs:attribute name="map" type="map" default="0" />


65                </xs:complexType>


66              </xs:element>


67        


68              <xs:element name="child" type="map" minOccurs="0" maxOccurs="unbounded" />


69            </xs:sequence>


70            


71            <xs:attribute name="id" type="xs:integer" use="required" />


72            <xs:attribute name="expanded" type="xs:boolean" default="false" />


73            <xs:attribute name="title" use="required">


74              <xs:simpleType>


75                <xs:restriction base="xs:string">


76                  <xs:maxLength value="40" />


77                </xs:restriction>


78              </xs:simpleType>


79            </xs:attribute>


80          </xs:complexType>


81        </xs:element>


82      </xs:sequence>


83      


84      <xs:attribute name="nextmap" type="map" default="0" />


85      <xs:attribute name="lastmap" type="map" default="0" />


86      <xs:attribute name="startx" type="xs:integer" use="required" />


87      <xs:attribute name="starty" type="xs:integer" use="required" />


88      <xs:attribute name="startmap" type="map" use="required" />


89    </xs:complexType>


90  </xs:element>


91  


92</xs:schema>
diff --git a/src/components/map_collision.cpp b/src/components/map_collision.cpp
index 9adad26..83ad33d 100644
--- a/src/components/map_collision.cpp
+++ b/src/components/map_collision.cpp

@@ -5,10 +5,10 @@

5
5

6MapCollisionComponent::MapCollisionComponent(const Map& map) : map(map)
6MapCollisionComponent::MapCollisionComponent(const Map& map) : map(map)

7{
7{

8  addCollision(-6, 0, GAME_HEIGHT, Direction::left, collisionFromMoveType(map.getLeftMoveType()));
8  addCollision(-6, 0, GAME_HEIGHT, Direction::left, collisionFromMoveType(map.getAdjacent(Map::MoveDir::Left).type));

9  addCollision(GAME_WIDTH+6, 0, GAME_HEIGHT, Direction::right, collisionFromMoveType(map.getRightMoveType()));
9  addCollision(GAME_WIDTH+6, 0, GAME_HEIGHT, Direction::right, collisionFromMoveType(map.getAdjacent(Map::MoveDir::Right).type));

10  addCollision(-7, 0, GAME_WIDTH, Direction::up, collisionFromMoveType(map.getUpMoveType()));
10  addCollision(-7, 0, GAME_WIDTH, Direction::up, collisionFromMoveType(map.getAdjacent(Map::MoveDir::Up).type));

11  addCollision(GAME_HEIGHT+6, 0, GAME_WIDTH, Direction::down, collisionFromMoveType(map.getDownMoveType()));
11  addCollision(GAME_HEIGHT+6, 0, GAME_WIDTH, Direction::down, collisionFromMoveType(map.getAdjacent(Map::MoveDir::Down).type));

12  
12  

13  for (int i=0; i<MAP_WIDTH*MAP_HEIGHT; i++)
13  for (int i=0; i<MAP_WIDTH*MAP_HEIGHT; i++)

14  {
14  {
@@ -189,16 +189,16 @@ void MapCollisionComponent::processCollision(Game& game, Entity& collider, Colli

189  {
189  {

190    if (dir == Direction::left)
190    if (dir == Direction::left)

191    {
191    {

192      game.loadMap(game.getMap(map.getLeftMapID()), std::make_pair(GAME_WIDTH-collider.size.first/2, old_position.second));
192      game.loadMap(game.getWorld().getMap(map.getAdjacent(Map::MoveDir::Left).map), std::make_pair(GAME_WIDTH-collider.size.first/2, old_position.second));

193    } else if (dir == Direction::right)
193    } else if (dir == Direction::right)

194    {
194    {

195      game.loadMap(game.getMap(map.getRightMapID()), std::make_pair(-collider.size.first/2, old_position.second));
195      game.loadMap(game.getWorld().getMap(map.getAdjacent(Map::MoveDir::Right).map), std::make_pair(-collider.size.first/2, old_position.second));

196    } else if (dir == Direction::up)
196    } else if (dir == Direction::up)

197    {
197    {

198      game.loadMap(game.getMap(map.getUpMapID()), std::make_pair(old_position.first, GAME_HEIGHT-collider.size.second/2));
198      game.loadMap(game.getWorld().getMap(map.getAdjacent(Map::MoveDir::Up).map), std::make_pair(old_position.first, GAME_HEIGHT-collider.size.second/2));

199    } else if (dir == Direction::down)
199    } else if (dir == Direction::down)

200    {
200    {

201      game.loadMap(game.getMap(map.getDownMapID()), std::make_pair(old_position.first, -collider.size.second/2));
201      game.loadMap(game.getWorld().getMap(map.getAdjacent(Map::MoveDir::Down).map), std::make_pair(old_position.first, -collider.size.second/2));

202    }
202    }

203  } else if (collision.type == Collision::Type::reverse)
203  } else if (collision.type == Collision::Type::reverse)

204  {
204  {
diff --git a/src/game.cpp b/src/game.cpp
index 4a08744..673c804 100644
--- a/src/game.cpp
+++ b/src/game.cpp

@@ -1,6 +1,5 @@

1#include "game.h"
1#include "game.h"

2#include <cstdlib>
2#include <cstdlib>

3#include <libxml/parser.h>


4#include "renderer.h"
3#include "renderer.h"

5#include "muxer.h"
4#include "muxer.h"

6#include "map.h"
5#include "map.h"
@@ -11,164 +10,11 @@

11#include "components/map_collision.h"
10#include "components/map_collision.h"

12#include "consts.h"
11#include "consts.h"

13
12

14Game::Game(const char* mapfile)
13Game::Game(const char* mapfile) : world(mapfile)

15{ 
14{ 

16  // Load maps


17  xmlDocPtr doc = xmlParseFile(mapfile);


18  if (doc == nullptr)


19  {


20    exit(2);


21  }


22  


23  xmlNodePtr top = xmlDocGetRootElement(doc);


24  if (top == nullptr)


25  {


26    exit(2);


27  }


28  


29  if (xmlStrcmp(top->name, (const xmlChar*) "world"))


30  {


31    exit(2);


32  }


33  


34  for (xmlNodePtr node = top->xmlChildrenNode; node != NULL; node = node->next)


35  {


36    if (!xmlStrcmp(node->name, (const xmlChar*) "startpos"))


37    {


38      xmlChar* idKey = xmlGetProp(node, (xmlChar*) "id");


39      if (idKey == 0) exit(2);


40      startMap = atoi((char*) idKey);


41      xmlFree(idKey);


42      


43      xmlChar* posKey = xmlGetProp(node, (xmlChar*) "pos");


44      if (posKey == 0) exit(2);


45      sscanf((char*) posKey, "%d,%d", &startPos.first, &startPos.second);


46      xmlFree(posKey);


47    } else if (!xmlStrcmp(node->name, (const xmlChar*) "map"))


48    {


49      xmlChar* idKey = xmlGetProp(node, (xmlChar*) "id");


50      if (idKey == 0) exit(2);


51      int theId = atoi((char*) idKey);


52      xmlFree(idKey);


53      


54      Map map {theId};


55      


56      for (xmlNodePtr mapNode = node->xmlChildrenNode; mapNode != NULL; mapNode = mapNode->next)


57      {


58        if (!xmlStrcmp(mapNode->name, (const xmlChar*) "name"))


59        {


60          xmlChar* key = xmlNodeListGetString(doc, mapNode->xmlChildrenNode, 1);


61          if (key != 0)


62          {


63            map.setTitle((char*) key);


64          }


65          


66          xmlFree(key);


67        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "environment"))


68        {


69          xmlChar* key = xmlNodeListGetString(doc, mapNode->xmlChildrenNode, 1);


70          int* mapdata = (int*) malloc(MAP_WIDTH*MAP_HEIGHT*sizeof(int));


71          mapdata[0] = atoi(strtok((char*) key, ",\n"));


72          for (int i=1; i<(MAP_WIDTH*MAP_HEIGHT); i++)


73          {


74            mapdata[i] = atoi(strtok(NULL, ",\n"));


75          }


76          map.setMapdata(mapdata);


77          xmlFree(key);


78        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "leftmap"))


79        {


80          xmlChar* typeKey = xmlGetProp(mapNode, (xmlChar*) "type");


81          if (typeKey == 0) exit(2);


82          map.setLeftMoveType(Map::moveTypeForShort((char*) typeKey));


83          xmlFree(typeKey);


84          


85          if (Map::moveTypeTakesMap(map.getLeftMoveType()))


86          {


87            xmlChar* idKey = xmlGetProp(mapNode, (xmlChar*) "map");


88            if (idKey == 0) exit(2);


89            map.setLeftMapID(atoi((char*) idKey));


90            xmlFree(idKey);


91          }


92        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "rightmap"))


93        {


94          xmlChar* typeKey = xmlGetProp(mapNode, (xmlChar*) "type");


95          if (typeKey == 0) exit(2);


96          map.setRightMoveType(Map::moveTypeForShort((char*) typeKey));


97          xmlFree(typeKey);


98          


99          if (Map::moveTypeTakesMap(map.getRightMoveType()))


100          {


101            xmlChar* idKey = xmlGetProp(mapNode, (xmlChar*) "map");


102            if (idKey == 0) exit(2);


103            map.setRightMapID(atoi((char*) idKey));


104            xmlFree(idKey);


105          }


106        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "upmap"))


107        {


108          xmlChar* typeKey = xmlGetProp(mapNode, (xmlChar*) "type");


109          if (typeKey == 0) exit(2);


110          map.setUpMoveType(Map::moveTypeForShort((char*) typeKey));


111          xmlFree(typeKey);


112          


113          if (Map::moveTypeTakesMap(map.getUpMoveType()))


114          {


115            xmlChar* idKey = xmlGetProp(mapNode, (xmlChar*) "map");


116            if (idKey == 0) exit(2);


117            map.setUpMapID(atoi((char*) idKey));


118            xmlFree(idKey);


119          }


120        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "downmap"))


121        {


122          xmlChar* typeKey = xmlGetProp(mapNode, (xmlChar*) "type");


123          if (typeKey == 0) exit(2);


124          map.setDownMoveType(Map::moveTypeForShort((char*) typeKey));


125          xmlFree(typeKey);


126          


127          if (Map::moveTypeTakesMap(map.getDownMoveType()))


128          {


129            xmlChar* idKey = xmlGetProp(mapNode, (xmlChar*) "map");


130            if (idKey == 0) exit(2);


131            map.setDownMapID(atoi((char*) idKey));


132            xmlFree(idKey);


133          }


134        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "entities"))


135        {


136          for (xmlNodePtr entityNode = mapNode->xmlChildrenNode; entityNode != NULL; entityNode = entityNode->next)


137          {


138            if (!xmlStrcmp(entityNode->name, (const xmlChar*) "entity"))


139            {


140              Map::EntityData data;


141          


142              for (xmlNodePtr entityDataNode = entityNode->xmlChildrenNode; entityDataNode != NULL; entityDataNode = entityDataNode->next)


143              {


144                if (!xmlStrcmp(entityDataNode->name, (const xmlChar*) "entity-type"))


145                {


146                  xmlChar* key = xmlNodeListGetString(doc, entityDataNode->xmlChildrenNode, 1);


147                  data.name = (char*) key;


148                  xmlFree(key);


149                } else if (!xmlStrcmp(entityDataNode->name, (const xmlChar*) "entity-position"))


150                {


151                  xmlChar* key = xmlNodeListGetString(doc, entityDataNode->xmlChildrenNode, 1);


152                  sscanf((char*) key, "%d,%d", &data.position.first, &data.position.second);


153                  xmlFree(key);


154                }


155              }


156        


157              map.addEntity(data);


158            }


159          }


160        }


161      }


162      


163      maps[theId] = map;


164    }


165  }


166  


167  xmlFreeDoc(doc);


168  


169  // Set up entities
15  // Set up entities

170  player = std::make_shared<Entity>();
16  player = std::make_shared<Entity>();

171  player->position = startPos;
17  player->position = world.getStartingPosition();

172  player->size = std::make_pair(10.0,12.0);
18  player->size = std::make_pair(10.0,12.0);

173  
19  

174  auto player_input = std::make_shared<UserMovementComponent>();
20  auto player_input = std::make_shared<UserMovementComponent>();
@@ -180,7 +26,7 @@ Game::Game(const char* mapfile)

180  auto player_anim = std::make_shared<PlayerSpriteComponent>();
26  auto player_anim = std::make_shared<PlayerSpriteComponent>();

181  player->addComponent(player_anim);
27  player->addComponent(player_anim);

182  
28  

183  Map& startingMap = maps[startMap];
29  const Map& startingMap = world.getStartingMap();

184  save = {&startingMap, player->position};
30  save = {&startingMap, player->position};

185  
31  

186  loadMap(startingMap, player->position);
32  loadMap(startingMap, player->position);
@@ -326,7 +172,7 @@ void Game::playerDie()

326  });
172  });

327}
173}

328
174

329const Map& Game::getMap(int id) const
175const World& Game::getWorld() const

330{
176{

331  return maps.at(id);
177  return world;

332}
178}
diff --git a/src/game.h b/src/game.h
index 3f0fcc8..dd4b2f7 100644
--- a/src/game.h
+++ b/src/game.h

@@ -6,6 +6,7 @@

6#include <list>
6#include <list>

7#include <map>
7#include <map>

8#include "map.h"
8#include "map.h"


9#include "world.h"

9
10

10class Entity;
11class Entity;

11struct GLFWwindow;
12struct GLFWwindow;
@@ -24,14 +25,11 @@ class Game {

24    void saveGame();
25    void saveGame();

25    void schedule(double time, std::function<void ()> callback);
26    void schedule(double time, std::function<void ()> callback);

26    void playerDie();
27    void playerDie();

27    const Map& getMap(int id) const;
28    const World& getWorld() const;

28    
29    

29  private:
30  private:

30    friend void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
31    friend void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);

31
32

32    std::map<int, Map> maps;


33    int startMap;


34    std::pair<int, int> startPos;


35    std::list<std::shared_ptr<Entity>> entities;
33    std::list<std::shared_ptr<Entity>> entities;

36    std::list<std::shared_ptr<Entity>> nextEntities;
34    std::list<std::shared_ptr<Entity>> nextEntities;

37    std::pair<double, double> nextPosition;
35    std::pair<double, double> nextPosition;
@@ -41,6 +39,7 @@ class Game {

41    Savefile save;
39    Savefile save;

42    std::list<std::pair<double, std::function<void ()>>> scheduled;
40    std::list<std::pair<double, std::function<void ()>>> scheduled;

43    bool shouldQuit = false;
41    bool shouldQuit = false;


42    World world;

44};
43};

45
44

46#endif
45#endif
diff --git a/src/map.cpp b/src/map.cpp
index fa940ef..c4f31d1 100644
--- a/src/map.cpp
+++ b/src/map.cpp

@@ -20,14 +20,7 @@ Map::Map(const Map& map)

20  
20  

21  id = map.id;
21  id = map.id;

22  title = map.title;
22  title = map.title;

23  leftMap = map.leftMap;
23  adjacents = map.adjacents;

24  rightMap = map.rightMap;


25  downMap = map.downMap;


26  upMap = map.upMap;


27  leftType = map.leftType;


28  rightType = map.rightType;


29  upType = map.upType;


30  downType = map.downType;


31  entities = map.entities;
24  entities = map.entities;

32}
25}

33
26
@@ -52,14 +45,7 @@ void swap(Map& first, Map& second)

52{
45{

53  std::swap(first.mapdata, second.mapdata);
46  std::swap(first.mapdata, second.mapdata);

54  std::swap(first.title, second.title);
47  std::swap(first.title, second.title);

55  std::swap(first.leftMap, second.leftMap);
48  std::swap(first.adjacents, second.adjacents);

56  std::swap(first.rightMap, second.rightMap);


57  std::swap(first.downMap, second.downMap);


58  std::swap(first.upMap, second.upMap);


59  std::swap(first.leftType, second.leftType);


60  std::swap(first.rightType, second.rightType);


61  std::swap(first.upType, second.upType);


62  std::swap(first.downType, second.downType);


63  std::swap(first.id, second.id);
49  std::swap(first.id, second.id);

64  std::swap(first.entities, second.entities);
50  std::swap(first.entities, second.entities);

65}
51}
@@ -109,44 +95,24 @@ Map::MoveType Map::moveTypeForShort(std::string str)

109  return MoveType::Wall;
95  return MoveType::Wall;

110}
96}

111
97

112Map::MoveType Map::getLeftMoveType() const
98Map::MoveDir Map::moveDirForShort(std::string str)

113{
99{

114  return leftType;
100  if (str == "right") return MoveDir::Right;

115}
101  if (str == "up") return MoveDir::Up;

116
102  if (str == "down") return MoveDir::Down;

117Map::MoveType Map::getRightMoveType() const
103  

118{
104  return MoveDir::Left;

119  return rightType;


120}


121


122Map::MoveType Map::getUpMoveType() const


123{


124  return upType;


125}


126


127Map::MoveType Map::getDownMoveType() const


128{


129  return downType;


130}


131


132int Map::getLeftMapID() const


133{


134  return leftMap;


135}


136


137int Map::getRightMapID() const


138{


139  return rightMap;


140}


141


142int Map::getUpMapID() const


143{


144  return upMap;


145}
105}

146
106

147int Map::getDownMapID() const
107static const Map::Adjacent defaultAdjacent {};


108const Map::Adjacent& Map::getAdjacent(MoveDir dir) const

148{
109{

149  return downMap;
110  if (adjacents.count(dir) > 0)


111  {


112    return adjacents.at(dir);


113  } else {


114    return defaultAdjacent;


115  }

150}
116}

151
117

152bool Map::moveTypeTakesMap(MoveType type)
118bool Map::moveTypeTakesMap(MoveType type)
@@ -171,44 +137,11 @@ void Map::setTitle(std::string title)

171  this->title = title;
137  this->title = title;

172}
138}

173
139

174void Map::setLeftMoveType(MoveType type)
140void Map::setAdjacent(MoveDir dir, MoveType type, int map)

175{


176  leftType = type;


177}


178


179void Map::setRightMoveType(MoveType type)


180{


181  rightType = type;


182}


183


184void Map::setUpMoveType(MoveType type)


185{


186  upType = type;


187}


188


189void Map::setDownMoveType(MoveType type)


190{


191  downType = type;


192}


193


194void Map::setLeftMapID(int id)


195{


196  leftMap = id;


197}


198


199void Map::setRightMapID(int id)


200{


201  rightMap = id;


202}


203


204void Map::setUpMapID(int id)


205{


206  upMap = id;


207}


208


209void Map::setDownMapID(int id)


210{
141{

211  downMap = id;
142  Adjacent& cur = adjacents[dir];


143  cur.type = type;


144  if (map != -1) cur.map = map;

212}
145}

213
146

214void Map::addEntity(EntityData& data)
147void Map::addEntity(EntityData& data)
diff --git a/src/map.h b/src/map.h
index 1234dbb..4e661ab 100644
--- a/src/map.h
+++ b/src/map.h

@@ -3,6 +3,7 @@

3
3

4#include <string>
4#include <string>

5#include <list>
5#include <list>


6#include <map>

6
7

7class Entity;
8class Entity;

8
9
@@ -23,25 +24,31 @@ class Map {

23      ReverseWarp
24      ReverseWarp

24    };
25    };

25    
26    


27    enum class MoveDir {


28      Left,


29      Right,


30      Up,


31      Down


32    };


33    

26    struct EntityData {
34    struct EntityData {

27      std::string name;
35      std::string name;

28      std::pair<int, int> position;
36      std::pair<int, int> position;

29    };
37    };

30    
38    


39    struct Adjacent {


40      MoveType type = MoveType::Wall;


41      int map = -1;


42    };


43    

31    static MoveType moveTypeForShort(std::string str);
44    static MoveType moveTypeForShort(std::string str);


45    static MoveDir moveDirForShort(std::string str);

32    static bool moveTypeTakesMap(MoveType type);
46    static bool moveTypeTakesMap(MoveType type);

33    
47    

34    int getID() const;
48    int getID() const;

35    const int* getMapdata() const;
49    const int* getMapdata() const;

36    std::string getTitle() const;
50    std::string getTitle() const;

37    MoveType getLeftMoveType() const;
51    const Adjacent& getAdjacent(MoveDir dir) const;

38    MoveType getRightMoveType() const;


39    MoveType getUpMoveType() const;


40    MoveType getDownMoveType() const;


41    int getLeftMapID() const;


42    int getRightMapID() const;


43    int getUpMapID() const;


44    int getDownMapID() const;


45    
52    

46    void createEntities(std::list<std::shared_ptr<Entity>>& entities) const;
53    void createEntities(std::list<std::shared_ptr<Entity>>& entities) const;

47    bool operator==(const Map& other) const;
54    bool operator==(const Map& other) const;
@@ -49,22 +56,14 @@ class Map {

49    
56    

50    void setMapdata(int* mapdata);
57    void setMapdata(int* mapdata);

51    void setTitle(std::string title);
58    void setTitle(std::string title);

52    void setLeftMoveType(MoveType type);
59    void setAdjacent(MoveDir dir, MoveType type, int map);

53    void setRightMoveType(MoveType type);


54    void setUpMoveType(MoveType type);


55    void setDownMoveType(MoveType type);


56    void setLeftMapID(int id);


57    void setRightMapID(int id);


58    void setUpMapID(int id);


59    void setDownMapID(int id);


60    void addEntity(EntityData& data);
60    void addEntity(EntityData& data);

61  private:
61  private:

62    int* mapdata;
62    int* mapdata;

63    std::string title;
63    std::string title;

64    int id;
64    int id;

65    std::list<EntityData> entities;
65    std::list<EntityData> entities;

66    MoveType leftType, rightType, upType, downType;
66    std::map<MoveDir, Adjacent> adjacents;

67    int leftMap, rightMap, upMap, downMap;


68};
67};

69
68

70#endif
69#endif
diff --git a/src/world.cpp b/src/world.cpp
new file mode 100644
index 0000000..17288fa
--- /dev/null
+++ b/src/world.cpp

@@ -0,0 +1,134 @@


1#include "world.h"


2#include <libxml/parser.h>


3#include "consts.h"


4


5World::World(const char* filename)


6{


7  xmlDocPtr doc = xmlParseFile(filename);


8  if (doc == nullptr)


9  {


10    exit(2);


11  }


12  


13  xmlNodePtr top = xmlDocGetRootElement(doc);


14  if (top == nullptr)


15  {


16    exit(2);


17  }


18  


19  if (xmlStrcmp(top->name, (const xmlChar*) "world"))


20  {


21    exit(2);


22  }


23  


24  xmlChar* startxKey = xmlGetProp(top, (xmlChar*) "startx");


25  if (startxKey == 0) exit(2);


26  startX = atoi((char*) startxKey);


27  xmlFree(startxKey);


28  


29  xmlChar* startyKey = xmlGetProp(top, (xmlChar*) "starty");


30  if (startyKey == 0) exit(2);


31  startY = atoi((char*) startyKey);


32  xmlFree(startyKey);


33  


34  xmlChar* startmapKey = xmlGetProp(top, (xmlChar*) "startmap");


35  if (startxKey == 0) exit(2);


36  startMap = atoi((char*) startmapKey);


37  xmlFree(startmapKey);


38  


39  for (xmlNodePtr node = top->xmlChildrenNode; node != NULL; node = node->next)


40  {


41    if (!xmlStrcmp(node->name, (const xmlChar*) "map"))


42    {


43      xmlChar* idKey = xmlGetProp(node, (xmlChar*) "id");


44      if (idKey == 0) exit(2);


45      int theId = atoi((char*) idKey);


46      xmlFree(idKey);


47      


48      maps.emplace(theId, theId);


49      Map& map = maps[theId];


50      


51      xmlChar* titleKey = xmlGetProp(node, (xmlChar*) "title");


52      if (titleKey == 0) exit(2);


53      map.setTitle((char*) titleKey);


54      xmlFree(titleKey);


55      


56      for (xmlNodePtr mapNode = node->xmlChildrenNode; mapNode != NULL; mapNode = mapNode->next)


57      {


58        if (!xmlStrcmp(mapNode->name, (const xmlChar*) "environment"))


59        {


60          xmlChar* key = xmlNodeListGetString(doc, mapNode->xmlChildrenNode, 1);


61          int* mapdata = (int*) malloc(MAP_WIDTH*MAP_HEIGHT*sizeof(int));


62          mapdata[0] = atoi(strtok((char*) key, ",\n"));


63          for (int i=1; i<(MAP_WIDTH*MAP_HEIGHT); i++)


64          {


65            mapdata[i] = atoi(strtok(NULL, ",\n"));


66          }


67          map.setMapdata(mapdata);


68          xmlFree(key);


69        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "entity"))


70        {


71          Map::EntityData data;


72          


73          xmlChar* typeKey = xmlGetProp(mapNode, (const xmlChar*) "type");


74          if (typeKey == 0) exit(2);


75          data.name = (char*) typeKey;


76          xmlFree(typeKey);


77          


78          xmlChar* xKey = xmlGetProp(mapNode, (const xmlChar*) "x");


79          if (xKey == 0) exit(2);


80          data.position.first = atoi((char*) xKey);


81          xmlFree(xKey);


82          


83          xmlChar* yKey = xmlGetProp(mapNode, (const xmlChar*) "y");


84          if (yKey == 0) exit(2);


85          data.position.second = atoi((char*) yKey);


86          xmlFree(yKey);


87          


88          map.addEntity(data);


89        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "adjacent"))


90        {


91          Map::MoveDir direction;


92          Map::MoveType moveType;


93          int mapId = 0;


94          


95          xmlChar* dirKey = xmlGetProp(mapNode, (const xmlChar*) "dir");


96          if (dirKey == 0) exit(2);


97          direction = Map::moveDirForShort((char*) dirKey);


98          xmlFree(dirKey);


99          


100          xmlChar* typeKey = xmlGetProp(mapNode, (const xmlChar*) "type");


101          if (typeKey == 0) exit(2);


102          moveType = Map::moveTypeForShort((char*) typeKey);


103          xmlFree(typeKey);


104          


105          xmlChar* mapIdKey = xmlGetProp(mapNode, (const xmlChar*) "map");


106          if (mapIdKey != 0)


107          {


108            mapId = atoi((char*) mapIdKey);


109          }


110          xmlFree(mapIdKey);


111          


112          map.setAdjacent(direction, moveType, mapId);


113        }


114      }


115    }


116  }


117  


118  xmlFreeDoc(doc);


119}


120


121const Map& World::getMap(int id) const


122{


123  return maps.at(id);


124}


125


126const Map& World::getStartingMap() const


127{


128  return maps.at(startMap);


129}


130


131std::pair<int, int> World::getStartingPosition() const


132{


133  return std::make_pair(startX, startY);


134}
diff --git a/src/world.h b/src/world.h
new file mode 100644
index 0000000..f566487
--- /dev/null
+++ b/src/world.h

@@ -0,0 +1,21 @@


1#ifndef WORLD_H


2#define WORLD_H


3


4#include <map>


5#include "map.h"


6


7class World {


8  public:


9    World(const char* filename);


10    const Map& getMap(int id) const;


11    const Map& getStartingMap() const;


12    std::pair<int, int> getStartingPosition() const;


13    


14  private:


15    std::map<int, Map> maps;


16    int startMap;


17    int startX;


18    int startY;


19};


20


21#endif /* end of include guard: WORLD_H */
diff --git a/tools/mapedit/src/frame.cpp b/tools/mapedit/src/frame.cpp
index cc45c29..06102f7 100644
--- a/tools/mapedit/src/frame.cpp
+++ b/tools/mapedit/src/frame.cpp

@@ -190,22 +190,22 @@ MapeditFrame::MapeditFrame(World* world) : wxFrame(NULL, wxID_ANY, "Map Editor")

190  wxStaticText* leftmapLabel = new wxStaticText(propertyEditor, wxID_ANY, "Leftmap Action:");
190  wxStaticText* leftmapLabel = new wxStaticText(propertyEditor, wxID_ANY, "Leftmap Action:");

191  wxChoice* leftmapChoice = new wxChoice(propertyEditor, LEFTMAP_TYPE_CHOICE);
191  wxChoice* leftmapChoice = new wxChoice(propertyEditor, LEFTMAP_TYPE_CHOICE);

192  wxComboCtrl* leftmapCombo = new wxComboCtrl(propertyEditor, LEFTMAP_MAP_CHOICE, "", wxDefaultPosition, wxDefaultSize, wxCB_READONLY);
192  wxComboCtrl* leftmapCombo = new wxComboCtrl(propertyEditor, LEFTMAP_MAP_CHOICE, "", wxDefaultPosition, wxDefaultSize, wxCB_READONLY);

193  leftmapCombo->SetPopupControl(new MapSelectComboPopup(mapTree, currentMap->getLeftMoveMapID()));
193  leftmapCombo->SetPopupControl(new MapSelectComboPopup(mapTree, currentMap->getAdjacent(Map::MoveDir::Left).map));

194  
194  

195  wxStaticText* rightmapLabel = new wxStaticText(propertyEditor, wxID_ANY, "Rightmap Action:");
195  wxStaticText* rightmapLabel = new wxStaticText(propertyEditor, wxID_ANY, "Rightmap Action:");

196  wxChoice* rightmapChoice = new wxChoice(propertyEditor, RIGHTMAP_TYPE_CHOICE);
196  wxChoice* rightmapChoice = new wxChoice(propertyEditor, RIGHTMAP_TYPE_CHOICE);

197  wxComboCtrl* rightmapCombo = new wxComboCtrl(propertyEditor, RIGHTMAP_MAP_CHOICE, "", wxDefaultPosition, wxDefaultSize, wxCB_READONLY);
197  wxComboCtrl* rightmapCombo = new wxComboCtrl(propertyEditor, RIGHTMAP_MAP_CHOICE, "", wxDefaultPosition, wxDefaultSize, wxCB_READONLY);

198  rightmapCombo->SetPopupControl(new MapSelectComboPopup(mapTree, currentMap->getRightMoveMapID()));
198  rightmapCombo->SetPopupControl(new MapSelectComboPopup(mapTree, currentMap->getAdjacent(Map::MoveDir::Right).map));

199  
199  

200  wxStaticText* upmapLabel = new wxStaticText(propertyEditor, wxID_ANY, "Upmap Action:");
200  wxStaticText* upmapLabel = new wxStaticText(propertyEditor, wxID_ANY, "Upmap Action:");

201  wxChoice* upmapChoice = new wxChoice(propertyEditor, UPMAP_TYPE_CHOICE);
201  wxChoice* upmapChoice = new wxChoice(propertyEditor, UPMAP_TYPE_CHOICE);

202  wxComboCtrl* upmapCombo = new wxComboCtrl(propertyEditor, UPMAP_MAP_CHOICE, "", wxDefaultPosition, wxDefaultSize, wxCB_READONLY);
202  wxComboCtrl* upmapCombo = new wxComboCtrl(propertyEditor, UPMAP_MAP_CHOICE, "", wxDefaultPosition, wxDefaultSize, wxCB_READONLY);

203  upmapCombo->SetPopupControl(new MapSelectComboPopup(mapTree, currentMap->getUpMoveMapID()));
203  upmapCombo->SetPopupControl(new MapSelectComboPopup(mapTree, currentMap->getAdjacent(Map::MoveDir::Up).map));

204  
204  

205  wxStaticText* downmapLabel = new wxStaticText(propertyEditor, wxID_ANY, "Downmap Action:");
205  wxStaticText* downmapLabel = new wxStaticText(propertyEditor, wxID_ANY, "Downmap Action:");

206  wxChoice* downmapChoice = new wxChoice(propertyEditor, DOWNMAP_TYPE_CHOICE);
206  wxChoice* downmapChoice = new wxChoice(propertyEditor, DOWNMAP_TYPE_CHOICE);

207  wxComboCtrl* downmapCombo = new wxComboCtrl(propertyEditor, DOWNMAP_MAP_CHOICE, "", wxDefaultPosition, wxDefaultSize, wxCB_READONLY);
207  wxComboCtrl* downmapCombo = new wxComboCtrl(propertyEditor, DOWNMAP_MAP_CHOICE, "", wxDefaultPosition, wxDefaultSize, wxCB_READONLY);

208  downmapCombo->SetPopupControl(new MapSelectComboPopup(mapTree, currentMap->getDownMoveMapID()));
208  downmapCombo->SetPopupControl(new MapSelectComboPopup(mapTree, currentMap->getAdjacent(Map::MoveDir::Down).map));

209  
209  

210  for (auto type : Map::listMoveTypes())
210  for (auto type : Map::listMoveTypes())

211  {
211  {
@@ -674,157 +674,169 @@ void MapeditFrame::OnThreeMovingSash(wxSplitterEvent& event)

674
674

675void MapeditFrame::OnSetLeftmapType(wxCommandEvent&)
675void MapeditFrame::OnSetLeftmapType(wxCommandEvent&)

676{
676{

677  wxChoice* leftmapChoice = (wxChoice*) wxWindow::FindWindowById(LEFTMAP_TYPE_CHOICE, this);
677  wxChoice* choice = (wxChoice*) wxWindow::FindWindowById(LEFTMAP_TYPE_CHOICE, this);

678  wxComboCtrl* leftmapCombo = (wxComboCtrl*) wxWindow::FindWindowById(LEFTMAP_MAP_CHOICE, this);
678  wxComboCtrl* combo = (wxComboCtrl*) wxChoice::FindWindowById(LEFTMAP_MAP_CHOICE, this);

679  
679  Map::MoveDir dir = Map::MoveDir::Left;

680  Map::MoveType old = currentMap->getLeftMoveType();


681  Map::MoveType newt = ((MoveTypeCtr*) leftmapChoice->GetClientData(leftmapChoice->GetSelection()))->type;


682  
680  


681  Map::Adjacent adjacent = currentMap->getAdjacent(dir);


682  Map::MoveType newt = ((MoveTypeCtr*) choice->GetClientData(choice->GetSelection()))->type;

683  commitAction(std::make_shared<Undoable>("Set Leftmap Action", [=] () {
683  commitAction(std::make_shared<Undoable>("Set Leftmap Action", [=] () {

684    leftmapChoice->SetSelection(leftmapChoice->FindString(Map::stringForMoveType(newt)));
684    choice->SetSelection(choice->FindString(Map::stringForMoveType(newt)));

685    currentMap->setLeftMoveType(newt);
685    currentMap->setAdjacent(dir, newt);

686    leftmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getLeftMoveType()));
686    combo->Enable(Map::moveTypeTakesMap(newt));

687  }, [=] () {
687  }, [=] () {

688    leftmapChoice->SetSelection(leftmapChoice->FindString(Map::stringForMoveType(old)));
688    choice->SetSelection(choice->FindString(Map::stringForMoveType(adjacent.type)));

689    currentMap->setLeftMoveType(old);
689    currentMap->setAdjacent(dir, adjacent.type);

690    leftmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getLeftMoveType()));
690    combo->Enable(Map::moveTypeTakesMap(adjacent.type));

691  }));
691  }));

692}
692}

693
693

694void MapeditFrame::OnSetLeftmapMap(wxCommandEvent&)
694void MapeditFrame::OnSetLeftmapMap(wxCommandEvent&)

695{
695{

696  wxComboCtrl* leftmapCombo = (wxComboCtrl*) wxWindow::FindWindowById(LEFTMAP_MAP_CHOICE, this);
696  wxComboCtrl* combo = (wxComboCtrl*) wxWindow::FindWindowById(LEFTMAP_MAP_CHOICE, this);

697  MapSelectComboPopup* popup = (MapSelectComboPopup*) leftmapCombo->GetPopupControl();
697  Map::MoveDir dir = Map::MoveDir::Left;

698  int old = currentMap->getLeftMoveMapID();
698  


699  Map::Adjacent adjacent = currentMap->getAdjacent(dir);


700  MapSelectComboPopup* popup = (MapSelectComboPopup*) combo->GetPopupControl();


701  int old = adjacent.map;

699  int newt = popup->GetSelectedMapID();
702  int newt = popup->GetSelectedMapID();

700  
703  

701  if (old == newt) return;
704  if (old == newt) return;

702  
705  

703  commitAction(std::make_shared<Undoable>("Set Leftmap Map", [=] () {
706  commitAction(std::make_shared<Undoable>("Set Leftmap Map", [=] () {

704    popup->SetSelectedMapID(newt);
707    popup->SetSelectedMapID(newt);

705    leftmapCombo->SetValue(world->getMap(newt)->getTitle());
708    combo->SetValue(world->getMap(newt)->getTitle());

706    currentMap->setLeftMoveMapID(newt);
709    currentMap->setAdjacent(dir, adjacent.type, newt);

707  }, [=] () {
710  }, [=] () {

708    popup->SetSelectedMapID(old);
711    popup->SetSelectedMapID(old);

709    leftmapCombo->SetValue(world->getMap(old)->getTitle());
712    combo->SetValue(world->getMap(old)->getTitle());

710    currentMap->setLeftMoveMapID(old);
713    currentMap->setAdjacent(dir, adjacent.type, old);

711  }));
714  }));

712}
715}

713
716

714void MapeditFrame::OnSetRightmapType(wxCommandEvent&)
717void MapeditFrame::OnSetRightmapType(wxCommandEvent&)

715{
718{

716  wxChoice* rightmapChoice = (wxChoice*) wxWindow::FindWindowById(RIGHTMAP_TYPE_CHOICE, this);
719  wxChoice* choice = (wxChoice*) wxWindow::FindWindowById(RIGHTMAP_TYPE_CHOICE, this);

717  wxComboCtrl* rightmapCombo = (wxComboCtrl*) wxWindow::FindWindowById(RIGHTMAP_MAP_CHOICE, this);
720  wxComboCtrl* combo = (wxComboCtrl*) wxChoice::FindWindowById(RIGHTMAP_MAP_CHOICE, this);

718  
721  Map::MoveDir dir = Map::MoveDir::Right;

719  Map::MoveType old = currentMap->getRightMoveType();


720  Map::MoveType newt = ((MoveTypeCtr*) rightmapChoice->GetClientData(rightmapChoice->GetSelection()))->type;


721  
722  


723  Map::Adjacent adjacent = currentMap->getAdjacent(dir);


724  Map::MoveType newt = ((MoveTypeCtr*) choice->GetClientData(choice->GetSelection()))->type;

722  commitAction(std::make_shared<Undoable>("Set Rightmap Action", [=] () {
725  commitAction(std::make_shared<Undoable>("Set Rightmap Action", [=] () {

723    rightmapChoice->SetSelection(rightmapChoice->FindString(Map::stringForMoveType(newt)));
726    choice->SetSelection(choice->FindString(Map::stringForMoveType(newt)));

724    currentMap->setRightMoveType(newt);
727    currentMap->setAdjacent(dir, newt);

725    rightmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getRightMoveType()));
728    combo->Enable(Map::moveTypeTakesMap(newt));

726  }, [=] () {
729  }, [=] () {

727    rightmapChoice->SetSelection(rightmapChoice->FindString(Map::stringForMoveType(old)));
730    choice->SetSelection(choice->FindString(Map::stringForMoveType(adjacent.type)));

728    currentMap->setRightMoveType(old);
731    currentMap->setAdjacent(dir, adjacent.type);

729    rightmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getRightMoveType()));
732    combo->Enable(Map::moveTypeTakesMap(adjacent.type));

730  }));
733  }));

731}
734}

732
735

733void MapeditFrame::OnSetRightmapMap(wxCommandEvent&)
736void MapeditFrame::OnSetRightmapMap(wxCommandEvent&)

734{
737{

735  wxComboCtrl* rightmapCombo = (wxComboCtrl*) wxWindow::FindWindowById(RIGHTMAP_MAP_CHOICE, this);
738  wxComboCtrl* combo = (wxComboCtrl*) wxWindow::FindWindowById(RIGHTMAP_MAP_CHOICE, this);

736  MapSelectComboPopup* popup = (MapSelectComboPopup*) rightmapCombo->GetPopupControl();
739  Map::MoveDir dir = Map::MoveDir::Right;

737  int old = currentMap->getRightMoveMapID();
740  


741  Map::Adjacent adjacent = currentMap->getAdjacent(dir);


742  MapSelectComboPopup* popup = (MapSelectComboPopup*) combo->GetPopupControl();


743  int old = adjacent.map;

738  int newt = popup->GetSelectedMapID();
744  int newt = popup->GetSelectedMapID();

739  
745  

740  if (old == newt) return;
746  if (old == newt) return;

741  
747  

742  commitAction(std::make_shared<Undoable>("Set Rightmap Map", [=] () {
748  commitAction(std::make_shared<Undoable>("Set Rightmap Map", [=] () {

743    popup->SetSelectedMapID(newt);
749    popup->SetSelectedMapID(newt);

744    rightmapCombo->SetValue(world->getMap(newt)->getTitle());
750    combo->SetValue(world->getMap(newt)->getTitle());

745    currentMap->setRightMoveMapID(newt);
751    currentMap->setAdjacent(dir, adjacent.type, newt);

746  }, [=] () {
752  }, [=] () {

747    popup->SetSelectedMapID(old);
753    popup->SetSelectedMapID(old);

748    rightmapCombo->SetValue(world->getMap(old)->getTitle());
754    combo->SetValue(world->getMap(old)->getTitle());

749    currentMap->setRightMoveMapID(old);
755    currentMap->setAdjacent(dir, adjacent.type, old);

750  }));
756  }));

751}
757}

752
758

753void MapeditFrame::OnSetUpmapType(wxCommandEvent&)
759void MapeditFrame::OnSetUpmapType(wxCommandEvent&)

754{
760{

755  wxChoice* upmapChoice = (wxChoice*) wxWindow::FindWindowById(UPMAP_TYPE_CHOICE, this);
761  wxChoice* choice = (wxChoice*) wxWindow::FindWindowById(UPMAP_TYPE_CHOICE, this);

756  wxComboCtrl* upmapCombo = (wxComboCtrl*) wxWindow::FindWindowById(UPMAP_MAP_CHOICE, this);
762  wxComboCtrl* combo = (wxComboCtrl*) wxChoice::FindWindowById(UPMAP_MAP_CHOICE, this);

757  
763  Map::MoveDir dir = Map::MoveDir::Up;

758  Map::MoveType old = currentMap->getUpMoveType();


759  Map::MoveType newt = ((MoveTypeCtr*) upmapChoice->GetClientData(upmapChoice->GetSelection()))->type;


760  
764  


765  Map::Adjacent adjacent = currentMap->getAdjacent(dir);


766  Map::MoveType newt = ((MoveTypeCtr*) choice->GetClientData(choice->GetSelection()))->type;

761  commitAction(std::make_shared<Undoable>("Set Upmap Action", [=] () {
767  commitAction(std::make_shared<Undoable>("Set Upmap Action", [=] () {

762    upmapChoice->SetSelection(upmapChoice->FindString(Map::stringForMoveType(newt)));
768    choice->SetSelection(choice->FindString(Map::stringForMoveType(newt)));

763    currentMap->setUpMoveType(newt);
769    currentMap->setAdjacent(dir, newt);

764    upmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getUpMoveType()));
770    combo->Enable(Map::moveTypeTakesMap(newt));

765  }, [=] () {
771  }, [=] () {

766    upmapChoice->SetSelection(upmapChoice->FindString(Map::stringForMoveType(old)));
772    choice->SetSelection(choice->FindString(Map::stringForMoveType(adjacent.type)));

767    currentMap->setUpMoveType(old);
773    currentMap->setAdjacent(dir, adjacent.type);

768    upmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getUpMoveType()));
774    combo->Enable(Map::moveTypeTakesMap(adjacent.type));

769  }));
775  }));

770}
776}

771
777

772void MapeditFrame::OnSetUpmapMap(wxCommandEvent&)
778void MapeditFrame::OnSetUpmapMap(wxCommandEvent&)

773{
779{

774  wxComboCtrl* upmapCombo = (wxComboCtrl*) wxWindow::FindWindowById(UPMAP_MAP_CHOICE, this);
780  wxComboCtrl* combo = (wxComboCtrl*) wxWindow::FindWindowById(UPMAP_MAP_CHOICE, this);

775  MapSelectComboPopup* popup = (MapSelectComboPopup*) upmapCombo->GetPopupControl();
781  Map::MoveDir dir = Map::MoveDir::Up;

776  int old = currentMap->getUpMoveMapID();
782  


783  Map::Adjacent adjacent = currentMap->getAdjacent(dir);


784  MapSelectComboPopup* popup = (MapSelectComboPopup*) combo->GetPopupControl();


785  int old = adjacent.map;

777  int newt = popup->GetSelectedMapID();
786  int newt = popup->GetSelectedMapID();

778  
787  

779  if (old == newt) return;
788  if (old == newt) return;

780  
789  

781  commitAction(std::make_shared<Undoable>("Set Upmap Map", [=] () {
790  commitAction(std::make_shared<Undoable>("Set Upmap Map", [=] () {

782    popup->SetSelectedMapID(newt);
791    popup->SetSelectedMapID(newt);

783    upmapCombo->SetValue(world->getMap(newt)->getTitle());
792    combo->SetValue(world->getMap(newt)->getTitle());

784    currentMap->setUpMoveMapID(newt);
793    currentMap->setAdjacent(dir, adjacent.type, newt);

785  }, [=] () {
794  }, [=] () {

786    popup->SetSelectedMapID(old);
795    popup->SetSelectedMapID(old);

787    upmapCombo->SetValue(world->getMap(old)->getTitle());
796    combo->SetValue(world->getMap(old)->getTitle());

788    currentMap->setUpMoveMapID(old);
797    currentMap->setAdjacent(dir, adjacent.type, old);

789  }));
798  }));

790}
799}

791
800

792void MapeditFrame::OnSetDownmapType(wxCommandEvent&)
801void MapeditFrame::OnSetDownmapType(wxCommandEvent&)

793{
802{

794  wxChoice* downmapChoice = (wxChoice*) wxWindow::FindWindowById(DOWNMAP_TYPE_CHOICE, this);
803  wxChoice* choice = (wxChoice*) wxWindow::FindWindowById(DOWNMAP_TYPE_CHOICE, this);

795  wxComboCtrl* downmapCombo = (wxComboCtrl*) wxWindow::FindWindowById(DOWNMAP_MAP_CHOICE, this);
804  wxComboCtrl* combo = (wxComboCtrl*) wxChoice::FindWindowById(DOWNMAP_MAP_CHOICE, this);

796  
805  Map::MoveDir dir = Map::MoveDir::Down;

797  Map::MoveType old = currentMap->getDownMoveType();


798  Map::MoveType newt = ((MoveTypeCtr*) downmapChoice->GetClientData(downmapChoice->GetSelection()))->type;


799  
806  


807  Map::Adjacent adjacent = currentMap->getAdjacent(dir);


808  Map::MoveType newt = ((MoveTypeCtr*) choice->GetClientData(choice->GetSelection()))->type;

800  commitAction(std::make_shared<Undoable>("Set Downmap Action", [=] () {
809  commitAction(std::make_shared<Undoable>("Set Downmap Action", [=] () {

801    downmapChoice->SetSelection(downmapChoice->FindString(Map::stringForMoveType(newt)));
810    choice->SetSelection(choice->FindString(Map::stringForMoveType(newt)));

802    currentMap->setDownMoveType(newt);
811    currentMap->setAdjacent(dir, newt);

803    downmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getDownMoveType()));
812    combo->Enable(Map::moveTypeTakesMap(newt));

804  }, [=] () {
813  }, [=] () {

805    downmapChoice->SetSelection(downmapChoice->FindString(Map::stringForMoveType(old)));
814    choice->SetSelection(choice->FindString(Map::stringForMoveType(adjacent.type)));

806    currentMap->setDownMoveType(old);
815    currentMap->setAdjacent(dir, adjacent.type);

807    downmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getDownMoveType()));
816    combo->Enable(Map::moveTypeTakesMap(adjacent.type));

808  }));
817  }));

809}
818}

810
819

811void MapeditFrame::OnSetDownmapMap(wxCommandEvent&)
820void MapeditFrame::OnSetDownmapMap(wxCommandEvent&)

812{
821{

813  wxComboCtrl* downmapCombo = (wxComboCtrl*) wxWindow::FindWindowById(DOWNMAP_MAP_CHOICE, this);
822  wxComboCtrl* combo = (wxComboCtrl*) wxWindow::FindWindowById(DOWNMAP_MAP_CHOICE, this);

814  MapSelectComboPopup* popup = (MapSelectComboPopup*) downmapCombo->GetPopupControl();
823  Map::MoveDir dir = Map::MoveDir::Down;

815  int old = currentMap->getDownMoveMapID();
824  


825  Map::Adjacent adjacent = currentMap->getAdjacent(dir);


826  MapSelectComboPopup* popup = (MapSelectComboPopup*) combo->GetPopupControl();


827  int old = adjacent.map;

816  int newt = popup->GetSelectedMapID();
828  int newt = popup->GetSelectedMapID();

817  
829  

818  if (old == newt) return;
830  if (old == newt) return;

819  
831  

820  commitAction(std::make_shared<Undoable>("Set Downmap Map", [=] () {
832  commitAction(std::make_shared<Undoable>("Set Downmap Map", [=] () {

821    popup->SetSelectedMapID(newt);
833    popup->SetSelectedMapID(newt);

822    downmapCombo->SetValue(world->getMap(newt)->getTitle());
834    combo->SetValue(world->getMap(newt)->getTitle());

823    currentMap->setDownMoveMapID(newt);
835    currentMap->setAdjacent(dir, adjacent.type, newt);

824  }, [=] () {
836  }, [=] () {

825    popup->SetSelectedMapID(old);
837    popup->SetSelectedMapID(old);

826    downmapCombo->SetValue(world->getMap(old)->getTitle());
838    combo->SetValue(world->getMap(old)->getTitle());

827    currentMap->setDownMoveMapID(old);
839    currentMap->setAdjacent(dir, adjacent.type, old);

828  }));
840  }));

829}
841}

830
842
@@ -924,20 +936,20 @@ void MapeditFrame::SelectMap(Map* map)

924  wxComboCtrl* upmapCombo = (wxComboCtrl*) wxWindow::FindWindowById(UPMAP_MAP_CHOICE, this);
936  wxComboCtrl* upmapCombo = (wxComboCtrl*) wxWindow::FindWindowById(UPMAP_MAP_CHOICE, this);

925  wxComboCtrl* downmapCombo = (wxComboCtrl*) wxWindow::FindWindowById(DOWNMAP_MAP_CHOICE, this);
937  wxComboCtrl* downmapCombo = (wxComboCtrl*) wxWindow::FindWindowById(DOWNMAP_MAP_CHOICE, this);

926  
938  

927  leftmapChoice->SetSelection(leftmapChoice->FindString(Map::stringForMoveType(currentMap->getLeftMoveType())));
939  leftmapChoice->SetSelection(leftmapChoice->FindString(Map::stringForMoveType(currentMap->getAdjacent(Map::MoveDir::Left).type)));

928  rightmapChoice->SetSelection(rightmapChoice->FindString(Map::stringForMoveType(currentMap->getRightMoveType())));
940  rightmapChoice->SetSelection(rightmapChoice->FindString(Map::stringForMoveType(currentMap->getAdjacent(Map::MoveDir::Right).type)));

929  upmapChoice->SetSelection(upmapChoice->FindString(Map::stringForMoveType(currentMap->getUpMoveType())));
941  upmapChoice->SetSelection(upmapChoice->FindString(Map::stringForMoveType(currentMap->getAdjacent(Map::MoveDir::Up).type)));

930  downmapChoice->SetSelection(downmapChoice->FindString(Map::stringForMoveType(currentMap->getDownMoveType())));
942  downmapChoice->SetSelection(downmapChoice->FindString(Map::stringForMoveType(currentMap->getAdjacent(Map::MoveDir::Down).type)));

931  
943  

932  leftmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getLeftMoveType()));
944  leftmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getAdjacent(Map::MoveDir::Left).type));

933  rightmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getRightMoveType()));
945  rightmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getAdjacent(Map::MoveDir::Right).type));

934  upmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getUpMoveType()));
946  upmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getAdjacent(Map::MoveDir::Up).type));

935  downmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getDownMoveType()));
947  downmapCombo->Enable(Map::moveTypeTakesMap(currentMap->getAdjacent(Map::MoveDir::Down).type));

936  
948  

937  leftmapCombo->SetValue(world->getMap(currentMap->getLeftMoveMapID())->getTitle());
949  leftmapCombo->SetValue(world->getMap(currentMap->getAdjacent(Map::MoveDir::Left).map)->getTitle());

938  rightmapCombo->SetValue(world->getMap(currentMap->getRightMoveMapID())->getTitle());
950  rightmapCombo->SetValue(world->getMap(currentMap->getAdjacent(Map::MoveDir::Right).map)->getTitle());

939  upmapCombo->SetValue(world->getMap(currentMap->getUpMoveMapID())->getTitle());
951  upmapCombo->SetValue(world->getMap(currentMap->getAdjacent(Map::MoveDir::Up).map)->getTitle());

940  downmapCombo->SetValue(world->getMap(currentMap->getDownMoveMapID())->getTitle());
952  downmapCombo->SetValue(world->getMap(currentMap->getAdjacent(Map::MoveDir::Down).map)->getTitle());

941}
953}

942
954

943wxTreeItemId MapeditFrame::MoveTreeNode(wxTreeItemId toCopy, wxTreeItemId newParent)
955wxTreeItemId MapeditFrame::MoveTreeNode(wxTreeItemId toCopy, wxTreeItemId newParent)
diff --git a/tools/mapedit/src/map.cpp b/tools/mapedit/src/map.cpp
index fb675e8..a099e29 100644
--- a/tools/mapedit/src/map.cpp
+++ b/tools/mapedit/src/map.cpp

@@ -21,14 +21,7 @@ Map::Map(const Map& map)

21  treeItemId = map.treeItemId;
21  treeItemId = map.treeItemId;

22  children = map.children;
22  children = map.children;

23  hidden = map.hidden;
23  hidden = map.hidden;

24  leftType = map.leftType;
24  adjacents = map.adjacents;

25  rightType = map.rightType;


26  upType = map.upType;


27  downType = map.downType;


28  leftMap = map.leftMap;


29  rightMap = map.rightMap;


30  downMap = map.downMap;


31  upMap = map.upMap;


32}
25}

33
26

34Map::Map(Map&& map) : Map(-1, map.world)
27Map::Map(Map&& map) : Map(-1, map.world)
@@ -58,14 +51,7 @@ void swap(Map& first, Map& second)

58  std::swap(first.treeItemId, second.treeItemId);
51  std::swap(first.treeItemId, second.treeItemId);

59  std::swap(first.children, second.children);
52  std::swap(first.children, second.children);

60  std::swap(first.hidden, second.hidden);
53  std::swap(first.hidden, second.hidden);

61  std::swap(first.leftType, second.leftType);
54  std::swap(first.adjacents, second.adjacents);

62  std::swap(first.rightType, second.rightType);


63  std::swap(first.upType, second.upType);


64  std::swap(first.downType, second.downType);


65  std::swap(first.leftMap, second.leftMap);


66  std::swap(first.rightMap, second.rightMap);


67  std::swap(first.downMap, second.downMap);


68  std::swap(first.upMap, second.upMap);


69}
55}

70
56

71std::list<Map::MoveType> Map::listMoveTypes()
57std::list<Map::MoveType> Map::listMoveTypes()
@@ -78,9 +64,9 @@ std::string Map::stringForMoveType(MoveType type)

78  switch (type)
64  switch (type)

79  {
65  {

80    case MoveType::Wall: return "Wall";
66    case MoveType::Wall: return "Wall";

81    case MoveType::Warp: return "Warp";
67    case MoveType::Warp: return "Teleport";

82    case MoveType::Wrap: return "Wrap";
68    case MoveType::Wrap: return "Wrap";

83    case MoveType::ReverseWarp: return "Reverse Warp";
69    case MoveType::ReverseWarp: return "Reverse Teleport";

84  }
70  }

85}
71}

86
72
@@ -106,6 +92,17 @@ std::string Map::shortForMoveType(MoveType type)

106  }
92  }

107}
93}

108
94


95std::string Map::shortForMoveDir(MoveDir dir)


96{


97  switch (dir)


98  {


99    case MoveDir::Left: return "left";


100    case MoveDir::Right: return "right";


101    case MoveDir::Up: return "up";


102    case MoveDir::Down: return "down";


103  }


104}


105

109Map::MoveType Map::moveTypeForShort(std::string str)
106Map::MoveType Map::moveTypeForShort(std::string str)

110{
107{

111  if (str == "wrap") return MoveType::Wrap;
108  if (str == "wrap") return MoveType::Wrap;
@@ -115,6 +112,15 @@ Map::MoveType Map::moveTypeForShort(std::string str)

115  return MoveType::Wall;
112  return MoveType::Wall;

116}
113}

117
114


115Map::MoveDir Map::moveDirForShort(std::string str)


116{


117  if (str == "right") return MoveDir::Right;


118  if (str == "up") return MoveDir::Up;


119  if (str == "down") return MoveDir::Down;


120  


121  return MoveDir::Left;


122}


123

118int Map::getID() const
124int Map::getID() const

119{
125{

120  return id;
126  return id;
@@ -167,47 +173,21 @@ bool Map::getHidden() const

167  return hidden;
173  return hidden;

168}
174}

169
175

170Map::MoveType Map::getLeftMoveType() const
176const std::map<Map::MoveDir, Map::Adjacent>& Map::getAdjacents() const

171{


172  return leftType;


173}


174


175Map::MoveType Map::getRightMoveType() const


176{


177  return rightType;


178}


179


180Map::MoveType Map::getUpMoveType() const


181{
177{

182  return upType;
178  return adjacents;

183}
179}

184
180

185Map::MoveType Map::getDownMoveType() const
181const Map::Adjacent& Map::getAdjacent(MoveDir direction) const

186{
182{

187  return downType;
183  if (adjacents.count(direction) > 0)

188}
184  {

189
185    return adjacents.at(direction);

190int Map::getLeftMoveMapID() const
186  } else {

191{
187    return defaultAdjacent;

192  return leftMap;
188  }

193}


194


195int Map::getRightMoveMapID() const


196{


197  return rightMap;


198}


199


200int Map::getUpMoveMapID() const


201{


202  return upMap;


203}


204


205int Map::getDownMoveMapID() const


206{


207  return downMap;


208}
189}

209
190

210


211void Map::setTitle(std::string title, bool dirty)
191void Map::setTitle(std::string title, bool dirty)

212{
192{

213  this->title = title;
193  this->title = title;
@@ -279,79 +259,11 @@ void Map::setHidden(bool hid)

279  hidden = hid;
259  hidden = hid;

280}
260}

281
261

282void Map::setLeftMoveType(Map::MoveType move, bool dirty)
262void Map::setAdjacent(MoveDir direction, MoveType type, int map, bool dirty)

283{


284  leftType = move;


285  


286  if (dirty)


287  {


288    world->setDirty(true);


289  }


290}


291


292void Map::setRightMoveType(Map::MoveType move, bool dirty)


293{


294  rightType = move;


295  


296  if (dirty)


297  {


298    world->setDirty(true);


299  }


300}


301


302void Map::setUpMoveType(Map::MoveType move, bool dirty)


303{


304  upType = move;


305  


306  if (dirty)


307  {


308    world->setDirty(true);


309  }


310}


311


312void Map::setDownMoveType(Map::MoveType move, bool dirty)


313{


314  downType = move;


315  


316  if (dirty)


317  {


318    world->setDirty(true);


319  }


320}


321


322void Map::setLeftMoveMapID(int id, bool dirty)


323{


324  leftMap = id;


325  


326  if (dirty)


327  {


328    world->setDirty(true);


329  }


330}


331


332void Map::setRightMoveMapID(int id, bool dirty)


333{


334  rightMap = id;


335  


336  if (dirty)


337  {


338    world->setDirty(true);


339  }


340}


341


342void Map::setUpMoveMapID(int id, bool dirty)


343{


344  upMap = id;


345  


346  if (dirty)


347  {


348    world->setDirty(true);


349  }


350}


351


352void Map::setDownMoveMapID(int id, bool dirty)


353{
263{

354  downMap = id;
264  Adjacent& cur = adjacents[direction];


265  cur.type = type;


266  if (map != -1) cur.map = map;

355  
267  

356  if (dirty)
268  if (dirty)

357  {
269  {
diff --git a/tools/mapedit/src/map.h b/tools/mapedit/src/map.h
index 46e5790..c7f5b30 100644
--- a/tools/mapedit/src/map.h
+++ b/tools/mapedit/src/map.h

@@ -7,6 +7,7 @@

7#include <list>
7#include <list>

8#include <memory>
8#include <memory>

9#include <wx/treectrl.h>
9#include <wx/treectrl.h>


10#include <map>

10
11

11class MapObject;
12class MapObject;

12class World;
13class World;
@@ -64,6 +65,13 @@ class Map {

64    Map& operator= (Map other);
65    Map& operator= (Map other);

65    friend void swap(Map& first, Map& second);
66    friend void swap(Map& first, Map& second);

66    
67    


68    enum class MoveDir {


69      Left,


70      Right,


71      Up,


72      Down


73    };


74    

67    enum class MoveType {
75    enum class MoveType {

68      Wall,
76      Wall,

69      Wrap,
77      Wrap,
@@ -71,11 +79,18 @@ class Map {

71      ReverseWarp
79      ReverseWarp

72    };
80    };

73    
81    


82    struct Adjacent {


83      MoveType type = MoveType::Wall;


84      int map = 0;


85    };


86    

74    static std::list<MoveType> listMoveTypes();
87    static std::list<MoveType> listMoveTypes();

75    static std::string stringForMoveType(MoveType type);
88    static std::string stringForMoveType(MoveType type);

76    static bool moveTypeTakesMap(MoveType type);
89    static bool moveTypeTakesMap(MoveType type);

77    static std::string shortForMoveType(MoveType type);
90    static std::string shortForMoveType(MoveType type);


91    static std::string shortForMoveDir(MoveDir dir);

78    static MoveType moveTypeForShort(std::string str);
92    static MoveType moveTypeForShort(std::string str);


93    static MoveDir moveDirForShort(std::string str);

79    
94    

80    int getID() const;
95    int getID() const;

81    std::string getTitle() const;
96    std::string getTitle() const;
@@ -86,14 +101,8 @@ class Map {

86    bool getExpanded() const;
101    bool getExpanded() const;

87    World* getWorld() const;
102    World* getWorld() const;

88    bool getHidden() const;
103    bool getHidden() const;

89    MoveType getLeftMoveType() const;
104    const std::map<MoveDir, Adjacent>& getAdjacents() const;

90    MoveType getRightMoveType() const;
105    const Adjacent& getAdjacent(MoveDir direction) const;

91    MoveType getUpMoveType() const;


92    MoveType getDownMoveType() const;


93    int getLeftMoveMapID() const;


94    int getRightMoveMapID() const;


95    int getUpMoveMapID() const;


96    int getDownMoveMapID() const;


97    
106    

98    void setTitle(std::string title, bool dirty = true);
107    void setTitle(std::string title, bool dirty = true);

99    void setTileAt(int x, int y, int tile, bool dirty = true);
108    void setTileAt(int x, int y, int tile, bool dirty = true);
@@ -104,14 +113,7 @@ class Map {

104    void addChild(int id);
113    void addChild(int id);

105    void setExpanded(bool exp);
114    void setExpanded(bool exp);

106    void setHidden(bool hid);
115    void setHidden(bool hid);

107    void setLeftMoveType(MoveType move, bool dirty = true);
116    void setAdjacent(MoveDir direction, MoveType type, int map = -1, bool dirty = true);

108    void setRightMoveType(MoveType move, bool dirty = true);


109    void setUpMoveType(MoveType move, bool dirty = true);


110    void setDownMoveType(MoveType move, bool dirty = true);


111    void setLeftMoveMapID(int id, bool dirty = true);


112    void setRightMoveMapID(int id, bool dirty = true);


113    void setUpMoveMapID(int id, bool dirty = true);


114    void setDownMoveMapID(int id, bool dirty = true);


115    
117    

116  private:
118  private:

117    int id;
119    int id;
@@ -123,14 +125,8 @@ class Map {

123    wxTreeItemId treeItemId;
125    wxTreeItemId treeItemId;

124    bool expanded = false;
126    bool expanded = false;

125    bool hidden = false;
127    bool hidden = false;

126    MoveType leftType = MoveType::Wall;
128    std::map<MoveDir, Adjacent> adjacents;

127    MoveType rightType = MoveType::Wall;
129    const Adjacent defaultAdjacent {};

128    MoveType upType = MoveType::Wall;


129    MoveType downType = MoveType::Wall;


130    int leftMap = 0;


131    int rightMap = 0;


132    int upMap = 0;


133    int downMap = 0;


134};
130};

135
131

136class MapPtrCtr : public wxTreeItemData {
132class MapPtrCtr : public wxTreeItemData {
diff --git a/tools/mapedit/src/widget.cpp b/tools/mapedit/src/widget.cpp
index 7f90880..fa0af39 100644
--- a/tools/mapedit/src/widget.cpp
+++ b/tools/mapedit/src/widget.cpp

@@ -75,30 +75,30 @@ void MapeditWidget::OnPaint(wxPaintEvent&)

75
75

76  RenderMap(map, dc, tiles_dc);
76  RenderMap(map, dc, tiles_dc);

77  
77  

78  if (map->getLeftMoveType() == Map::MoveType::Warp)
78  if (map->getAdjacent(Map::MoveDir::Left).type == Map::MoveType::Warp)

79  {
79  {

80    auto tomap = map->getWorld()->getMap(map->getLeftMoveMapID());
80    auto tomap = map->getWorld()->getMap(map->getAdjacent(Map::MoveDir::Left).map);

81    
81    

82    RenderMap(tomap.get(), dc, tiles_dc, -EDITOR_SPACING_X, EDITOR_SPACING_Y, false);
82    RenderMap(tomap.get(), dc, tiles_dc, -EDITOR_SPACING_X, EDITOR_SPACING_Y, false);

83  }
83  }

84  
84  

85  if (map->getRightMoveType() == Map::MoveType::Warp)
85  if (map->getAdjacent(Map::MoveDir::Right).type == Map::MoveType::Warp)

86  {
86  {

87    auto tomap = map->getWorld()->getMap(map->getRightMoveMapID());
87    auto tomap = map->getWorld()->getMap(map->getAdjacent(Map::MoveDir::Right).map);

88    
88    

89    RenderMap(tomap.get(), dc, tiles_dc, EDITOR_WIDTH-EDITOR_SPACING_X, EDITOR_SPACING_Y, false);
89    RenderMap(tomap.get(), dc, tiles_dc, EDITOR_WIDTH-EDITOR_SPACING_X, EDITOR_SPACING_Y, false);

90  }
90  }

91  
91  

92  if (map->getUpMoveType() == Map::MoveType::Warp)
92  if (map->getAdjacent(Map::MoveDir::Up).type == Map::MoveType::Warp)

93  {
93  {

94    auto tomap = map->getWorld()->getMap(map->getUpMoveMapID());
94    auto tomap = map->getWorld()->getMap(map->getAdjacent(Map::MoveDir::Up).map);

95    
95    

96    RenderMap(tomap.get(), dc, tiles_dc, EDITOR_SPACING_X, -EDITOR_SPACING_Y, false);
96    RenderMap(tomap.get(), dc, tiles_dc, EDITOR_SPACING_X, -EDITOR_SPACING_Y, false);

97  }
97  }

98  
98  

99  if (map->getDownMoveType() == Map::MoveType::Warp)
99  if (map->getAdjacent(Map::MoveDir::Down).type == Map::MoveType::Warp)

100  {
100  {

101    auto tomap = map->getWorld()->getMap(map->getDownMoveMapID());
101    auto tomap = map->getWorld()->getMap(map->getAdjacent(Map::MoveDir::Down).map);

102    
102    

103    RenderMap(tomap.get(), dc, tiles_dc, EDITOR_SPACING_X, EDITOR_HEIGHT-EDITOR_SPACING_Y, false);
103    RenderMap(tomap.get(), dc, tiles_dc, EDITOR_SPACING_X, EDITOR_HEIGHT-EDITOR_SPACING_Y, false);

104  }
104  }
diff --git a/tools/mapedit/src/world.cpp b/tools/mapedit/src/world.cpp
index 043cf8a..01225cf 100644
--- a/tools/mapedit/src/world.cpp
+++ b/tools/mapedit/src/world.cpp

@@ -36,43 +36,43 @@ World::World(std::string filename)

36    throw MapLoadException(filename);
36    throw MapLoadException(filename);

37  }
37  }

38  
38  


39  xmlChar* nextmapKey = xmlGetProp(top, (xmlChar*) "nextmap");


40  if (nextmapKey != 0)


41  {


42    nextMapID = atoi((char*) nextmapKey);


43  }


44  xmlFree(nextmapKey);


45  


46  xmlChar* lastmapKey = xmlGetProp(top, (xmlChar*) "lastmap");


47  if (lastmapKey != 0)


48  {


49    lastmap = atoi((char*) lastmapKey);


50  }


51  xmlFree(lastmapKey);


52  


53  xmlChar* startxKey = xmlGetProp(top, (xmlChar*) "startx");


54  if (startxKey == 0) throw MapLoadException(filename);


55  startingPosition.first = atoi((char*) startxKey);


56  xmlFree(startxKey);


57  


58  xmlChar* startyKey = xmlGetProp(top, (xmlChar*) "starty");


59  if (startyKey == 0) throw MapLoadException(filename);


60  startingPosition.second = atoi((char*) startyKey);


61  xmlFree(startyKey);


62  


63  xmlChar* startmapKey = xmlGetProp(top, (xmlChar*) "startmap");


64  if (startxKey == 0) throw MapLoadException(filename);


65  startingMap = atoi((char*) startmapKey);


66  xmlFree(startmapKey);


67  

39  for (xmlNodePtr node = top->xmlChildrenNode; node != NULL; node = node->next)
68  for (xmlNodePtr node = top->xmlChildrenNode; node != NULL; node = node->next)

40  {
69  {

41    if (!xmlStrcmp(node->name, (const xmlChar*) "nextmapid"))
70    if (!xmlStrcmp(node->name, (const xmlChar*) "root"))

42    {


43      xmlChar* key = xmlNodeListGetString(doc, node->xmlChildrenNode, 1);


44      if (key != 0)


45      {


46        nextMapID = atoi((char*) key);


47      }


48      xmlFree(key);


49    } else if (!xmlStrcmp(node->name, (const xmlChar*) "lastmap"))


50    {
71    {

51      xmlChar* key = xmlNodeListGetString(doc, node->xmlChildrenNode, 1);
72      xmlChar* key = xmlNodeListGetString(doc, node->xmlChildrenNode, 1);

52      if (key != 0)
73      if (key == 0) throw MapLoadException(filename);

53      {
74      rootChildren.push_back(atoi((char*) key));

54        lastmap = atoi((char*) key);


55      }


56      xmlFree(key);
75      xmlFree(key);

57    } else if (!xmlStrcmp(node->name, (const xmlChar*) "root"))


58    {


59      xmlChar* key = xmlNodeListGetString(doc, node->xmlChildrenNode, 1);


60      if (key != 0)


61      {


62        rootChildren.push_back(atoi((char*) key));


63      }


64      xmlFree(key);


65    } else if (!xmlStrcmp(node->name, (const xmlChar*) "startpos"))


66    {


67      xmlChar* idKey = xmlGetProp(node, (xmlChar*) "id");


68      if (idKey == 0) throw MapLoadException(filename);


69      startingMap = atoi((char*) idKey);


70      xmlFree(idKey);


71      


72      xmlChar* posKey = xmlGetProp(node, (xmlChar*) "pos");


73      if (posKey == 0) throw MapLoadException(filename);


74      sscanf((char*) posKey, "%d,%d", &startingPosition.first, &startingPosition.second);


75      xmlFree(posKey);


76    } else if (!xmlStrcmp(node->name, (const xmlChar*) "map"))
76    } else if (!xmlStrcmp(node->name, (const xmlChar*) "map"))

77    {
77    {

78      xmlChar* idKey = xmlGetProp(node, (xmlChar*) "id");
78      xmlChar* idKey = xmlGetProp(node, (xmlChar*) "id");
@@ -82,18 +82,21 @@ World::World(std::string filename)

82      
82      

83      auto map = std::make_shared<Map>(id, this);
83      auto map = std::make_shared<Map>(id, this);

84      
84      


85      xmlChar* expandKey = xmlGetProp(node, (xmlChar*) "expanded");


86      if ((expandKey != 0) && (!xmlStrcmp(expandKey, (const xmlChar*) "true")))


87      {


88        map->setExpanded(true);


89      }


90      xmlFree(expandKey);


91      


92      xmlChar* titleKey = xmlGetProp(node, (xmlChar*) "title");


93      if (titleKey == 0) throw MapLoadException(filename);


94      map->setTitle((char*) titleKey, false);


95      xmlFree(titleKey);


96      

85      for (xmlNodePtr mapNode = node->xmlChildrenNode; mapNode != NULL; mapNode = mapNode->next)
97      for (xmlNodePtr mapNode = node->xmlChildrenNode; mapNode != NULL; mapNode = mapNode->next)

86      {
98      {

87        if (!xmlStrcmp(mapNode->name, (const xmlChar*) "name"))
99        if (!xmlStrcmp(mapNode->name, (const xmlChar*) "environment"))

88        {


89          xmlChar* key = xmlNodeListGetString(doc, mapNode->xmlChildrenNode, 1);


90          if (key != 0)


91          {


92            map->setTitle((char*) key, false);


93          }


94          


95          xmlFree(key);


96        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "environment"))


97        {
100        {

98          xmlChar* key = xmlNodeListGetString(doc, mapNode->xmlChildrenNode, 1);
101          xmlChar* key = xmlNodeListGetString(doc, mapNode->xmlChildrenNode, 1);

99          int* mapdata = (int*) malloc(MAP_WIDTH*MAP_HEIGHT*sizeof(int));
102          int* mapdata = (int*) malloc(MAP_WIDTH*MAP_HEIGHT*sizeof(int));
@@ -104,88 +107,50 @@ World::World(std::string filename)

104          }
107          }

105          map->setMapdata(mapdata, false);
108          map->setMapdata(mapdata, false);

106          xmlFree(key);
109          xmlFree(key);

107        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "leftmap"))
110        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "entity"))

108        {
111        {

109          xmlChar* typeKey = xmlGetProp(mapNode, (xmlChar*) "type");
112          auto data = std::make_shared<MapObjectEntry>();

110          if (typeKey == 0) throw MapLoadException(filename);


111          map->setLeftMoveType(Map::moveTypeForShort((char*) typeKey), false);


112          xmlFree(typeKey);


113          
113          

114          if (Map::moveTypeTakesMap(map->getLeftMoveType()))
114          xmlChar* typeKey = xmlGetProp(mapNode, (const xmlChar*) "type");

115          {


116            xmlChar* idKey = xmlGetProp(mapNode, (xmlChar*) "map");


117            if (idKey == 0) throw MapLoadException(filename);


118            map->setLeftMoveMapID(atoi((char*) idKey), false);


119            xmlFree(idKey);


120          }


121        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "rightmap"))


122        {


123          xmlChar* typeKey = xmlGetProp(mapNode, (xmlChar*) "type");


124          if (typeKey == 0) throw MapLoadException(filename);
115          if (typeKey == 0) throw MapLoadException(filename);

125          map->setRightMoveType(Map::moveTypeForShort((char*) typeKey), false);
116          data->object = MapObject::getAllObjects().at((char*) typeKey).get();

126          xmlFree(typeKey);
117          xmlFree(typeKey);

127          
118          

128          if (Map::moveTypeTakesMap(map->getRightMoveType()))
119          xmlChar* xKey = xmlGetProp(mapNode, (const xmlChar*) "x");

129          {
120          if (xKey == 0) throw MapLoadException(filename);

130            xmlChar* idKey = xmlGetProp(mapNode, (xmlChar*) "map");
121          data->position.first = atoi((char*) xKey);

131            if (idKey == 0) throw MapLoadException(filename);
122          xmlFree(xKey);

132            map->setRightMoveMapID(atoi((char*) idKey), false);


133            xmlFree(idKey);


134          }


135        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "upmap"))


136        {


137          xmlChar* typeKey = xmlGetProp(mapNode, (xmlChar*) "type");


138          if (typeKey == 0) throw MapLoadException(filename);


139          map->setUpMoveType(Map::moveTypeForShort((char*) typeKey), false);


140          xmlFree(typeKey);


141          
123          

142          if (Map::moveTypeTakesMap(map->getUpMoveType()))
124          xmlChar* yKey = xmlGetProp(mapNode, (const xmlChar*) "y");

143          {
125          if (yKey == 0) throw MapLoadException(filename);

144            xmlChar* idKey = xmlGetProp(mapNode, (xmlChar*) "map");
126          data->position.second = atoi((char*) yKey);

145            if (idKey == 0) throw MapLoadException(filename);
127          xmlFree(yKey);

146            map->setUpMoveMapID(atoi((char*) idKey), false);
128          

147            xmlFree(idKey);
129          map->addObject(data, false);

148          }
130        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "adjacent"))

149        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "downmap"))


150        {
131        {

151          xmlChar* typeKey = xmlGetProp(mapNode, (xmlChar*) "type");
132          Map::MoveDir direction;


133          Map::MoveType moveType;


134          int mapId = 0;


135          


136          xmlChar* dirKey = xmlGetProp(mapNode, (const xmlChar*) "dir");


137          if (dirKey == 0) throw MapLoadException(filename);


138          direction = Map::moveDirForShort((char*) dirKey);


139          xmlFree(dirKey);


140          


141          xmlChar* typeKey = xmlGetProp(mapNode, (const xmlChar*) "type");

152          if (typeKey == 0) throw MapLoadException(filename);
142          if (typeKey == 0) throw MapLoadException(filename);

153          map->setDownMoveType(Map::moveTypeForShort((char*) typeKey), false);
143          moveType = Map::moveTypeForShort((char*) typeKey);

154          xmlFree(typeKey);
144          xmlFree(typeKey);

155          
145          

156          if (Map::moveTypeTakesMap(map->getDownMoveType()))
146          xmlChar* mapIdKey = xmlGetProp(mapNode, (const xmlChar*) "map");


147          if (mapIdKey != 0)

157          {
148          {

158            xmlChar* idKey = xmlGetProp(mapNode, (xmlChar*) "map");
149            mapId = atoi((char*) mapIdKey);

159            if (idKey == 0) throw MapLoadException(filename);


160            map->setDownMoveMapID(atoi((char*) idKey), false);


161            xmlFree(idKey);


162          }
150          }

163        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "entities"))
151          xmlFree(mapIdKey);

164        {


165          for (xmlNodePtr entityNode = mapNode->xmlChildrenNode; entityNode != NULL; entityNode = entityNode->next)


166          {


167            if (!xmlStrcmp(entityNode->name, (const xmlChar*) "entity"))


168            {


169              auto data = std::make_shared<MapObjectEntry>();


170          
152          

171              for (xmlNodePtr entityDataNode = entityNode->xmlChildrenNode; entityDataNode != NULL; entityDataNode = entityDataNode->next)
153          map->setAdjacent(direction, moveType, mapId, false);

172              {


173                if (!xmlStrcmp(entityDataNode->name, (const xmlChar*) "entity-type"))


174                {


175                  xmlChar* key = xmlNodeListGetString(doc, entityDataNode->xmlChildrenNode, 1);


176                  data->object = MapObject::getAllObjects().at((char*) key).get();


177                  xmlFree(key);


178                } else if (!xmlStrcmp(entityDataNode->name, (const xmlChar*) "entity-position"))


179                {


180                  xmlChar* key = xmlNodeListGetString(doc, entityDataNode->xmlChildrenNode, 1);


181                  sscanf((char*) key, "%d,%d", &data->position.first, &data->position.second);


182                  xmlFree(key);


183                }


184              }


185        


186              map->addObject(data, false);


187            }


188          }


189        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "child"))
154        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "child"))

190        {
155        {

191          xmlChar* key = xmlNodeListGetString(doc, mapNode->xmlChildrenNode, 1);
156          xmlChar* key = xmlNodeListGetString(doc, mapNode->xmlChildrenNode, 1);
@@ -194,13 +159,6 @@ World::World(std::string filename)

194            map->addChild(atoi((char*) key));
159            map->addChild(atoi((char*) key));

195          }
160          }

196          xmlFree(key);
161          xmlFree(key);

197        } else if (!xmlStrcmp(mapNode->name, (const xmlChar*) "expanded"))


198        {


199          xmlChar* key = xmlNodeListGetString(doc, mapNode->xmlChildrenNode, 1);


200          if ((key != 0) && ((char) key[0] == '1'))


201          {


202            map->setExpanded(true);


203          }


204        }
162        }

205      }
163      }

206      
164      
@@ -266,16 +224,24 @@ void World::save(std::string name, wxTreeCtrl* mapTree)

266  rc = xmlTextWriterStartElement(writer, (xmlChar*) "world");
224  rc = xmlTextWriterStartElement(writer, (xmlChar*) "world");

267  if (rc < 0) throw MapWriteException(name);
225  if (rc < 0) throw MapWriteException(name);

268  
226  

269  //   <nextmapid/>
227  //   nextmap=

270  std::ostringstream nextMap_out;
228  rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "nextmap", "%d", nextMapID);

271  nextMap_out << nextMapID;
229  if (rc < 0) throw MapWriteException(name);

272  rc = xmlTextWriterWriteElement(writer, (xmlChar*) "nextmapid", (xmlChar*) nextMap_out.str().c_str());
230  


231  //   lastmap=


232  rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "lastmap", "%d", lastmap);


233  if (rc < 0) throw MapWriteException(name);


234  


235  //   startx=


236  rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "startx", "%d", startingPosition.first);

273  if (rc < 0) throw MapWriteException(name);
237  if (rc < 0) throw MapWriteException(name);

274  
238  

275  //   <lastmap/>
239  //   starty=

276  std::ostringstream lastMap_out;
240  rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "starty", "%d", startingPosition.second);

277  lastMap_out << lastmap;
241  if (rc < 0) throw MapWriteException(name);

278  rc = xmlTextWriterWriteElement(writer, (xmlChar*) "lastmap", (xmlChar*) lastMap_out.str().c_str());
242  


243  //   startmap=


244  rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "startmap", "%d", startingMap);

279  if (rc < 0) throw MapWriteException(name);
245  if (rc < 0) throw MapWriteException(name);

280  
246  

281  // ASSUMPTION: There will always be at least one child of the invisible root element. i.e. you cannot delete to zero maps.
247  // ASSUMPTION: There will always be at least one child of the invisible root element. i.e. you cannot delete to zero maps.
@@ -285,28 +251,10 @@ void World::save(std::string name, wxTreeCtrl* mapTree)

285  {
251  {

286    // <root>
252    // <root>

287    MapPtrCtr* ctl = (MapPtrCtr*) mapTree->GetItemData(it);
253    MapPtrCtr* ctl = (MapPtrCtr*) mapTree->GetItemData(it);

288    std::ostringstream rootid_out;
254    rc = xmlTextWriterWriteFormatElement(writer, (xmlChar*) "root", "%d", ctl->map->getID());

289    rootid_out << ctl->map->getID();


290    rc = xmlTextWriterWriteElement(writer, (xmlChar*) "root", (xmlChar*) rootid_out.str().c_str());


291    if (rc < 0) throw MapWriteException(name);
255    if (rc < 0) throw MapWriteException(name);

292  }
256  }

293  
257  

294  //   <startpos/>


295  rc = xmlTextWriterStartElement(writer, (xmlChar*) "startpos");


296  if (rc < 0) throw MapWriteException(name);


297  


298  //   id=


299  rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "id", "%d", startingMap);


300  if (rc < 0) throw MapWriteException(name);


301  


302  //   pos=


303  rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "pos", "%d,%d", startingPosition.first, startingPosition.second);


304  if (rc < 0) throw MapWriteException(name);


305  


306  //   </startpos>


307  rc = xmlTextWriterEndElement(writer);


308  if (rc < 0) throw MapWriteException(name);


309  


310  for (auto mapPair : maps)
258  for (auto mapPair : maps)

311  {
259  {

312    Map& map = *mapPair.second;
260    Map& map = *mapPair.second;
@@ -318,16 +266,33 @@ void World::save(std::string name, wxTreeCtrl* mapTree)

318    if (rc < 0) throw MapWriteException(name);
266    if (rc < 0) throw MapWriteException(name);

319    
267    

320    // id=
268    // id=

321    std::ostringstream id_out;
269    rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "id", "%d", map.getID());

322    id_out << map.getID();


323    rc = xmlTextWriterWriteAttribute(writer, (xmlChar*) "id", (xmlChar*) id_out.str().c_str());


324    if (rc < 0) throw MapWriteException(name);
270    if (rc < 0) throw MapWriteException(name);

325    
271    

326    //   <name/>
272    // expanded=

327    rc = xmlTextWriterWriteElement(writer, (xmlChar*) "name", (xmlChar*) map.getTitle().c_str());
273    wxTreeItemId node = map.getTreeItemId();


274    if (mapTree->IsExpanded(node))


275    {


276      rc = xmlTextWriterWriteAttribute(writer, (xmlChar*) "expanded", (xmlChar*) "true");


277      if (rc < 0) throw MapWriteException(name);


278    } else {


279      rc = xmlTextWriterWriteAttribute(writer, (xmlChar*) "expanded", (xmlChar*) "false");


280      if (rc < 0) throw MapWriteException(name);


281    }


282    


283    // title=


284    rc = xmlTextWriterWriteAttribute(writer, (xmlChar*) "name", (xmlChar*) map.getTitle().c_str());

328    if (rc < 0) throw MapWriteException(name);
285    if (rc < 0) throw MapWriteException(name);

329  
286  

330    //   <environment/>
287    //   <environment


288    rc = xmlTextWriterStartElement(writer, (xmlChar*) "environment");


289    if (rc < 0) throw MapWriteException(name);


290    


291    //   type=


292    rc = xmlTextWriterWriteAttribute(writer, (xmlChar*) "type", (xmlChar*) "0");


293    if (rc < 0) throw MapWriteException(name);


294    


295    //   >

331    std::ostringstream mapdata_out;
296    std::ostringstream mapdata_out;

332    for (int y=0; y<MAP_HEIGHT; y++)
297    for (int y=0; y<MAP_HEIGHT; y++)

333    {
298    {
@@ -341,113 +306,60 @@ void World::save(std::string name, wxTreeCtrl* mapTree)

341  
306  

342    rc = xmlTextWriterWriteElement(writer, (xmlChar*) "environment", (xmlChar*) mapdata_out.str().c_str());
307    rc = xmlTextWriterWriteElement(writer, (xmlChar*) "environment", (xmlChar*) mapdata_out.str().c_str());

343    if (rc < 0) throw MapWriteException(name);
308    if (rc < 0) throw MapWriteException(name);

344  


345    //   <leftmap/>


346    rc = xmlTextWriterStartElement(writer, (xmlChar*) "leftmap");


347    if (rc < 0) throw MapWriteException(name);


348    
309    

349    //   type=
310    //   </environment>

350    rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "type", "%s", Map::shortForMoveType(map.getLeftMoveType()).c_str());


351    if (rc < 0) throw MapWriteException(name);


352    


353    if (Map::moveTypeTakesMap(map.getLeftMoveType()))


354    {


355      // map=


356      rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "map", "%d", map.getLeftMoveMapID());


357      if (rc < 0) throw MapWriteException(name);


358    }


359    


360    //   </leftmap>


361    rc = xmlTextWriterEndElement(writer);
311    rc = xmlTextWriterEndElement(writer);

362    if (rc < 0) throw MapWriteException(name);
312    if (rc < 0) throw MapWriteException(name);

363    
313    

364    //   <rightmap/>
314    for (auto object : map.getObjects())

365    rc = xmlTextWriterStartElement(writer, (xmlChar*) "rightmap");


366    if (rc < 0) throw MapWriteException(name);


367    


368    //   type=


369    rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "type", "%s", Map::shortForMoveType(map.getRightMoveType()).c_str());


370    if (rc < 0) throw MapWriteException(name);


371    


372    if (Map::moveTypeTakesMap(map.getRightMoveType()))


373    {
315    {

374      // map=
316      // <entity>

375      rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "map", "%d", map.getRightMoveMapID());
317      rc = xmlTextWriterStartElement(writer, (xmlChar*) "entity");

376      if (rc < 0) throw MapWriteException(name);
318      if (rc < 0) throw MapWriteException(name);

377    }


378    


379    //   </rightmap>


380    rc = xmlTextWriterEndElement(writer);


381    if (rc < 0) throw MapWriteException(name);


382    
319    

383    //   <upmap/>
320      // type=

384    rc = xmlTextWriterStartElement(writer, (xmlChar*) "upmap");
321      rc = xmlTextWriterWriteAttribute(writer, (xmlChar*) "type", (xmlChar*) object->object->getType().c_str());

385    if (rc < 0) throw MapWriteException(name);


386    


387    //   type=


388    rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "type", "%s", Map::shortForMoveType(map.getUpMoveType()).c_str());


389    if (rc < 0) throw MapWriteException(name);


390    


391    if (Map::moveTypeTakesMap(map.getUpMoveType()))


392    {


393      // map=


394      rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "map", "%d", map.getUpMoveMapID());


395      if (rc < 0) throw MapWriteException(name);
322      if (rc < 0) throw MapWriteException(name);

396    }


397    


398    //   </upmap>


399    rc = xmlTextWriterEndElement(writer);


400    if (rc < 0) throw MapWriteException(name);


401    
323    

402    //   <downmap/>
324      // x=

403    rc = xmlTextWriterStartElement(writer, (xmlChar*) "downmap");
325      rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "x", "%d", object->position.first);

404    if (rc < 0) throw MapWriteException(name);
326      if (rc < 0) throw MapWriteException(name);

405    
327      

406    //   type=
328      // y=

407    rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "type", "%s", Map::shortForMoveType(map.getDownMoveType()).c_str());
329      rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "y", "%d", object->position.second);

408    if (rc < 0) throw MapWriteException(name);
330      if (rc < 0) throw MapWriteException(name);

409    
331    

410    if (Map::moveTypeTakesMap(map.getDownMoveType()))
332      // </entity>

411    {
333      rc = xmlTextWriterEndElement(writer);

412      // map=


413      rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "map", "%d", map.getDownMoveMapID());


414      if (rc < 0) throw MapWriteException(name);
334      if (rc < 0) throw MapWriteException(name);

415    }
335    }

416    
336    

417    //   </downmap>
337    for (auto adjacent : map.getAdjacents())

418    rc = xmlTextWriterEndElement(writer);


419    if (rc < 0) throw MapWriteException(name);


420  


421    //   <entities>


422    rc = xmlTextWriterStartElement(writer, (xmlChar*) "entities");


423    if (rc < 0) throw MapWriteException(name);


424  


425    for (auto object : map.getObjects())


426    {
338    {

427      //   <entity>
339      // <adjacent>

428      rc = xmlTextWriterStartElement(writer, (xmlChar*) "entity");
340      rc = xmlTextWriterStartElement(writer, (xmlChar*) "adjacent");

429      if (rc < 0) throw MapWriteException(name);
341      if (rc < 0) throw MapWriteException(name);

430    
342      

431      //     <entity-type/>
343      // dir=

432      rc = xmlTextWriterWriteElement(writer, (xmlChar*) "entity-type", (xmlChar*) object->object->getType().c_str());
344      rc = xmlTextWriterWriteAttribute(writer, (xmlChar*) "dir", (xmlChar*) Map::shortForMoveDir(adjacent.first).c_str());

433      if (rc < 0) throw MapWriteException(name);
345      if (rc < 0) throw MapWriteException(name);

434    
346      

435      //     <entity-position/>
347      // type=

436      std::ostringstream entpos_out;
348      rc = xmlTextWriterWriteAttribute(writer, (xmlChar*) "type", (xmlChar*) Map::shortForMoveType(adjacent.second.type).c_str());

437      entpos_out << object->position.first << "," << object->position.second;


438      rc = xmlTextWriterWriteElement(writer, (xmlChar*) "entity-position", (xmlChar*) entpos_out.str().c_str());


439      if (rc < 0) throw MapWriteException(name);
349      if (rc < 0) throw MapWriteException(name);

440    
350      

441      //   </entity>
351      // map=


352      if (Map::moveTypeTakesMap(adjacent.second.type))


353      {


354        rc = xmlTextWriterWriteFormatAttribute(writer, (xmlChar*) "map", "%d", adjacent.second.map);


355        if (rc < 0) throw MapWriteException(name);


356      }


357      


358      // </adjacent>

442      rc = xmlTextWriterEndElement(writer);
359      rc = xmlTextWriterEndElement(writer);

443      if (rc < 0) throw MapWriteException(name);
360      if (rc < 0) throw MapWriteException(name);

444    }
361    }

445  


446    //   </entities>


447    rc = xmlTextWriterEndElement(writer);


448    if (rc < 0) throw MapWriteException(name);


449    
362    

450    wxTreeItemId node = map.getTreeItemId();


451    if (mapTree->ItemHasChildren(node))
363    if (mapTree->ItemHasChildren(node))

452    {
364    {

453      wxTreeItemIdValue cookie2;
365      wxTreeItemIdValue cookie2;
@@ -455,16 +367,7 @@ void World::save(std::string name, wxTreeCtrl* mapTree)

455      {
367      {

456      // <child/>
368      // <child/>

457        MapPtrCtr* ctl = (MapPtrCtr*) mapTree->GetItemData(it);
369        MapPtrCtr* ctl = (MapPtrCtr*) mapTree->GetItemData(it);

458        std::ostringstream childid_out;
370        rc = xmlTextWriterWriteFormatElement(writer, (xmlChar*) "child", "%d", ctl->map->getID());

459        childid_out << ctl->map->getID();


460        rc = xmlTextWriterWriteElement(writer, (xmlChar*) "child", (xmlChar*) childid_out.str().c_str());


461        if (rc < 0) throw MapWriteException(name);


462      }


463      


464      if (mapTree->IsExpanded(node))


465      {


466      // <expanded/>


467        rc = xmlTextWriterWriteElement(writer, (xmlChar*) "expanded", (xmlChar*) "1");


468        if (rc < 0) throw MapWriteException(name);
371        if (rc < 0) throw MapWriteException(name);

469      }
372      }

470    }
373    }
 

generated by cgit-pink 1.4.1 (git 2.36.1) at 2024-11-21 15:37:48 +0000