← Back to branch summary

~ubuntu-branches/ubuntu/saucy/lordsawar/saucy

« back to all changes in this revision

Viewing changes to src/Tile.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Barry deFreese, Barry deFreese
  • Date: 2008-12-20 13:52:12 UTC
  • mfrom: (1.1.6 upstream) (5.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20081220135212-noeb2w3y98ebo7o9
Tags: 0.1.4-1
[ Barry deFreese ]
* New upstream release.
* Move 0.0.8-2.1 changelog entry to correct point in changelog.
* Make lordsawar-data suggest lordsawar.
* Update my e-mail address.
* Add build-depends on intltool, uuid-dev, and libboost-dev.
* Don't install locales since there are no translations currently.
* Add simple man page for new lordsawar-pbm binary.
* Drop gcc4.3 patches as they have been fixed upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Tile.cpp
18
18
//  02110-1301, USA.
19
19
 
20
20
#include "Tile.h"
21
 
#include "defs.h"
 
21
#include "SmallTile.h"
22
22
#include <iostream>
 
23
#include <algorithm>
 
24
 
 
25
std::string Tile::d_tag = "tile";
23
26
 
24
27
using namespace std;
25
28
 
 
29
 
26
30
Tile::Tile()
27
31
{
28
32
  d_type = Tile::GRASS;
29
 
  d_pattern = Tile::SOLID;
30
33
  d_moves = 0;
31
 
  d_color.r = 80;
32
 
  d_color.g = 172;
33
 
  d_color.b = 28;
 
34
  d_smalltile = new SmallTile();
34
35
}
35
36
 
36
37
Tile::Tile(XML_Helper* helper)
37
38
{
38
 
    int i;
39
 
    
40
39
    helper->getData(d_name, "name");
41
40
    helper->getData(d_moves, "moves");
42
 
    helper->getData(i, "type");
43
 
    d_type = static_cast<Tile::Type>(i);
44
 
 
 
41
    std::string type_str;
 
42
    helper->getData(type_str, "type");
 
43
    d_type = tileTypeFromString(type_str);
45
44
}
46
45
 
47
46
bool Tile::save(XML_Helper *helper)
48
47
{
49
48
  bool retval = true;
50
49
 
51
 
  retval &= helper->openTag("tile");
 
50
  retval &= helper->openTag(d_tag);
52
51
  retval &= helper->saveData("name", d_name);
53
52
  retval &= helper->saveData("moves", d_moves);
54
 
  retval &= helper->saveData("type", d_type);
55
 
  retval &= helper->openTag("smallmap");
56
 
  switch (d_pattern)
57
 
    {
58
 
      //patterns with a single colour
59
 
    case SOLID:
60
 
      retval &= helper->saveData("red", d_color.r);
61
 
      retval &= helper->saveData("green", d_color.g);
62
 
      retval &= helper->saveData("blue", d_color.b);
63
 
      break;
64
 
      //patterns with two colours
65
 
    case STIPPLED: case SUNKEN:
66
 
      retval &= helper->saveData("red", d_color.r);
67
 
      retval &= helper->saveData("green", d_color.g);
68
 
      retval &= helper->saveData("blue", d_color.b);
69
 
      retval &= helper->saveData("2nd_red", d_second_color.r);
70
 
      retval &= helper->saveData("2nd_green", d_second_color.g);
71
 
      retval &= helper->saveData("2nd_blue", d_second_color.b);
72
 
      break;
73
 
      //patterns with three colours
74
 
    case RANDOMIZED: case TABLECLOTH:
75
 
      retval &= helper->saveData("red", d_color.r);
76
 
      retval &= helper->saveData("green", d_color.g);
77
 
      retval &= helper->saveData("blue", d_color.b);
78
 
      retval &= helper->saveData("2nd_red", d_second_color.r);
79
 
      retval &= helper->saveData("2nd_green", d_second_color.g);
80
 
      retval &= helper->saveData("2nd_blue", d_second_color.b);
81
 
      retval &= helper->saveData("3rd_red", d_third_color.r);
82
 
      retval &= helper->saveData("3rd_green", d_third_color.g);
83
 
      retval &= helper->saveData("3rd_blue", d_third_color.b);
84
 
      break;
85
 
    }
86
 
  retval &= helper->closeTag();
 
53
  std::string type_str = tileTypeToString(Tile::Type(d_type));
 
54
  retval &= helper->saveData("type", type_str);
 
55
  retval &= d_smalltile->save(helper);
87
56
  for (Tile::iterator i = begin(); i != end(); ++i)
88
57
    retval &= (*i)->save(helper);
89
58
  retval &= helper->closeTag();
97
66
      delete *it;
98
67
}
99
68
 
100
 
void Tile::instantiatePixmaps(std::string tileset, Uint32 tilesize)
101
 
{
102
 
  for (iterator it = begin(); it != end(); it++)
103
 
    (*it)->instantiatePixmaps(tileset, tilesize);
104
 
}
105
 
 
106
69
void Tile::setTypeByIndex(int idx)
107
70
{
108
71
  switch (idx)
113
76
    case 3: setType(HILLS); break;
114
77
    case 4: setType(MOUNTAIN); break;
115
78
    case 5: setType(SWAMP); break;
 
79
    case 6: setType(VOID); break;
116
80
    }
117
81
}
118
82
int Tile::getTypeIndexForType(Tile::Type type)
125
89
    case HILLS: return 3; break;
