← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/enigma/intrepid

« back to all changes in this revision

Viewing changes to lib-src/oxydlib/printstats.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Erich Schubert
  • Date: 2005-08-28 15:30:09 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20050828153009-sky64kb6tcq37xt5
Tags: 0.92.1-1
http://bugs.debian.org/321669
http://bugs.debian.org/325405
http://bugs.debian.org/308558
* New upstream subversion checkout
* Remove menu.s3m, which we are allowed to distributed but not to modify
  also copyright notice is confusing... (Closes: #321669)
* Rebuild with new libzipios (Closes: #325405)
  I hope this works without a versioned build-dependency
* Added "enigma replaces enigma-data" for upgrades (Closes: #308558)
* Added notes about the fonts copyright.
* updated to policy 3.6.2.1 (no changes)

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib-src/oxydlib/printstats.cpp
1
 
// Copyright 2003 Jeremy Sawicki
2
 
//
3
 
// This file is part of OxydLib.
4
 
//
5
 
// OxydLib is free software; you can redistribute it and/or modify
6
 
// it under the terms of the GNU General Public License as published by
7
 
// the Free Software Foundation; either version 2 of the License, or
8
 
// (at your option) any later version.
9
 
//
10
 
// OxydLib is distributed in the hope that it will be useful,
11
 
// but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
// GNU General Public License for more details.
14
 
//
15
 
// You should have received a copy of the GNU General Public License
16
 
// along with OxydLib; if not, write to the Free Software
17
 
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 
 
19
 
#include <stdio.h>
20
 
#include "OxydVersion.h"
21
 
#include <string>
22
 
#include <cassert>
23
 
#include "VecUtils.h"
24
 
#include "FileUtils.h"
25
 
#include "DatFile.h"
26
 
#include "Level.h"
27
 
 
28
 
#include "EnigmaNames.cpp"
29
 
 
30
 
using namespace std;
31
 
using namespace OxydLib;
32
 
using namespace enigma_names;
33
 
 
34
 
void usage()
35
 
{
36
 
  printf("Usage:\n");
37
 
  printf("  printstats [options] <datfile>\n");
38
 
  printf("\n");
39
 
  printf("Description:\n");
40
 
  printf("  The printstats program parses the Oxyd data file specified by <datfile>\n");
41
 
  printf("  and displays statistics about the contents of the levels.  For each\n");
42
 
  printf("  type of surface, piece, or object, printstats displays the level\n");
43
 
  printf("  numbers where it is used, as well as the level numbers where it is used\n");
44
 
  printf("  as a signal sender or recipient (pieces and objects only).\n");
45
 
  printf("\n");
46
 
  printf("Options:\n");
47
 
  printf("  -v1  Oxyd 1\n");
48
 
  printf("  -vm  Oxyd Magnum\n");
49
 
  printf("  -vg  Oxyd Magnum Gold\n");
50
 
  printf("  -vp  PerOxyd (default)\n");
51
 
  printf("  -ve  Oxyd Extra\n");
52
 
  printf("  -n   Use enigma names for objects\n");
53
 
  printf("\n");
54
 
}
55
 
 
56
 
void printObjectValue(int num, Mapping *m, GridType type) {
57
 
    if (m) {
58
 
        static int max_length[GridType_Count] = { -1, -1, -1 };
59
 
 
60
 
        if (max_length[type]<0) {
61
 
            for (int t = GridType_First; t <= GridType_Last; ++t) {
62
 
                const char *(Mapping::*getName)(int) const = 0;
63
 
 
64
 
                switch (t) {
65
 
                    case GridType_Surfaces: getName = &Mapping::floorName; break;
66
 
                    case GridType_Pieces:   getName = &Mapping::stoneName; break;
67
 
                    case GridType_Objects:  getName = &Mapping::itemName; break;
68
 
                    default : assert(0); break;
69
 
                }
70
 
 
71
 
                int max = -1;
72
 
                for (int i = 0; i<256; ++i) {
73
 
                    const char *name = (m->*getName)(i);
74
 
                    if (name) {
75
 
                        int len          = strlen(name);
76
 
                        if (len>max) max = len;
77
 
                    }
78
 
                }
79
 
                max_length[t] = max;
80
 
            }
81
 
        }
82
 
 
83
 
        const char *name = 0;
84
 
 
85
 
        switch (type) {
86
 
            case GridType_Surfaces: name = m->floorName(num); break;
87
 
            case GridType_Pieces:   name = m->stoneName(num); break;
88
 
            case GridType_Objects:  name = m->itemName(num); break;
89
 
            default : assert(0); break;
90
 
        }
91
 
        printf("%-*s ", max_length[type], name ? name : "");
92
 
    }
93
 
    printf("%02x:", num);
94
 
}
95
 
 
96
 
int main(int argc, char *argv[])
97
 
{
98
 
  OxydVersion ver            = OxydVersion_PerOxyd;
99
 
  bool        bGotDatFile    = false;
100
 
  bool        useEnigmaNames = false;
101
 
  string      strDatFile;
102
 
 
103
 
  int nArg = 1;
104
 
  while (nArg < argc) {
105
 
    string strArg(argv[nArg]);
106
 
    nArg++;
107
 
 
108
 
    if (strArg.compare("-v1") == 0) {
109
 
      ver = OxydVersion_Oxyd1;
110
 
    } else if (strArg.compare("-vm") == 0) {
111
 
      ver = OxydVersion_OxydMagnum;
112
 
    } else if (strArg.compare("-vg") == 0) {
113
 
      ver = OxydVersion_OxydMagnumGold;
114
 
    } else if (strArg.compare("-vp") == 0) {
115
 
      ver = OxydVersion_PerOxyd;
116
 
    } else if (strArg.compare("-ve") == 0) {
117
 
      ver = OxydVersion_OxydExtra;
118
 
    } else if (strArg.compare("-n") == 0) {
119
 
      useEnigmaNames = true;
120
 
    } else if (!bGotDatFile) {
121
 
      strDatFile = strArg;
122
 
      bGotDatFile = true;
123
 
    } else {
124
 
      usage();
125
 
      exit(1);
126
 
    }
127
 
  }
128
 
 
129
 
  if (!bGotDatFile) {
130
 
    usage();
131
 
    exit(1);
132
 
  }
133
 
 
134
 
  Mapping *enigmaMapping = 0;
135
 
  if (useEnigmaNames) enigmaMapping = new Mapping(ver);
136
 
 
137
 
  OxydLib::ByteVec fileData;
138
 
  bool success = readFile(strDatFile, &fileData);
139
 
  if (!success) {
140
 
    printf("Error reading DAT file.\n");
141
 
    exit(1);
142
 
  }
143
 
 
144
 
  DatFile datFile;
145
 
  string msg;
146
 
  success = parseDatFile(fileData, ver, &datFile, &msg);
147
 
  if (!success) {
148
 
    printf("Error parsing DAT file:\n");
149
 
    printf("%s\n", msg.c_str());
150
 
    exit(1);
151
 
  }
152
 
 
153
 
  set<int> used[GridType_Count][256];
154
 
  set<int> usedAsSender[GridType_Count][256];
155
 
  set<int> usedAsRecipient[GridType_Count][256];
156
 
 
157
 
  for (int nLevel = 0; nLevel < 200; nLevel++) {
158
 
    OxydLib::Level level;
159
 
    success = parseLevel(datFile.getLevel(nLevel), &level, &msg);
160
 
    if (!success) {
161
 
      printf("Error parsing level %d:\n", nLevel + 1);
162
 
      printf("%s\n", msg.c_str());
163
 
      continue;
164
 
//       exit(1);
165
 
    }
166
 
 
167
 
    if (level.isEmpty()) {
168
 
      continue;
169
 
    }
170
 
 
171
 
    {
172
 
      for (int gridTypeInt = GridType_First;
173
 
           gridTypeInt <= GridType_Last;
174
 
           gridTypeInt++) {
175
 
        GridType gridType = GridType(gridTypeInt);
176
 
 
177
 
        for (unsigned int y = 0; y < level.getHeight(); y++) {
178
 
          for (unsigned int x = 0; x < level.getWidth(); x++) {
179
 
            unsigned char byteVal = level.getGrid(gridType).get(x, y);
180
 
            used[gridType][byteVal].insert(nLevel);
181
 
          }
182
 
        }
183
 
 
184
 
        if (gridType == GridType_Surfaces) {
185
 
          continue;
186
 
        }
187
 
      }
188
 
    }
189
 
 
190
 
    {
191
 
      set<SignalLocation> senders;
192
 
      level.getSenders(&senders);
193
 
      set<SignalLocation>::const_iterator senderIter = senders.begin();
194
 
      set<SignalLocation>::const_iterator senderEnd = senders.end();
195
 
      for (; senderIter != senderEnd; ++senderIter) {
196
 
        const SignalLocation &sender = *senderIter;
197
 
 
198
 
        unsigned char senderByteVal =
199
 
          level.getGrid(sender.getGridType()).get(sender.getX(),
200
 
                                                  sender.getY());
201
 
        usedAsSender[sender.getGridType()][senderByteVal].insert(nLevel);
202
 
 
203
 
        int numRecipients = level.getNumRecipients(sender);
204
 
        for (int nRecipient = 0;
205
 
             nRecipient < numRecipients;
206
 
             nRecipient++) {
207
 
          const SignalLocation &recipient =
208
 
            level.getRecipient(sender, nRecipient);
209
 
 
210
 
          unsigned char recipientByteVal =
211
 
            level.getGrid(recipient.getGridType()).get(recipient.getX(),
212
 
                                                       recipient.getY());
213
 
          usedAsRecipient[recipient.getGridType()][recipientByteVal]
214
 
            .insert(nLevel);
215
 
        }
216
 
      }
217
 
    }
218
 
  }
219
 
 
220
 
  {
221
 
    for (int gridTypeInt = GridType_First;
222
 
         gridTypeInt <= GridType_Last;
223
 
         gridTypeInt++) {
224
 
      GridType gridType = GridType(gridTypeInt);
225
 
 
226
 
      switch (gridType) {
227
 
      case GridType_Surfaces: printf("Surfaces:\n"); break;
228
 
      case GridType_Pieces:   printf("Pieces:\n");   break;
229
 
      case GridType_Objects:  printf("Objects:\n");  break;
230
 
      default: exit(1);
231
 
      }
232
 
 
233
 
      for (int byteValInt = 0; byteValInt < 256; byteValInt++) {
234
 
        printObjectValue(byteValInt, enigmaMapping, gridType);
235
 
        // printf("%02x:", byteValInt);
236
 
 
237
 
        const set<int> &intSet = used[gridType][byteValInt];
238
 
        set<int>::const_iterator iter = intSet.begin();
239
 
        set<int>::const_iterator end = intSet.end();
240
 
        for (; iter != end; ++iter) {
241
 
          int nLevel = *iter;
242
 
          printf(" %d", nLevel + 1);
243
 
        }
244
 
 
245
 
        printf("\n");
246
 
      }
247
 
 
248
 
      printf("\n");
249
 
    }
250
 
  }
251
 
 
252
 
  {
253
 
    for (int gridTypeInt = GridType_First;
254
 
         gridTypeInt <= GridType_Last;
255
 
         gridTypeInt++) {
256
 
      GridType gridType = GridType(gridTypeInt);
257
 
 
258
 
      if (gridType == GridType_Surfaces) {
259
 
        continue;
260
 
      }
261
 
 
262
 
      for (int useType = 1; useType <= 2; useType++) {
263
 
        switch (gridType) {
264
 
        case GridType_Pieces:   printf("Pieces (");   break;
265
 
        case GridType_Objects:  printf("Objects (");  break;
266
 
        default: exit(1);
267
 
        }
268
 
 
269
 
        switch (useType) {
270
 
        case 1: printf("senders"); break;
271
 
        case 2: printf("recipients"); break;
272
 
        default: exit(1);
273
 
        }
274
 
 
275
 
        printf("):\n");
276
 
 
277
 
        for (int byteValInt = 0; byteValInt < 256; byteValInt++) {
278
 
          printObjectValue(byteValInt, enigmaMapping, gridType);
279
 
          // printf("%02x:", byteValInt);
280
 
 
281
 
          const set<int> &intSet =
282
 
            (useType == 1 ? usedAsSender : usedAsRecipient)
283
 
            [gridType][byteValInt];
284
 
          set<int>::const_iterator iter = intSet.begin();
285
 
          set<int>::const_iterator end = intSet.end();
286
 
          for (; iter != end; ++iter) {
287
 
            int nLevel = *iter;
288
 
            printf(" %d", nLevel + 1);
289
 
          }
290
 
 
291
 
          printf("\n");
292
 
        }
293
 
 
294
 
        printf("\n");
295
 
      }
296
 
    }
297
 
  }
298
 
 
299
 
  delete enigmaMapping;
300
 
 
301
 
  return 0;
302
 
}