39 |
case absort_feld: |
case absort_feld: |
40 |
return (rechts_ok(rechts) && (0<=x) && (x<grx) && (0<=y) && (y<gry)); |
return (rechts_ok(rechts) && (0<=x) && (x<grx) && (0<=y) && (y<gry)); |
41 |
case absort_fall: |
case absort_fall: |
42 |
return (rechts_ok(rechts) && (x==x%2)); |
return (rechts_ok(rechts) && (x==x & 1)); |
43 |
case absort_semiglobal: |
case absort_semiglobal: |
44 |
return (rechts_ok(rechts)); |
return (rechts_ok(rechts)); |
45 |
case absort_global: |
case absort_global: |
61 |
case absort_fall: |
case absort_fall: |
62 |
return (Cuyo::gCuyo->getSpielfeld(rechts)->getFall())[x]; |
return (Cuyo::gCuyo->getSpielfeld(rechts)->getFall())[x]; |
63 |
case absort_semiglobal: |
case absort_semiglobal: |
64 |
throw iFehler(_("%s: Internal error in ort_absolut::finde_ort(): semiglobal gibt's noch nicht")); |
return Cuyo::gCuyo->getSpielfeld(rechts)->getSemiglobal(); |
65 |
case absort_global: |
case absort_global: |
66 |
return Blop::gGlobalBlop; |
return Blop::gGlobalBlop; |
67 |
case absort_nirgends: |
case absort_nirgends: |
74 |
}; |
}; |
75 |
|
|
76 |
|
|
77 |
|
/** Hat der Ort einen Platz auf dem Bildschirm? */ |
78 |
|
bool ort_absolut::bemalbar() { |
79 |
|
switch (art) { |
80 |
|
case absort_feld: |
81 |
|
case absort_fall: |
82 |
|
return true; |
83 |
|
case absort_semiglobal: |
84 |
|
case absort_global: |
85 |
|
case absort_nirgends: |
86 |
|
return false; |
87 |
|
default: |
88 |
|
throw iFehler(_( |
89 |
|
"%s: Internal error in ort_absolut::bemalbar(): Unbekannte Art %d"), |
90 |
|
art); |
91 |
|
}; |
92 |
|
}; |
93 |
|
|
94 |
|
|
95 |
__String ort_absolut::toString() const { |
__String ort_absolut::toString() const { |
96 |
__String ret; |
__String ret; |
97 |
switch (art) { |
switch (art) { |
102 |
ret.sprintf(_("%d"), x); |
ret.sprintf(_("%d"), x); |
103 |
break; |
break; |
104 |
case absort_semiglobal: |
case absort_semiglobal: |
105 |
ret.sprintf(_("?")); |
ret.sprintf(_("@@")); |
106 |
break; |
break; |
107 |
case absort_global: |
case absort_global: |
108 |
ret.sprintf(_("()")); |
ret.sprintf(_("@")); |
109 |
break; |
break; |
110 |
case absort_nirgends: |
case absort_nirgends: |
111 |
ret.sprintf(_("-")); |
ret.sprintf(_("-")); |
126 |
mXKoord(0), mYKoord(0) |
mXKoord(0), mYKoord(0) |
127 |
{}; |
{}; |
128 |
|
|
129 |
|
/** ortart_relativ_feld */ |
130 |
/** ortart_relativ */ |
Ort::Ort(Code * x, Code * y) : |
131 |
Ort::Ort(Code * x, Code * y /* =0 */) : |
mArt(ortart_relativ_feld), mAbsArt(0), mHaelfte(haelfte_hier), |
|
mArt(ortart_relativ), mAbsArt(0), mHaelfte(haelfte_hier), |
|
132 |
mXKoord(x), mYKoord(y) |
mXKoord(x), mYKoord(y) |
133 |
{}; |
{}; |
134 |
|
|
135 |
|
/** ortart_relativ_fall */ |
136 |
|
Ort::Ort(Code * x) : |
137 |
|
mArt(ortart_relativ_fall), mAbsArt(0), mHaelfte(haelfte_hier), |
138 |
|
mXKoord(x), mYKoord(0) |
139 |
|
{}; |
140 |
|
|
141 |
/** ortart_absolut */ |
/** ortart_absolut */ |
142 |
Ort::Ort(int absart, Code * x /* = 0*/, Code * y /* = 0*/) : |
Ort::Ort(int absart, Code * x /* = 0*/, Code * y /* = 0*/) : |
159 |
}; |
}; |
160 |
|
|
161 |
|
|
162 |
|
Ort::~Ort() { |
163 |
|
if (mXKoord) delete mXKoord; |
164 |
|
if (mYKoord) delete mYKoord; |
165 |
|
} |
166 |
|
|
167 |
|
|
168 |
|
bool Ort::hier() { |
169 |
|
return mArt==ortart_hier; |
170 |
|
}; |
171 |
|
|
172 |
|
|
173 |
|
|
174 |
|
void Ort::setzeHaelfte(int haelfte) { |
175 |
|
mHaelfte = haelfte; |
176 |
|
}; |
177 |
|
|
178 |
|
|
179 |
|
|
180 |
inline bool berechne_rechts(bool vonhieraus, int haelfte) { |
inline bool berechne_rechts(bool vonhieraus, int haelfte) { |
181 |
switch (haelfte) { |
switch (haelfte) { |
194 |
switch (mArt) { |
switch (mArt) { |
195 |
case ortart_hier: |
case ortart_hier: |
196 |
return vonhieraus; |
return vonhieraus; |
197 |
case ortart_relativ: |
case ortart_relativ_feld: |
198 |
switch (vonhieraus.art) { |
CASSERT(mXKoord); |
199 |
case absort_feld: { |
CASSERT(mYKoord); |
200 |
int dx = mXKoord->eval(fuer_code); |
if (vonhieraus.art==absort_feld) { |
201 |
int dy = mYKoord->eval(fuer_code); |
int dx = mXKoord->eval(fuer_code); |
202 |
|
int dy = mYKoord->eval(fuer_code); |
203 |
/* Spiegeln für den Himmel-Level: |
|
204 |
(User will y nach unten eingeben; intern ist y nach oben.) |
/* Spiegeln für den Himmel-Level: |
205 |
|
(User will y nach unten eingeben; intern ist y nach oben.) |
206 |
Anpassung an die Hex-Koordinaten: |
|
207 |
Intern sind die relativen Koordinaten bei ungeradem dx |
Anpassung an die Hex-Koordinaten: |
208 |
so gespeichert, dass dy = 0 leicht schräg nach oben bedeutet. |
Intern sind die relativen Koordinaten bei ungeradem dx |
209 |
D. h. Für die geraden Spalten stimmt's, |
so gespeichert, dass dy = 0 leicht schräg nach oben bedeutet. |
210 |
für die ungeraden muss noch verschoben werden. |
D. h. Für die geraden Spalten stimmt's, |
211 |
*/ |
für die ungeraden muss noch verschoben werden. |
212 |
|
*/ |
213 |
int x = vonhieraus.x + dx; |
|
214 |
int y = vonhieraus.y + (ld->mSpiegeln ? -dy : dy) |
int x = vonhieraus.x + dx; |
215 |
- (ld->mSechseck && (vonhieraus.x & 1) && (dx & 1)); |
int y = vonhieraus.y + (ld->mSpiegeln ? -dy : dy) |
216 |
|
- (ld->mSechseck && (vonhieraus.x & 1) && (dx & 1)); |
217 |
return ort_absolut(absort_feld, |
|
218 |
berechne_rechts(vonhieraus.rechts,mHaelfte),x,y); |
return ort_absolut(absort_feld, |
219 |
}; |
berechne_rechts(vonhieraus.rechts,mHaelfte),x,y); |
220 |
case absort_fall: |
} |
221 |
return ort_absolut(absort_fall, |
else |
222 |
|
return ort_absolut(absort_nirgends); |
223 |
|
case ortart_relativ_fall: |
224 |
|
CASSERT(mXKoord); |
225 |
|
if (vonhieraus.art==absort_fall) |
226 |
|
return ort_absolut(absort_fall, |
227 |
berechne_rechts(vonhieraus.rechts,mHaelfte), |
berechne_rechts(vonhieraus.rechts,mHaelfte), |
228 |
(vonhieraus.x + mXKoord->eval(fuer_code)) % 2, 0); |
(vonhieraus.x + mXKoord->eval(fuer_code)) & 1, 0); |
229 |
case absort_semiglobal: |
else |
230 |
case absort_global: |
return ort_absolut(absort_nirgends); |
|
case absort_nirgends: |
|
|
throw Fehler(_("@ in inappropriate blob")); |
|
|
default: throw iFehler(_( |
|
|
"%s: Internal error in Ort::berechne(): Unbekannte Ort-Art %d"), |
|
|
vonhieraus.art); |
|
|
}; |
|
231 |
case ortart_absolut: |
case ortart_absolut: |
232 |
switch (mAbsArt) { |
switch (mAbsArt) { |
233 |
case absort_feld: |
case absort_feld: |
238 |
case absort_fall: |
case absort_fall: |
239 |
return ort_absolut(absort_fall, |
return ort_absolut(absort_fall, |
240 |
berechne_rechts(vonhieraus.rechts,mHaelfte), |
berechne_rechts(vonhieraus.rechts,mHaelfte), |
241 |
mXKoord->eval(fuer_code) % 2, 0); |
mXKoord->eval(fuer_code) & 1, 0); |
242 |
case absort_semiglobal: |
case absort_semiglobal: |
243 |
return ort_absolut(absort_semiglobal, |
return ort_absolut(absort_semiglobal, |
244 |
berechne_rechts(vonhieraus.rechts,mHaelfte), 0, 0); |
berechne_rechts(vonhieraus.rechts,mHaelfte), 0, 0); |
257 |
} |
} |
258 |
|
|
259 |
|
|
260 |
Ort::~Ort() { |
__String Ort::toString() const { |
261 |
if (mXKoord) delete mXKoord; |
__String ret; |
262 |
if (mYKoord) delete mYKoord; |
switch (mArt) { |
263 |
} |
case ortart_hier: |
264 |
|
ret.sprintf("@(0,0)"); |
265 |
|
break; |
266 |
|
case ortart_relativ_feld: |
267 |
|
ret.sprintf("@(x,y)"); |
268 |
|
break; |
269 |
|
case ortart_relativ_fall: |
270 |
|
ret.sprintf("@x"); |
271 |
|
break; |
272 |
|
case ortart_absolut: |
273 |
|
switch (mAbsArt) { |
274 |
|
case absort_feld: |
275 |
|
ret.sprintf("@@(x,y)"); |
276 |
|
break; |
277 |
|
case absort_fall: |
278 |
|
ret.sprintf("@@x"); |
279 |
|
break; |
280 |
|
case absort_semiglobal: |
281 |
|
ret.sprintf("@@"); |
282 |
|
break; |
283 |
|
case absort_global: |
284 |
|
ret.sprintf("@"); |
285 |
|
break; |
286 |
|
case absort_nirgends: |
287 |
|
ret.sprintf("@@-"); |
288 |
|
break; |
289 |
|
default: throw iFehler(_( |
290 |
|
"%s: Internal error in Ort::berechne(): Unbekannte Ort-Art %d"), |
291 |
|
mAbsArt); |
292 |
|
}; |
293 |
|
default: |
294 |
|
throw iFehler(_( |
295 |
|
"%s: Internal error in Ort::toString(): Unbekannte Ort-Art %d"), |
296 |
|
mArt); |
297 |
|
}; |
298 |
|
return ret; |
299 |
|
}; |
300 |
|
|