126
90
    case MOUNTAIN: return 4; break;
127
91
    case SWAMP: return 5; break;
 
92
    case VOID: return 6; break;
128
93
    }
 
94
  return 0;
129
95
}
130
96
TileStyle *Tile::getRandomTileStyle (TileStyle::Type style)
131
97
{
145
111
    return NULL;
146
112
  return tilestyles[rand() % tilestyles.size()];
147
113
}
 
114
 
 
115
std::string Tile::tileTypeToString(const Tile::Type type)
 
116
{
 
117
  switch (type)
 
118
    {
 
119
    case Tile::GRASS:
 
120
      return "Tile::GRASS";
 
121
    case Tile::WATER:
 
122
      return "Tile::WATER";
 
123
    case Tile::FOREST:
 
124
      return "Tile::FOREST";
 
125
    case Tile::HILLS:
 
126
      return "Tile::HILLS";
 
127
    case Tile::MOUNTAIN:
 
128
      return "Tile::MOUNTAIN";
 
129
    case Tile::SWAMP:
 
130
      return "Tile::SWAMP";
 
131
    case Tile::VOID:
 
132
      return "Tile::VOID";
 
133
    }
 
134
  return "Tile::GRASS";
 
135
}
 
136
 
 
137
Tile::Type Tile::tileTypeFromString(const std::string str)
 
138
{
 
139
  if (str.size() > 0 && isdigit(str.c_str()[0]))
 
140
    return Tile::Type(atoi(str.c_str()));
 
141
  if (str == "Tile::GRASS")
 
142
    return Tile::GRASS;
 
143
  else if (str == "Tile::WATER")
 
144
    return Tile::WATER;
 
145
  else if (str == "Tile::FOREST")
 
146
    return Tile::FOREST;
 
147
  else if (str == "Tile::HILLS")
 
148
    return Tile::HILLS;
 
149
  else if (str == "Tile::MOUNTAIN")
 
150
    return Tile::MOUNTAIN;
 
151
  else if (str == "Tile::SWAMP")
 
152
    return Tile::SWAMP;
 
153
  else if (str == "Tile::VOID")
 
154
    return Tile::VOID;
 
155
  return Tile::GRASS;
 
156
}
 
157
 
 
158
      
 
159
bool Tile::validateGrass(std::list<TileStyle::Type> types)
 
160
{
 
161
  //grass tiles only have lone styles and other styles.
 
162
  for (std::list<TileStyle::Type>::iterator it = types.begin(); 
 
163
       it != types.end(); it++)
 
164
    {
 
165
      if ((*it) != TileStyle::LONE && (*it) != TileStyle::OTHER)
 
166
        return false;
 
167
    }
 
168
  return true;
 
169
}
 
170
 
 
171
bool Tile::validateFeature(std::list<TileStyle::Type> types)
 
172
{
 
173
  //forest, water and hill tiles have a full suite of styles
 
174
  //"other" styles are optional.
 
175
  if (types.size() == TileStyle::OTHER)
 
176
    return true;
 
177
  if (types.size() == TileStyle::OTHER - 1 &&
 
178
      find (types.begin(), types.end(), TileStyle::OTHER) == types.end())
 
179
    return true;
 
180
  return false;
 
181
}
 
182
 
 
183
bool Tile::consistsOnlyOfLoneAndOtherStyles()
 
184
{
 
185
  std::list<TileStyle::Type> types;
 
186
  for (Tile::iterator i = begin(); i != end(); ++i)
 
187
    (*i)->getUniqueTileStyleTypes(types);
 
188
      return validateGrass(types);
 
189
}
 
190
bool Tile::validate()
 
191
{
 
192
  if (size() == 0)
 
193
    return false;
 
194
 
 
195
  for (Tile::iterator i = begin(); i != end(); ++i)
 
196
    if ((*i)->validate() == false)
 
197
      return false;
 
198
 
 
199
  std::list<TileStyle::Type> types;
 
200
  for (Tile::iterator i = begin(); i != end(); ++i)
 
201
    (*i)->getUniqueTileStyleTypes(types);
 
202
 
 
203
  if (types.empty())
 
204
    return false;
 
205
 
 
206
  switch (getType())
 
207
    {
 
208
    case Tile::GRASS:
 
209
      if (validateGrass(types) == false)
 
210
        return false;
 
211
      break;
 
212
    case Tile::FOREST: case Tile::WATER: case Tile::HILLS: 
 
213
    case Tile::SWAMP: case Tile::VOID: case Tile::MOUNTAIN:
 
214
      if (validateFeature(types) == false)
 
215
        {
 
216
          if (validateGrass(types) == false)
 
217
            return false;
 
218
          else
 
219
            return true;
 
220
        }
 
221
      break;
 
222
    }
 
223
  return true;
 
224
}
148
225
// End of file