?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Reduce CPU usage
[hex-a-hop.git] / hex_puzzzle.cpp
blob21a796863381ae9694dfc0cb64dab3b8af9e6f93
1 /*
2 Copyright (C) 2005-2007 Tom Beaumont
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18
19
20 //////////////////////////////////////////////////////
21 // Config
22
23
24 #ifdef _DEBUG
25 #define EDIT
26 #endif
27
28 //#define MAP_LOCKED_VISIBLE
29
30 #define GAME_NAME "Hex-a-hop"
31
32 #ifdef EDIT
33 // #define MAP_EDIT_HACKS
34 #define MAP_EDIT_HACKS_DISPLAY_UNLOCK 0
35 #define CHEAT
36 #define BMP_SUFFIX ".bmp"
37 #else
38 #define USE_LEVEL_PACKFILE
39 #define BMP_SUFFIX ".dat"
40 #endif
41
42
43
44 #ifdef EDIT
45 #define GAMENAME GAME_NAME " (EDIT MODE)"
46 #endif
47 #ifndef GAMENAME
48 #define GAMENAME GAME_NAME
49 #endif
50
51 #define IMAGE_DAT_OR_MASK 0xff030303 // Reduce colour depth of images slightly for better compression (and remove useless top 8 bits!)
52 #define STARTING_LEVEL "Levels\\0_green\\triangular.lev"
53 #define UNLOCK_SCORING 75
54 const char * mapname = "Levels\\map_maybe\\map.lev";
55
56 //////////////////////////////////////////////////////
57
58
59
60 #ifndef USE_OPENGL
61
62 #include "state.h"
63
64 #include "tiletypes.h"
65
66 #ifdef USE_LEVEL_PACKFILE
67 #include "packfile.h"
68 #endif
69
70 void RenderTile(bool reflect, int t, int x, int y, int cliplift=-1);
71
72 int keyState[SDLK_LAST] = {0};
73
74 FILE *file_open( const char *file, const char *flags )
75 {
76 // printf("file_open( \"%s\", \"%s\" )\n", file, flags );
77 extern String base_path;
78 static String filename; // static to reduce memory alloc/free calls.
79 if (file[0]=='\0' || file[1]!=':') //If a full path is specified, don't prepend base_path
80 filename = base_path;
81 filename += file;
82 // printf(" -> \"%s\"\n", filename );
83
84 filename.fix_backslashes();
85 FILE* f = fopen( filename, flags );
86
87 if (!f)
88 {
89 printf("Warning: unable to open file \"%s\" for %s\n", (const char*)filename, strchr(flags, 'r') ? "reading" : "writing");
90 }
91
92 return f;
93 }
94
95
96 #ifdef MAP_EDIT_HACKS
97 static const short value_order[]={
98 //WALL,
99 //COLLAPSE_DOOR2,
100 //COLLAPSABLE3
101 //SWITCH
102 //EMPTY, NORMAL,
103
104 COLLAPSABLE,
105 TRAMPOLINE,
106 COLLAPSE_DOOR, COLLAPSABLE2,
107 GUN,
108 FLOATING_BALL,
109 SPINNER,
110 TRAP,
111 0x100,
112 LIFT_DOWN, LIFT_UP,
113 BUILDER,
114 0x200,
115 };
116 #endif
117
118 //#define PROGRESS_FILE "progress.dat"
119
120 #define PI (3.1415926535897931)
121 #define PI2 (PI*2)
122 #define MAX(a,b) ((a)>(b) ? (a) : (b))
123 #define MIN(a,b) ((a)<(b) ? (a) : (b))
124 #define ABS(a) ((a)<0 ? -(a) : (a))
125
126 #define WATER_COLOUR 31 | (IMAGE_DAT_OR_MASK>>16)&255, 37 | (IMAGE_DAT_OR_MASK>>8)&255, 135 | (IMAGE_DAT_OR_MASK>>0)&255
127
128 #define ROTATION_TIME 0.25
129 #define BUILD_TIME 1
130 #define LASER_LINE_TIME 0.7
131 #define LASER_FADE_TIME 0.1
132 #define LASER_SEGMENT_TIME 0.01
133 #define LIFT_TIME 0.5
134 #define JUMP_TIME 0.4
135
136 #define X(NAME,FILE,ALPHA) SDL_Surface* NAME = 0;
137 #include "gfx_list.h"
138 int scrollX=0, scrollY=0, initScrollX=0, initScrollY=0;
139 int mapRightBound = 0;
140 int mapScrollX = 0;
141 bool showScoring = false;
142 bool hintsDone = false;
143
144 enum {
145 TILE_SPLASH_1 = 17,
146 TILE_SPLASH_2,
147 TILE_SPLASH_3,
148
149 TILE_SPHERE = 20,
150 TILE_SPHERE_OPEN,
151 TILE_SPHERE_DONE,
152 TILE_SPHERE_PERFECT,
153 TILE_LOCK,
154
155 TILE_LIFT_BACK,
156 TILE_LIFT_FRONT,
157 TILE_LIFT_SHAFT,
158 TILE_BLUE_FRONT,
159 TILE_GREEN_FRONT,
160
161 TILE_LINK_0 = 30,
162 TILE_LINK_1,
163 TILE_LINK_2,
164 TILE_LINK_3,
165 TILE_LINK_4,
166 TILE_LINK_5,
167 TILE_GREEN_FRAGMENT,
168 TILE_GREEN_FRAGMENT_1,
169 TILE_GREEN_FRAGMENT_2,
170 TILE_ITEM2,
171
172 TILE_WATER_MAP = 40,
173 TILE_GREEN_CRACKED,
174 TILE_GREEN_CRACKED_WALL,
175 TILE_BLUE_CRACKED,
176 TILE_BLUE_CRACKED_WALL,
177 TILE_LASER_HEAD,
178 TILE_FIRE_PARTICLE_1,
179 TILE_FIRE_PARTICLE_2,
180 TILE_WATER_PARTICLE,
181
182 TILE_LASER_0 = 50,
183 TILE_LASER_FADE_0 = 53,
184 TILE_BLUE_FRAGMENT = 56,
185 TILE_BLUE_FRAGMENT_1,
186 TILE_BLUE_FRAGMENT_2,
187 TILE_ITEM1,
188 TILE_LASER_REFRACT = 60,
189 TILE_ICE_LASER_REFRACT = TILE_LASER_REFRACT+6,
190 TILE_WHITE_TILE,
191 TILE_WHITE_WALL,
192 TILE_BLACK_TILE,
193
194 };
195
196 const int colours[] = {
197 #define X(n,col, solid) col,
198 #include "tiletypes.h"
199 };
200
201 const int tileSolid[] = {
202 #define X(n,col, solid) solid,
203 #include "tiletypes.h"
204 };
205
206 void ChangeSuffix(char* filename, char* newsuffix)
207 {
208 int len = strlen(filename);
209 int i = len-1;
210 while (i>=0 && filename[i]!='\\' && filename[i]!='.' && filename[i]!='/')
211 i--;
212 if (filename[i]=='.')
213 strcpy(filename+i+1, newsuffix);
214 else
215 {
216 strcat(filename, ".");
217 strcat(filename, newsuffix);
218 }
219 }
220
221 bool isMap=false, isRenderMap=false;
222 int isFadeRendering=0;
223
224 /*
225 |--| |--| TILE_W1
226 |--------| TILE_W2
227 |-----| TILE_WL
228 |-----------| TILE_W3
229
230 *-----* - -
231 / \ |TILE_H1 |TILE_H2
232 / \ | |
233 * * - |
234 \ / |
235 \ / |
236 *-----* -
237
238 WL = sqrt(h1*h1 + w1*w1)
239 wl**2 = h1**2 + w1**2
240
241 w1 = sin60.wL
242
243 */
244
245 #if 1
246 #define TILE_W1 18
247 #define TILE_W3 64
248 #define GFX_SIZE TILE_W3
249 #define TILE_W2 (TILE_W3-TILE_W1)
250 #define TILE_H1 TILE_W1
251 #define TILE_HUP 22 //extra visible height of wall (used for determining whether a wall was clicked on)
252 #define TILE_H2 (TILE_H1*2)
253 #define TILE_WL (TILE_W2-TILE_W1)
254 #define TILE_H_LIFT_UP 26
255 #define TILE_H_REFLECT_OFFSET 24
256 #define TILE_HUP2 TILE_H_LIFT_UP // Displacement of object on top of wall
257 #define FONT_SPACING 25
258 #define FONT_X_SPACING (-1) // -1 in order to try and overlap the black borders of adjacent characters
259 #else
260 #define TILE_WL 30
261 #define TILE_W1 (TILE_WL/2)
262 #define TILE_W2 (TILE_W1+TILE_WL)
263 #define TILE_W3 (TILE_W1+TILE_W2)
264 #define TILE_H1 (TILE_WL*0.8660254037844386)
265 #define TILE_H2 (TILE_H1*2)
266 #endif
267
268 #define MAX_DIR 6
269
270 SDL_Rect font[256];
271 SDL_Rect tile[2][70];
272 short tileOffset[2][70][2];
273 int Peek(SDL_Surface* i, int x, int y)
274 {
275 if (x<0 || y<0 || x>=i->w || y>=i->h)
276 return 0;
277 unsigned int p=0;
278 const int BytesPerPixel = i->format->BytesPerPixel;
279 const int BitsPerPixel = i->format->BitsPerPixel;
280 if (BitsPerPixel==8)
281 p = ((unsigned char*)i->pixels)[i->pitch*y + x*BytesPerPixel];
282 else if (BitsPerPixel==15 || BitsPerPixel==16)
283 p = *(short*)(((char*)i->pixels) + (i->pitch*y + x*BytesPerPixel));
284 else if (BitsPerPixel==32)
285 p = *(unsigned int*)(((char*)i->pixels) + (i->pitch*y + x*BytesPerPixel));
286 else if (BitsPerPixel==24)
287 p = (int)((unsigned char*)i->pixels)[i->pitch*y + x*BytesPerPixel]
288 | (int)((unsigned char*)i->pixels)[i->pitch*y + x*BytesPerPixel] << 8
289 | (int)((unsigned char*)i->pixels)[i->pitch*y + x*BytesPerPixel] << 16;
290
291 return p;
292 }
293 bool IsEmpty(SDL_Surface* im, int x, int y, int w, int h)
294 {
295 for (int i=x; i<x+w; i++)
296 for (int j=y; j<y+h; j++)
297 if (Peek(im,i,j) != Peek(im,0,im->h-1))
298 return false;
299 return true;
300 }
301 void MakeFont()
302 {
303 memset(font, 0, sizeof(font));
304
305 int h = FONT_SPACING;
306 int x=-1, y=0;
307 for (int i=33; i<=127; i++)
308 {
309 do
310 {
311 x++;
312 if (x>=fontImage->w)
313 x=0, y+=h;
314 if (y >= fontImage->h)
315 return;
316 if (y+h > fontImage->h)
317 h = fontImage->h - y;
318 } while(IsEmpty(fontImage, x, y, 1, h));
319
320 int w=1;
321 while(!IsEmpty(fontImage, x+w, y, 1, h) && x+w<fontImage->w)
322 w++;
323 int h1=h;
324 while (h1>1 && IsEmpty(fontImage, x, y+h1-1, w, 1))
325 h1--;
326 font[i].x = x;
327 font[i].y = y;
328 font[i].w = w;
329 font[i].h = h1;
330 //printf("character %c: % 4d % 4d % 4d % 4d\n", i, x, y, w, h1);
331 x+=w;
332 }
333
334 int i=' ';
335 font[i].x = x;
336 font[i].y = y;
337 font[i].w = font['j'].w;
338 font[i].h = 0;
339 }
340 void MakeTileInfo()
341 {
342 for (int i=0; i<140; i++)
343 {
344 SDL_Rect r = {(i%10)*GFX_SIZE, ((i/10)%7)*GFX_SIZE, GFX_SIZE, GFX_SIZE};
345 short * outOffset = tileOffset[i/70][i%70];
346 SDL_Surface * im = (i/70) ? tileGraphicsR : tileGraphics;
347
348 outOffset[0] = outOffset[1] = 0;
349
350 while (r.h>1 && IsEmpty(im, r.x, r.y, r.w, 1)) r.h--, r.y++, outOffset[1]++;
351 while (r.h>1 && IsEmpty(im, r.x, r.y+r.h-1, r.w, 1)) r.h--;
352 while (r.w>1 && IsEmpty(im, r.x, r.y, 1, r.h)) r.w--, r.x++, outOffset[0]++;
353 while (r.w>1 && IsEmpty(im, r.x+r.w-1, r.y, 1, r.h)) r.w--;
354
355 tile[i/70][i%70] = r;
356 }
357 }
358
359 void PrintRaw(int x, int y, const char * tmp)
360 {
361 for (int i=0; tmp[i]; i++)
362 {
363 SDL_Rect dst = {x, y, 1, 1};
364 SDL_BlitSurface(fontImage, &font[tmp[i]], screen, &dst);
365 x += font[tmp[i]].w + FONT_X_SPACING;
366 }
367 }
368
369 void Print(int x, int y, const char * string, ...)
370 {
371 va_list marker;
372 va_start( marker, string ); /* Initialize variable arguments. */
373
374 char tmp[1000];
375 vsprintf((char*)tmp, string, marker);
376
377 PrintRaw(x, y, tmp);
378
379 va_end( marker ); /* Reset variable arguments. */
380 }
381
382 int FontWidth(const char * string)
383 {
384 int w = 0;
385 for (int i=0; string[i]; i++)
386 w += font[string[i]].w + FONT_X_SPACING;
387 return w;
388 }
389
390 void PrintR(int x, int y, const char * string, ...)
391 {
392 va_list marker;
393 va_start( marker, string ); /* Initialize variable arguments. */
394
395 char tmp[1000];
396 vsprintf((char*)tmp, string, marker);
397
398 PrintRaw(x-FontWidth(tmp), y, tmp);
399
400 va_end( marker ); /* Reset variable arguments. */
401 }
402
403 void PrintC(bool split, int x, int y, const char * string, ...)
404 {
405 va_list marker;
406 va_start( marker, string ); /* Initialize variable arguments. */
407
408 char tmp[1000];
409 vsprintf((char*)tmp, string, marker);
410
411 char* scan = tmp;
412 while (1)
413 {
414 char * end = split ? strstr(scan," ") : 0;
415 if (!end)
416 {
417 PrintRaw(x - FontWidth(scan)/2, y, scan);
418 break;
419 }
420 else
421 {
422 *end = '\0';
423 PrintRaw(x - FontWidth(scan)/2, y, scan);
424 scan = end+2;
425 y += FONT_SPACING;
426 }
427 }
428
429 va_end( marker ); /* Reset variable arguments. */
430 }
431
432
433 #include "savestate.h"
434 #include "menus.h"
435 #include "level_list.h"
436
437 void SaveState::GetStuff()
438 {
439 general.hintFlags = HintMessage::flags;
440 }
441 void SaveState::ApplyStuff()
442 {
443 HintMessage::flags = general.hintFlags;
444 }
445
446
447 typedef int Tile;
448 typedef int Dir;
449 struct Pos{
450 int x,y;
451 Pos() : x(0), y(0) {}
452 Pos(int a, int b) : x(a), y(b) {}
453 bool operator == (Pos const & p) const
454 {
455 return x==p.x && y==p.y;
456 }
457 Pos operator + (Dir const d) const
458 {
459 return Pos(
460 x + ((d==1 || d==2) ? 1 : (d==4 || d==5) ? -1 : 0),
461 y + ((d==0 || d==1) ? -1 : (d==3 || d==4) ? 1 : 0)
462 );
463 }
464 int getScreenX() const {
465 return x*TILE_W2;
466 }
467 int getScreenY() const {
468 return x*TILE_H1 + y*TILE_H2;
469 }
470 static Pos GetFromWorld(double x, double y)
471 {
472 x += TILE_W3/2;
473 y += TILE_H1;
474 int tx, ty;
475 tx = (int)floor(x/TILE_W2);
476 y -= tx*TILE_H1;
477 ty = (int)floor(y/TILE_H2);
478
479 y -= ty * TILE_H2;
480 x -= tx * TILE_W2;
481
482 if (x < TILE_W1 && y < TILE_H1)
483 if (x*TILE_H1 + y * TILE_W1 < TILE_H1*TILE_W1)
484 tx--;
485 if (x < TILE_W1 && y > TILE_H1)
486 if (x*TILE_H1 + (TILE_H2-y) * TILE_W1 < TILE_H1*TILE_W1)
487 tx--, ty++;
488
489 return Pos(tx, ty);
490 }
491 };
492 Pos mousep(0,0), keyboardp(4,20);
493
494 class RenderObject;
495
496 struct RenderStage
497 {
498 virtual void Render(RenderObject* r, double time, bool reflect) = 0;
499 virtual int GetDepth(double time) { return 1; }
500 };
501
502 class RenderObject
503 {
504 RenderStage** stage;
505 double* time;
506 int numStages;
507 int maxStages;
508 int currentStage;
509 public:
510 double seed;
511 double currentTime;
512 private:
513
514 void Reserve()
515 {
516 if (maxStages <= numStages)
517 {
518 maxStages = maxStages ? maxStages*2 : 4;
519 stage = (RenderStage**) realloc(stage, sizeof(stage[0])*maxStages);
520 time = (double*) realloc(time, sizeof(time[0])*maxStages);
521 }
522 }
523 public:
524 RenderObject() : stage(0), time(0), numStages(0), maxStages(0), currentStage(0)
525 {
526 // TODO: use a random number with better range
527 // or maybe make seed an int or float...
528 seed = rand() / (double)RAND_MAX;
529 }
530 ~RenderObject()
531 {
532 free(stage); free(time);
533 }
534 bool Active(double t)
535 {
536 if (numStages==0) return false;
537 if (t < time[0]) return false;
538 return true;
539 }
540 void UpdateCurrent(double t)
541 {
542 if (currentStage >= numStages) currentStage = numStages-1;
543 if (currentStage < 0) currentStage = 0;
544
545 while (currentStage>0 && time[currentStage]>t)
546 currentStage--;
547 while (currentStage<numStages-1 && time[currentStage+1]<=t)
548 currentStage++;
549
550 currentTime = t;
551 }
552 RenderStage* GetStage(double t)
553 {
554 if (t==-1 && numStages>0)
555 return stage[numStages-1];
556
557 if (!Active(t)) return 0;
558 UpdateCurrent(t);
559 return stage[currentStage];
560 }
561 double GetLastTime()
562 {
563 return numStages>0 ? time[numStages-1] : -1;
564 }
565 void Render(double t, bool reflect)
566 {
567 if (!Active(t))
568 return;
569 UpdateCurrent(t);
570 stage[currentStage]->Render(this, t - time[currentStage], reflect);
571 }
572 int GetDepth(double t)
573 {
574 if (!Active(t))
575 return -1;
576 UpdateCurrent(t);
577 return stage[currentStage]->GetDepth(t - time[currentStage]);
578 }
579 void Reset(double t)
580 {
581 if (t<0)
582 numStages = currentStage = 0;
583 else
584 {
585 while (numStages > 0 && time[numStages-1] >= t)
586 numStages--;
587 }
588 }
589 void Wipe()
590 {
591 if (currentStage > 0 && numStages > 0)
592 {
593 memmove(&time[0], &time[currentStage], sizeof(time[0]) * numStages-currentStage);
594 memmove(&stage[0], &stage[currentStage], sizeof(stage[0]) * numStages-currentStage);
595 numStages -= currentStage;
596 currentStage = 0;
597 }
598 }
599 void Add(RenderStage* s, double t)
600 {
601 int i=0;
602
603 if (currentStage<numStages && time[currentStage]<=t)
604 i = currentStage;
605
606 while (i<numStages && time[i]<t)
607 i++;
608
609 if (i<numStages && time[i]==t)
610 stage[i]=s;
611 else
612 {
613 Reserve();
614
615 if (i<numStages)
616 {
617 memmove(&time[i+1], &time[i], (numStages-i) * sizeof(time[0]));
618 memmove(&stage[i+1], &stage[i], (numStages-i) * sizeof(stage[0]));
619 }
620
621 numStages++;
622 time[i] = t;
623 stage[i] = s;
624 }
625 }
626 };
627
628 class WorldRenderer
629 {
630 #define SIZE 30
631 #define FX 10
632 RenderObject tile[SIZE][SIZE][2];
633 RenderObject fx[FX];
634 int fxPos;
635
636 public:
637 RenderObject player;
638 RenderObject dummy;
639
640 WorldRenderer()
641 {
642 Reset();
643 }
644
645 void Reset(double t = -1)
646 {
647 fxPos = 0;
648 player.Reset(t);
649 dummy.Reset(-1);
650
651 for (int i=0; i<SIZE; i++)
652 for (int j=0; j<SIZE; j++)
653 for (int q=0; q<2; q++)
654 tile[i][j][q].Reset(t);
655
656 for (int j=0; j<FX; j++)
657 fx[j].Reset(t);
658 }
659
660 void Wipe()
661 {
662 player.Wipe();
663 dummy.Reset(-1);
664
665 for (int i=0; i<SIZE; i++)
666 for (int j=0; j<SIZE; j++)
667 for (int q=0; q<2; q++)
668 tile[i][j][q].Wipe();
669
670 for (int j=0; j<FX; j++)
671 fx[j].Wipe();
672 }
673
674 bool Visible(Pos p)
675 {
676 int x0 = (scrollX+TILE_W2) / TILE_W2;
677 int x1 = (scrollX+SCREEN_W+TILE_W3+TILE_W1) / TILE_W2;
678 if (p.x<0 || p.y<0 || p.x>=SIZE || p.y>=SIZE) return false;
679 if (p.x<x0) return false;
680 if (p.x>=x1-1) return false;
681 for (int j0=0; j0<SIZE*3; j0++)
682 {
683 if (j0 * TILE_H1 < scrollY-TILE_H1) continue;
684 if (j0 * TILE_H1 > scrollY+SCREEN_H+TILE_H1) break;
685 int i = j0&1;
686 int j = j0>>1;
687 j -= (x0-i)/2;
688 i += (x0-i)/2*2;
689 if (j>=SIZE) i+=(j+1-SIZE)*2, j=SIZE-1;
690 for (; i<x1 && j>=0; i+=2, j--)
691 {
692 if (Pos(i,j)==p)
693 return true;
694 }
695 }
696 return false;
697 }
698
699 void Render(double t, bool reflect)
700 {
701 dummy.Reset(-1);
702
703 int playerDepth = player.GetDepth(t);
704 if (reflect) playerDepth-=4;
705 if (playerDepth<0)
706 player.Render(t, reflect);
707
708 int x0 = (scrollX+TILE_W2) / TILE_W2;
709 int x1 = (scrollX+SCREEN_W+TILE_W3+TILE_W1) / TILE_W2;
710 x0 = MAX(x0, 0);
711 x1 = MIN(x1, SIZE);
712 for (int j0=0; j0<SIZE*3; j0++)
713 {
714 if (j0 * TILE_H1 < scrollY-TILE_H1) continue;
715 if (j0 * TILE_H1 > scrollY+SCREEN_H+TILE_H1) break;
716 int i = j0&1;
717 int j = j0>>1;
718 j -= (x0-i)/2;
719 i += (x0-i)/2*2;
720 if (j>=SIZE) i+=(j+1-SIZE)*2, j=SIZE-1;
721 for (; i<x1 && j>=0; i+=2, j--)
722 {
723 for (int q=reflect?1:0; q!=2 && q!=-1; q += (reflect ? -1 : 1))
724 if (tile[i][j][q].Active(t))
725 {
726 tile[i][j][q].Render(t, reflect);
727 }
728 }
729
730 if (playerDepth==j0 || j0==SIZE*3 && playerDepth>j0)
731 player.Render(t, reflect);
732 }
733
734 for (int j=0; j<FX; j++)
735 if(fx[j].Active(t))
736 {
737 fx[j].Render(t, reflect);
738 }
739
740 }
741 RenderObject & operator () ()
742 {
743 fxPos++;
744 if (fxPos==FX) fxPos = 0;
745 return fx[fxPos];
746 }
747 RenderObject & operator () (Pos const & p, bool item=false)
748 {
749 if (p.x<0 || p.y<0 || p.x>=SIZE || p.y>=SIZE)
750 return dummy;
751 return tile[p.x][p.y][item ? 1 : 0];
752 }
753 };
754
755 void RenderTile(bool reflect, int t, int x, int y, int cliplift)
756 {
757 SDL_Rect src = tile[reflect][t];
758 SDL_Rect dst = {x-scrollX-GFX_SIZE/2, y-scrollY-GFX_SIZE+TILE_H1};
759 dst.x += tileOffset[reflect][t][0];
760 dst.y += tileOffset[reflect][t][1];
761 if (reflect)
762 dst.y += TILE_H_REFLECT_OFFSET;
763 if (cliplift==-1 || reflect)
764 {
765 // dst.w=src.w; dst.h=src.h;
766 // SDL_FillRect(screen, &dst, rand());
767 SDL_BlitSurface(reflect ? tileGraphicsR : tileGraphics, &src, screen, &dst);
768 }
769 else
770 {
771 src.h -= cliplift;
772 if (src.h > TILE_W1)
773 {
774 src.h -= TILE_W1/2;
775 SDL_BlitSurface(tileGraphics, &src, screen, &dst);
776 src.y += src.h;
777 dst.y += src.h;
778 src.h = TILE_W1/2;
779 }
780 if (src.h > 0)
781 {
782 src.w -= TILE_W1*2, src.x += TILE_W1;
783 dst.x += TILE_W1;
784 SDL_BlitSurface(tileGraphics, &src, screen, &dst);
785 }
786 }
787 }
788 void RenderGirl(bool reflect, int r, int frame, int x, int y, int h)
789 {
790 int sx = r * 64;
791 int sy = frame * 80*2;
792 if (reflect)
793 y += TILE_H_REFLECT_OFFSET+20+h, sy += 80;
794 else
795 y -= h;
796 SDL_Rect src = {sx, sy, 64, 80};
797 SDL_Rect dst = {x-scrollX-32, y-scrollY-65};
798 SDL_BlitSurface(girlGraphics, &src, screen, &dst);
799 }
800
801 struct ItemRender : public RenderStage
802 {
803 int item;
804 Pos p;
805 int water;
806
807 ItemRender(int i2, int _water, Pos const & _p) : item(i2), p(_p), water(_water)
808 {}
809
810 double Translate(double seed, double time)
811 {
812 double bob = time*2 + seed*PI2;
813 return sin(bob)*4;
814 }
815
816 void Render(RenderObject* r, double time, bool reflect)
817 {
818 if (item==0)
819 return;
820
821 int y = -5 + (int)Translate(r->seed, r->currentTime + time);
822 if (reflect)
823 y=-y;
824 if (!reflect && !water)
825 RenderTile( false, TILE_SPHERE, p.getScreenX(), p.getScreenY());
826 RenderTile(
827 reflect,
828 item==1 ? TILE_ITEM1 : TILE_ITEM2,
829 p.getScreenX(), p.getScreenY()+y
830 );
831 }
832 };
833
834 void RenderFade(double time, int dir, int seed)
835 {
836 int ys=0;
837 srand(seed);
838 for(int x=rand()%22-11; x<SCREEN_W+22; x+=32, ys ^= 1)
839 {
840 for (int y=ys*20; y<SCREEN_H+30; y+=40)
841 {
842 double a = (rand()&0xff)*dir;
843 double b = (time * 0x400 + (y - SCREEN_H) * 0x140/SCREEN_H)*dir;
844 if (a >= b)
845 {
846 RenderTile(false, TILE_BLACK_TILE, x+scrollX, y+scrollY);
847 }
848 }
849 }
850 }
851
852 struct FadeRender : public RenderStage
853 {
854 int seed;
855 int dir;
856 FadeRender(int d=-1) : seed(rand()), dir(d)
857 {
858 isFadeRendering = d;
859 }
860
861 void Render(RenderObject* r, double time, bool reflect)
862 {
863 if (reflect) return;
864 if (time > 0.5)
865 {
866 if (dir==1) dir=0, isFadeRendering=0;
867 return;
868 }
869 RenderFade(time, dir, seed);
870 }
871 };
872
873 struct ScrollRender : public RenderStage
874 {
875 int x,y;
876 bool done;
877 ScrollRender(int a,int b) : x(a), y(b), done(false) {}
878
879 void Render(RenderObject* r, double time, bool reflect)
880 {
881 if (done) return;
882 scrollX = x, scrollY = y;
883 isRenderMap = isMap;
884 done = true;
885 }
886 };
887
888 struct LevelSelectRender : public RenderStage
889 {
890 Pos p;
891 int item;
892 int adj;
893 #ifdef MAP_EDIT_HACKS
894 int magic;
895 #endif
896
897 LevelSelectRender(Pos const & _p, int i2, int adj) : p(_p), item(i2), adj(adj)
898 {}
899
900 void Render(RenderObject* r, double time, bool reflect)
901 {
902 if (item==0)
903 return;
904
905 #ifndef MAP_LOCKED_VISIBLE
906 if (item==1) return;
907 #endif
908
909 if (!reflect && adj)
910 for (int i=0; i<MAX_DIR; i++)
911 if (adj & (1 << i))
912 RenderTile( false, TILE_LINK_0+i, p.getScreenX(), p.getScreenY());
913
914 if (item < 0)
915 return;
916
917 if (!reflect)
918 {
919 RenderTile(
920 reflect,
921 TILE_SPHERE + item-1,
922 p.getScreenX(), p.getScreenY()
923 );
924
925 #ifdef MAP_EDIT_HACKS
926 int x = p.getScreenX()-scrollX, y = p.getScreenY()-scrollY;
927 Print(x+5,y-25,"%d",magic);
928 #endif
929 }
930 }
931 };
932
933 struct ItemCollectRender : public ItemRender
934 {
935 ItemCollectRender(int i2, Pos const & p) : ItemRender(i2, 0, p)
936 {}
937
938 void Render(RenderObject* r, double time, bool reflect)
939 {
940 }
941 };
942
943 int GetLiftHeight(double time, int t)
944 {
945 if (t==LIFT_UP)
946 time = LIFT_TIME-time;
947 time = time / LIFT_TIME;
948 if (time > 1)
949 time = 1;
950 if (time < 0)
951 time = 0;
952 time = (3 - 2*time)*time*time;
953 if (t==LIFT_UP)
954 time = (3 - 2*time)*time*time;
955 if (t==LIFT_UP)
956 return (int)((TILE_H_LIFT_UP+4) * time);
957 else
958 return (int)((TILE_H_LIFT_UP-4) * time) + 4;
959 }
960
961 struct TileRender : public RenderStage
962 {
963 int special;
964 int t;
965 Pos p;
966 double specialDuration;
967
968 TileRender(int i, Pos const & _p, int _special=0) : t(i), p(_p), special(_special), specialDuration(LASER_LINE_TIME)
969 {}
970
971 void Render(RenderObject* r, double time, bool reflect)
972 {
973 if (t==0 && special==0)
974 return;
975
976 if (special && (t==LIFT_UP || t==LIFT_DOWN) && time<LIFT_TIME)
977 {
978 int y = GetLiftHeight(time, t);
979 if (!reflect)
980 {
981 RenderTile(reflect, TILE_LIFT_BACK, p.getScreenX(), p.getScreenY());
982 RenderTile(reflect, TILE_LIFT_SHAFT, p.getScreenX(), p.getScreenY()+y, y-8);
983 RenderTile(reflect, TILE_LIFT_FRONT, p.getScreenX(), p.getScreenY());
984 }
985 else
986 {
987 RenderTile(reflect, TILE_LIFT_SHAFT, p.getScreenX(), p.getScreenY()-y, y);
988 RenderTile(reflect, LIFT_DOWN, p.getScreenX(), p.getScreenY());
989 }
990 }
991 else if (special && (t==EMPTY || t==TRAP) && !reflect && time < specialDuration)
992 {
993 if (t == TRAP)
994 if (time < specialDuration-LASER_FADE_TIME)
995 RenderTile(reflect, TILE_ICE_LASER_REFRACT, p.getScreenX(), p.getScreenY());
996 else
997 RenderTile(reflect, t, p.getScreenX(), p.getScreenY());
998 int base = ((t==EMPTY) ? TILE_LASER_0 : TILE_LASER_REFRACT);
999 if (t==EMPTY && time >= specialDuration-LASER_FADE_TIME)
1000 base = TILE_LASER_FADE_0;
1001
1002 int foo=special;
1003 for(int i=0; foo; foo>>=1, i++)
1004 if (foo & 1)
1005 RenderTile(reflect, base+i, p.getScreenX(), p.getScreenY());
1006 }
1007 else if (t==FLOATING_BALL)
1008 {
1009 int y = int(1.8 * sin(r->seed*PI + time*4));
1010 if (special==512)
1011 {
1012 if (time > 2) return;
1013 if (reflect) return;
1014 srand(int(r->seed * 0xfff));
1015 for (int i=0; i<20 - int(time*10); i++)
1016 {
1017 int x = int((((rand() & 0xfff) - 0x800) / 10) * time);
1018 int y = int((((rand() & 0xfff) - 0x800) / 10) * time);
1019 RenderTile(true, 19 + ((i+int(time*5))&1)*10, p.getScreenX() + x, p.getScreenY() - 14 + y);
1020 }
1021
1022 if (time < 0.05)
1023 RenderTile(true, 18, p.getScreenX(), p.getScreenY() - 14);
1024 }
1025 else if (special)
1026 RenderBoat(reflect, int(special)&255, p.getScreenX(), p.getScreenY(), y);
1027 else
1028 RenderTile(reflect, t, p.getScreenX(), p.getScreenY() + (reflect ? -y : y));
1029 }
1030 else if (t != EMPTY)
1031 RenderTile(reflect, t, p.getScreenX(), p.getScreenY());
1032 }
1033 static void RenderBoat(bool reflect, int d, int x, int y, int yo)
1034 {
1035 if (reflect)
1036 RenderGirl(reflect, d, 0, x, y, -yo);
1037 RenderTile(reflect, FLOATING_BALL, x, y+yo);
1038 if (!reflect)
1039 {
1040 RenderGirl(reflect, d, 0, x, y, -yo);
1041 RenderTile(true, 17, x, y+yo-TILE_H_REFLECT_OFFSET);
1042 }
1043 }
1044 };
1045
1046 struct TileRotateRender : public TileRender
1047 {
1048 Dir d;
1049 // int range;
1050 int mode;
1051 TileRotateRender(int i, Pos const & p, Dir _d, int m) : TileRender(i, p), d(_d), mode(m)
1052 {}
1053 void Render(RenderObject* r, double time, bool reflect)
1054 {
1055 if (t==0)
1056 return;
1057 double f = time / ROTATION_TIME;
1058
1059 if (mode & 1) f += 0.5;
1060 if (f<1 && f>0)
1061 {
1062 if (mode & 2)
1063 ;
1064 else
1065 f = (3-2*f)*f*f;
1066 }
1067
1068 if (mode & 1) f=1-f; else f=f;
1069 if (f<0) f=0;
1070
1071 if (f >= 1)
1072 TileRender::Render(r, time, reflect);
1073 else
1074 {
1075 Pos dd = (Pos(0,0)+d);
1076 int x = p.getScreenX() + int(dd.getScreenX()*(f));
1077 int y = p.getScreenY() + int(dd.getScreenY()*(f));
1078
1079 if (mode & 2)
1080 RenderBoat(reflect, (mode&1) ? (d+MAX_DIR/2)%MAX_DIR : d, x, y, 2);
1081 else
1082 RenderTile(reflect, t, x, y);
1083 }
1084 }
1085 };
1086
1087 struct LaserRender : public RenderStage
1088 {
1089 Pos p;
1090 Dir d;
1091 int range;
1092
1093 LaserRender(Pos _p, int dir, int r) : p(_p), d(dir), range(r)
1094 {}
1095
1096 void Render(RenderObject* r, double time)
1097 {
1098 }
1099 };
1100
1101 struct ExplosionRender : public RenderStage
1102 {
1103 Pos p;
1104 int seed;
1105 int power;
1106 int type;
1107
1108 ExplosionRender(Pos _p, int _pow=0, int t=0) : p(_p), power(_pow), type(t)
1109 {
1110 seed = rand();
1111 }
1112
1113 virtual int GetDepth(double time)
1114 {
1115 return p.x + p.y*2;
1116 }
1117
1118 void Render(RenderObject* r, double time, bool reflect)
1119 {
1120 if (type==1 && time > 2.5)
1121 type = -1, new WinLoseScreen(false);
1122
1123 // if (reflect) return;
1124 if (time > 3) return;
1125 srand(seed);
1126 int q = 50 - int(time * 35);
1127 if (power) q*=2;
1128 if (type) q = 50;
1129 for (int i=0; i<q; i++)
1130 {
1131 int x = p.getScreenX();
1132 int y = p.getScreenY() + (rand() & 31)-16;
1133 int xs = ((rand() & 63) - 32);
1134 int ys = (-10 - (rand() & 127)) * (1+power);
1135 if (type) ys*=2, xs/=2;
1136 x += int(xs * (1+time*(2+power)));
1137 int yo = int(time*time*128 + ys*time);
1138 //if (yo > 0) yo=-yo;//continue;
1139 if (type)
1140 {
1141
1142 if (yo > 0)
1143 {
1144 if (!reflect && ys<-60)
1145 {
1146 const double T = 0.06;
1147 double ct = -ys / 128.0;
1148 if (time < ct+T*4)
1149 {
1150 x = p.getScreenX() + int(xs * (1+ct*(2+power)));
1151 RenderTile(
1152 reflect,
1153 time > ct+3*T ? TILE_SPLASH_3 : time > ct+2*T ? TILE_SPLASH_2 : time > ct+T ? TILE_SPLASH_1 : TILE_WATER_PARTICLE+1,
1154 x, y);
1155 }
1156 }
1157 }
1158 else
1159 RenderTile(
1160 reflect,
1161 time - i*0.003 < 0.2 ? TILE_WATER_PARTICLE+1 : TILE_WATER_PARTICLE,
1162 x, y+(reflect?-1:1)*yo);
1163 }
1164 else
1165 {
1166 if (yo > 0)
1167 ;
1168 else
1169 RenderTile(
1170 reflect,
1171 i<q-20 || time<0.3 ? TILE_LASER_HEAD : i<q-10 || time<0.6 ? TILE_FIRE_PARTICLE_1 : TILE_FIRE_PARTICLE_2,
1172 x, y+(reflect?-1:1)*yo);
1173 }
1174 }
1175 }
1176 };
1177 struct DisintegrateRender : public RenderStage
1178 {
1179 Pos p;
1180 int seed;
1181 int height;
1182 int type;
1183
1184 DisintegrateRender(Pos _p, int _pow=0, int _t=0) : p(_p), height(_pow), type(_t)
1185 {
1186 seed = rand();
1187 }
1188
1189 void Render(RenderObject* r, double time, bool reflect)
1190 {
1191 if (type)
1192 RenderTile(reflect, height ? COLLAPSE_DOOR : COLLAPSABLE, p.getScreenX(), p.getScreenY());
1193
1194 if (time > 50.0/70.0) return;
1195 if (reflect) return;
1196 srand(seed);
1197 int q = 50 - int(time * 70);
1198 if (height) q*=2;
1199 for (int i=0; i<q; i++)
1200 {
1201 int x = (rand() % (TILE_W3-8))-TILE_W3/2+4;
1202 int y = (rand() % (TILE_H2-8))-TILE_H1+4;
1203 if (x<-TILE_WL/2 && ABS(y)<-TILE_WL/2-x) continue;
1204 if (x>TILE_WL/2 && ABS(y)>x-TILE_WL/2) continue;
1205 int yo=0;
1206 if (height) yo -= rand() % TILE_HUP;
1207 x += p.getScreenX();
1208 y += p.getScreenY() + 4;
1209 int xs = 0;//((rand() & 63) - 32);
1210 int ys = (- (rand() & 31));
1211 x += int(xs * (1+time*(2)));
1212 if (type) yo = -yo;
1213 yo += int(time*time*128 + ys*time);
1214 if (type) yo = -yo*2;
1215 //if (yo > 0) yo=-yo;//continue;
1216 int t = type ? TILE_BLUE_FRAGMENT : TILE_GREEN_FRAGMENT;
1217 if (i>q-20) t++;
1218 if (i>q-10) t++;
1219 if (yo > 5) yo = 5;
1220 RenderTile(false, t, x, y+(reflect?-yo:yo));
1221 }
1222 }
1223 };
1224 struct BuildRender : public RenderStage
1225 {
1226 Pos p;
1227 Dir dir;
1228 int reverse;
1229 int height;
1230 int type;
1231
1232 BuildRender(Pos _p, Dir _d, int _h, int _r=0, int _type=0) : p(_p), dir(_d), height(_h), reverse(_r), type(_type)
1233 {
1234 }
1235
1236 void Render(RenderObject* r, double time, bool reflect)
1237 {
1238 if (time >= BUILD_TIME)
1239 RenderTile(reflect, height ^ reverse ? (type ? COLLAPSE_DOOR2 : COLLAPSE_DOOR) : (type ? COLLAPSABLE2 : COLLAPSABLE), p.getScreenX(), p.getScreenY());
1240 else
1241 {
1242 if (height)
1243 RenderTile(reflect, type ? COLLAPSABLE2 : COLLAPSABLE, p.getScreenX(), p.getScreenY());
1244
1245 double dist = time * 2 / BUILD_TIME;
1246 if (dir>-1)
1247 {
1248 Pos from = p + ((dir+MAX_DIR/2)%MAX_DIR);
1249 if (dist <= 1)
1250 //if (dist > 1)
1251 {
1252 double offset = (dist*0.7) + 0.3;
1253 int x = from.getScreenX() + int((p.getScreenX()-from.getScreenX()) * offset);
1254 int y = from.getScreenY() + int((p.getScreenY()-from.getScreenY()) * offset - dist*(1-dist)*(TILE_HUP*4));
1255 RenderTile(reflect, TILE_GREEN_FRAGMENT, x, y);
1256 }
1257 dist -= 1;
1258 }
1259 else
1260 {
1261 if (reverse) dist = 1-dist;
1262 }
1263 if (dist > 0 && !height)
1264 {
1265 if (!reflect)
1266 for (int i=0; i<=int(dist*15); i++)
1267 {
1268 int x = p.getScreenX(), y = p.getScreenY();
1269 double d = (i + fmod(dist*15, 1))/10.0;
1270 int x1 = int(sin(d*5+time)*MIN(d,1)*TILE_W2/2);
1271 int y1 = int(cos(d*5+time)*MIN(d,1)*TILE_H1*0.7);
1272 RenderTile(reflect, TILE_GREEN_FRAGMENT, x+x1, y+y1+4);
1273 RenderTile(reflect, TILE_GREEN_FRAGMENT, x-x1, y-y1+4);
1274 }
1275 }
1276 if (dist > 0 && height)
1277 {
1278 int yo = int((1-dist)*(TILE_HUP*1.3));
1279 if (yo > TILE_HUP*1.1)
1280 RenderTile(reflect, TILE_WHITE_TILE, p.getScreenX(), p.getScreenY());
1281 else if (!reflect)
1282 {
1283 RenderTile(reflect, type ? COLLAPSABLE2 : COLLAPSABLE, p.getScreenX(), p.getScreenY());
1284 RenderTile(reflect, type ? COLLAPSE_DOOR2 : COLLAPSE_DOOR, p.getScreenX(), p.getScreenY()+(reflect ? -yo : yo), yo+6);
1285 RenderTile(reflect, type ? TILE_BLUE_FRONT : TILE_GREEN_FRONT, p.getScreenX(), p.getScreenY());
1286 }
1287 else
1288 {
1289 if (yo < TILE_HUP/2)
1290 {
1291 RenderTile(reflect, type ? COLLAPSE_DOOR2 : COLLAPSE_DOOR, p.getScreenX(), p.getScreenY()+(reflect ? -yo : yo), yo);
1292
1293 }
1294 RenderTile(reflect, type ? COLLAPSABLE2 : COLLAPSABLE, p.getScreenX(), p.getScreenY());
1295
1296 }
1297 }
1298 }
1299 }
1300 };
1301
1302 struct PlayerRender : public RenderStage
1303 {
1304 Pos p;
1305 Pos target;
1306 int p_h, target_h;
1307 int r;
1308 int type;
1309 double speed;
1310 bool dead;
1311
1312 PlayerRender(Pos a, int h, bool d) : p(a), dead(d), target(a), speed(0), p_h(h), target_h(h), r(3), type(0)
1313 {}
1314 PlayerRender(int _r, Pos a, int h1, Pos t, int h2, bool d) : p(a), dead(d), target(t), speed(JUMP_TIME), p_h(h1), target_h(h2), r(_r), type(0)
1315 {
1316 int dist = MAX(ABS(p.x-target.x), ABS(p.y-target.y));
1317 if (dist > 1)
1318 speed *= 1.5;
1319 if(dist==0)
1320 speed = 0;
1321 }
1322
1323 virtual int GetDepth(double time)
1324 {
1325 double f = speed ? time / speed : 1;
1326 if (f>1) f=1;
1327 if (f==1) dead = this->dead;
1328
1329 double x = p.x + (target.x - p.x) * f;
1330 double y = p.y + (target.y - p.y) * f;
1331
1332 if (f==1 || f>0.5 && p_h>target_h)
1333 return target.x+target.y*2;
1334 return MAX(target.x+target.y*2 , p.x+p.y*2);
1335 }
1336
1337 void Render(RenderObject* ro, double time, bool reflect)
1338 {
1339 bool dead = false;
1340 double f = speed ? time / speed : 1;
1341 if (f>1) f=1;
1342 if (f==1) dead = this->dead;
1343
1344 int x = p.getScreenX();
1345 int y = p.getScreenY();
1346 int x2 = target.getScreenX();
1347 int y2 = target.getScreenY();
1348 int h = 0;
1349 int shadow_h = (int)((p_h+(target_h-p_h)*f)*TILE_HUP2);
1350
1351 if (x==x2 && y==y2 && p_h!=target_h)
1352 {
1353 h = TILE_H_LIFT_UP - GetLiftHeight(time, p_h ? LIFT_DOWN : LIFT_UP);
1354 }
1355 else
1356 {
1357
1358 int dist = MAX(ABS(p.x-target.x), ABS(p.y-target.y));
1359 int arc = dist*dist;
1360 int h1 = p_h * TILE_HUP2;;
1361 int h2 = target_h * TILE_HUP2;
1362 if (dist==2 && h1!=0)
1363 {
1364 arc += h2 ? 1 : 3;
1365 h1 = 0;
1366 shadow_h = f>=0.7 ? int(shadow_h*(f-0.7)/0.3) : 0;
1367 }
1368 if (dist==0)
1369 arc = speed > JUMP_TIME ? 7 : 2;
1370
1371 h = (int)(h1+(h2-h1)*f);
1372 // if (x==x2 && y==y2)
1373 // ;
1374 // else
1375 {
1376 //h += int(TILE_H_LIFT_UP/3 * (1-f));
1377 h += (int)(f*(1-f)*TILE_HUP2*arc);
1378 }
1379
1380 if (type==2)
1381 h=0;
1382 }
1383
1384 if (!dead)
1385 {
1386 int frame = 0;
1387 if (type==2 && f<1)
1388 {
1389 //frame = ((int)(f*4) % 4);
1390 //if (frame==2) frame=0; else if (frame==3) frame=2;
1391 frame = 0;
1392 }
1393 else if (f==1 || x==x2 && y==y2) // stationary
1394 frame = 0;
1395 else if (f > 0.7)
1396 frame = 0;
1397 else
1398 {
1399 frame = type ? 2 : 1;
1400 if (f<0.1 || f>0.6)
1401 frame += 2;
1402 }
1403
1404 if (!reflect)
1405 RenderTile( false, TILE_SPHERE,
1406 (int)(x+(x2-x)*f),
1407 (int)(y+(y2-y)*f) - shadow_h
1408 );
1409
1410 RenderGirl(
1411 reflect,
1412 r, frame,
1413 (int)(x+(x2-x)*f),
1414 (int)(y+(y2-y)*f),
1415 h
1416 );
1417
1418 }
1419 /* RenderTile(
1420 dead ? TILE_SPHERE_OPEN : TILE_SPHERE_DONE,
1421 (int)(x+(x2-x)*f),
1422 (int)(y+(y2-y)*f),
1423 true
1424 );*/
1425 }
1426 };
1427
1428
1429 struct HexPuzzle : public State
1430 {
1431 struct Undo
1432 {
1433 #define MAX_TILECHANGE 64 // TODO: don't have a magic upper limit
1434 struct TileChange
1435 {
1436 Pos p;
1437 Tile t;
1438 int item;
1439
1440 TileChange()
1441 {}
1442 TileChange(Pos _p, Tile _t, int _i) : p(_p), t(_t), item(_i)
1443 {}
1444 void Restore(HexPuzzle* w)
1445 {
1446 w->SetTile(p,t,false,false);
1447 w->SetItem(p,item,false,false);
1448 }
1449 };
1450
1451 TileChange t[MAX_TILECHANGE];
1452 Pos playerPos;
1453 Dir playerMovement;
1454 int numT;
1455 int numItems[2];
1456 int score;
1457 double time;
1458 double endTime;
1459
1460 void Add(TileChange const & tc)
1461 {
1462 for (int i=0; i<numT; i++)
1463 if (t[i].p==tc.p)
1464 return;
1465 if (numT>=MAX_TILECHANGE)
1466 FATAL("numT>=MAX_TILECHANGE");
1467 else
1468 t[numT++] = tc;
1469 }
1470 void New(Dir pmove, Pos & pp, int* items, double t, int sc)
1471 {
1472 numItems[0] = items[0];
1473 numItems[1] = items[1];
1474 playerPos = pp;
1475 playerMovement = pmove;
1476 score = sc;
1477 time = t;
1478 numT = 0;
1479 }
1480 void Restore(HexPuzzle* w)
1481 {
1482 for (int i=numT-1; i>=0; i--)
1483 t[i].Restore(w);
1484 w->dead = false;
1485 w->win = false;
1486 w->player = playerPos;
1487 w->player_items[0] = numItems[0];
1488 w->player_items[1] = numItems[1];
1489 w->player_score = score;
1490
1491 //w->renderer.player.Add(new PlayerRender(playerPos, w->GetHeight(playerPos), false), w->time);
1492 }
1493 };
1494
1495 #define MAP_SIZE 30
1496 char* special[MAP_SIZE][MAP_SIZE];
1497 Tile map[MAP_SIZE][MAP_SIZE];
1498 int map_item[MAP_SIZE][MAP_SIZE];
1499 int tileCount[NumTileTypes];
1500 int levelPar, levelDiff;
1501 int turboAnim;
1502 Pos player;
1503 int player_items[2];
1504 int player_score;
1505 int numComplete, numLevels, numMastered, numLevelsFound;
1506 bool dead;
1507 bool win;
1508 int winFinal;
1509
1510 SaveState progress;
1511
1512 WorldRenderer renderer;
1513 double time;
1514 double undoTime;
1515
1516 #define MAX_UNDO 6
1517 Undo undo[MAX_UNDO];
1518 int numUndo;
1519 LevelInfo* currentLevelInfo;
1520
1521 char currentFile[1000];
1522
1523 ~HexPuzzle()
1524 {
1525 FreeGraphics();
1526 }
1527
1528 LevelInfo* GetLevelInfo(const char* f)
1529 {
1530 if (strstr(f, "Levels\\") == f)
1531 f += 7;
1532 if (currentLevelInfo!=0 && strcmp(currentLevelInfo->file, f)==0)
1533 return currentLevelInfo;
1534
1535 if (f[0]=='_')
1536 {
1537 int t = atoi(f+1);
1538 if (t <= numComplete)
1539 return 0;
1540
1541 static char tmp1[100];
1542 static LevelInfo tmp = {0, "", tmp1};
1543 sprintf(tmp1, "Complete %d more %s to unlock!", t-numComplete, t-numComplete==1?"level":"levels");
1544 return &tmp;
1545 }
1546
1547 for (int i=0; i<sizeof(levelNames)/sizeof(levelNames[0]); i++)
1548 if (strcmp(f, levelNames[i].file)==0)
1549 return &levelNames[i];
1550 static LevelInfo tmp = {0, "", "<<NO NAME>>"};
1551 return &tmp;
1552 }
1553
1554 #ifdef MAP_EDIT_HACKS
1555 int GetAutoTile(const char * level, bool tiletype)
1556 {
1557 FILE* f = file_open(filename, "rb");
1558 int tile = EMPTY;
1559 int version;
1560
1561 if (f && fscanf(f, "%d", &version)==1 && (version==3 || version==4))
1562 {
1563 if (strstr(level,"mk"))
1564 level+=0;
1565
1566 fgetc(f); // Remove '\n' character
1567
1568 int par, diff;
1569 unsigned char bounds[4];
1570 Pos playerStart;
1571 fread(&par, sizeof(par), 1, f);
1572 if (version >= 4)
1573 fread(&diff, sizeof(diff), 1, f);
1574 fread(bounds, sizeof(bounds), 1, f);
1575 fread(&playerStart, sizeof(player), 1, f);
1576
1577 int highval=0;
1578
1579 for (int i=bounds[0]; i<=bounds[1]; i++)
1580 for (int j=bounds[2]; j<=bounds[3]; j++)
1581 {
1582 unsigned char comp = map[i][j] | (map_item[i][j]<<5);
1583 fread(&comp, sizeof(comp), 1, f);
1584 int t = comp & 0x1f;
1585 int item = (comp >> 5) & 3;
1586 for (int i=highval+1; i<sizeof(value_order)/sizeof(value_order[0]); i++)
1587 if (t!=0 && t==value_order[i]
1588 || item!=0 && item==(value_order[i]>>8))
1589 highval = i;
1590 }
1591
1592 if (tiletype)
1593 {
1594 tile = value_order[highval];
1595 if (tile==0x100) tile = COLLAPSABLE3;
1596 if (tile==0x200) tile = SWITCH;
1597 if (tile==LIFT_UP) tile = LIFT_DOWN;
1598 }
1599 else
1600 {
1601 if (value_order[highval] == LIFT_UP)
1602 tile = highval-1;
1603 else
1604 tile = highval;
1605 }
1606 }
1607 else
1608 {
1609 level+=0;
1610 }
1611 if (f)
1612 fclose(f);
1613 return tile;
1614 }
1615 #endif
1616
1617 void InitSpecials()
1618 {
1619 numComplete = numLevels = numMastered = numLevelsFound = 0;
1620 for (int i=0; i<MAP_SIZE; i++)
1621 for (int j=0; j<MAP_SIZE; j++)
1622 ActivateSpecial(Pos(i,j), 0);
1623 for (int i=0; i<MAP_SIZE; i++)
1624 for (int j=0; j<MAP_SIZE; j++)
1625 ActivateSpecial(Pos(i,j), 2);
1626 numComplete = numLevels = numMastered = numLevelsFound = 0;
1627 for (int i=0; i<MAP_SIZE; i++)
1628 for (int j=0; j<MAP_SIZE; j++)
1629 ActivateSpecial(Pos(i,j), 0);
1630
1631 }
1632 void DoHints()
1633 {
1634 #ifndef EDIT
1635 if (strcmp(mapname, currentFile)==0)
1636 {
1637 // for (int i=0; i<32; i++)
1638 // HintMessage::FlagTile(i);
1639 if (numComplete >= UNLOCK_SCORING && !progress.general.scoringOn)
1640 {
1641 HintMessage::FlagTile(26);
1642 progress.general.scoringOn = 1;
1643 InitSpecials(); // Re-initialise with gold ones available
1644 }
1645 HintMessage::FlagTile(25);
1646 }
1647 else
1648 {
1649 for (int i=0; i<MAP_SIZE; i++)
1650 for (int j=0; j<MAP_SIZE; j++)
1651 {
1652 int t = GetTile(Pos(i,j));
1653 int item = GetItem(Pos(i,j));
1654 if (t)
1655 HintMessage::FlagTile(t);
1656 if (item)
1657 HintMessage::FlagTile(item+20);
1658 }
1659 HintMessage::FlagTile(EMPTY);
1660 }
1661 #endif
1662 hintsDone = true;
1663 }
1664 void ResetLevel()
1665 {
1666 hintsDone = false;
1667
1668 UpdateCursor(Pos(-1,-1));
1669
1670 isMap = false;
1671
1672 player_score = 0;
1673
1674 numUndo = 0;
1675 undoTime = -1;
1676
1677 dead = false;
1678 win = false;
1679 winFinal = false;
1680 player_items[0] = player_items[1] = 0;
1681 // time = 0;
1682 if (strlen(currentSlot) == 0)
1683 {
1684 new TitleMenu();
1685 new Fader(1, -3);
1686 }
1687 else
1688 {
1689 if (!isFadeRendering && time!=0)
1690 {
1691 renderer().Add(new FadeRender(-1), time);
1692 time += 0.5;
1693 }
1694 }
1695
1696 // Reset renderer
1697 renderer.Reset(time);
1698 renderer.Wipe();
1699
1700 for (int t=0; t<NumTileTypes; t++)
1701 tileCount[t] = 0;
1702
1703 for (int i=0; i<MAP_SIZE; i++)
1704 for (int j=0; j<MAP_SIZE; j++)
1705 {
1706 Pos p(i,j);
1707 int item = GetItem(p);
1708 //if (item)
1709 renderer(p,true).Add(new ItemRender(item, GetTile(p)==EMPTY, p), time);
1710 }
1711
1712 InitSpecials();
1713
1714 for (int i=0; i<MAP_SIZE; i++)
1715 for (int j=0; j<MAP_SIZE; j++)
1716 {
1717 Pos p(i,j);
1718 int t = GetTile(p);
1719 tileCount[t]++;
1720
1721 if (isMap)
1722 t = EMPTY;
1723
1724 //if (t)
1725 renderer(p).Add(new TileRender(t, p), time);
1726 }
1727
1728 if (!isMap)
1729 renderer.player.Add(new PlayerRender(player, GetHeight(player), dead), time);
1730 else
1731 renderer.player.Add(new PlayerRender(Pos(-100,-100), 0, true), time);
1732
1733
1734 int bounds[4] = {player.getScreenX(),player.getScreenX(),player.getScreenY(),player.getScreenY()};
1735 for (int i=0; i<MAP_SIZE; i++)
1736 for (int j=0; j<MAP_SIZE; j++)
1737 {
1738 Pos p(i,j);
1739 if (map[i][j] !=0 || map_item[i][j]!=0)
1740 {
1741 int x1 = p.getScreenX();
1742 int y1 = p.getScreenY();
1743 int x2 = x1 + TILE_W3;
1744 int y2 = y1 + TILE_H2;
1745 y1 -= TILE_H2; // Make sure objects/player will be properly visible
1746
1747 if (x1<bounds[0]) bounds[0] = x1;
1748 if (x2>bounds[1]) bounds[1] = x2;
1749 if (y1<bounds[2]) bounds[2] = y1;
1750 if (y2>bounds[3]) bounds[3] = y2;
1751 }
1752 }
1753
1754 int sx, sy;
1755 if (isMap)
1756 {
1757 sx = bounds[0] - int(TILE_W2*6.35);
1758 sy = (bounds[3] + bounds[2] - SCREEN_H) / 2 - TILE_H2/2;
1759 }
1760 else
1761 {
1762 sx = (bounds[1] + bounds[0] - SCREEN_W) / 2 - TILE_W3/2;
1763 sy = (bounds[3] + bounds[2] - SCREEN_H) / 2 - TILE_H2/2;
1764 }
1765 if (isMap)
1766 {
1767 initScrollX = sx;
1768 initScrollY = sy;
1769 if (mapScrollX==0)
1770 mapScrollX = sx;
1771 else
1772 sx = mapScrollX;
1773 }
1774
1775 // time = 1; // Guarantee we can't try and do things at time=0
1776
1777 renderer().Add(new ScrollRender(sx, sy), time);
1778 renderer().Add(new FadeRender(1), time);
1779 if (time != 0)
1780 time -= 0.5;
1781 }
1782
1783 char* ReadAll(FILE* f)
1784 {
1785 int size;
1786 fseek(f, 0, SEEK_END);
1787 size = ftell(f);
1788 fseek(f, 0, SEEK_SET);
1789 char* c = loadPtr = new char [size];
1790 endLoad = loadPtr + size;
1791 fread(c, 1, size, f);
1792 return c;
1793 }
1794
1795 static char *loadPtr, *endLoad;
1796 static unsigned int fread_replace(void* d, unsigned int size, unsigned int num, FILE*)
1797 {
1798 unsigned int remain = (endLoad - loadPtr) / size;
1799 if (remain < num) num = remain;
1800 memcpy(d, loadPtr, size*num);
1801 loadPtr += size*num;
1802 return num;
1803 }
1804
1805 int GetPar(const char * level, bool getdiff=false)
1806 {
1807 if (strcmp(level, currentFile)==0)
1808 return getdiff ? levelDiff : levelPar;
1809
1810 #ifdef USE_LEVEL_PACKFILE
1811 PackFile1::Entry* e = levelFiles.Find(level);
1812 if (!e) return 999;
1813 loadPtr = (char*)e->Data();
1814 endLoad = loadPtr + e->DataLen();
1815 FILE* f = 0;
1816 #else
1817 loadPtr = 0;
1818 FILE* f = file_open(level, "rb");
1819 #endif
1820
1821 typedef unsigned int _fn(void*, unsigned int, unsigned int, FILE*);
1822 _fn * fn = (loadPtr ? (_fn*)fread_replace : (_fn*)fread);
1823
1824 int par = 99999, diff = 0;
1825 int version;
1826
1827 if (!f && !loadPtr)
1828 return getdiff ? diff : par;
1829
1830 fn(&version, 2, 1, f); // skip to relevant point
1831
1832 if (fn(&par, sizeof(par), 1, f) != 1)
1833 par = 99999;
1834 if (fn(&diff, sizeof(diff), 1, f) != 1 || diff<0 || diff>10)
1835 diff = 0;
1836
1837 #ifdef USE_LEVEL_PACKFILE
1838 loadPtr = endLoad = 0;
1839 #else
1840 if (f)
1841 fclose(f);
1842 #endif
1843
1844 return getdiff ? diff : par;
1845 }
1846
1847 bool LoadSave(const char * filename, bool save)
1848 {
1849 if (!filename)
1850 return false;
1851
1852 if (!save)
1853 {
1854 showScoring = false;
1855 LevelSave* l = progress.GetLevel(filename, true);
1856 if (progress.general.scoringOn && l && l->Completed() )
1857 showScoring = true;
1858 }
1859
1860 #ifdef USE_LEVEL_PACKFILE
1861 if (!save)
1862 {
1863 PackFile1::Entry* e = levelFiles.Find(filename);
1864 if (!e) return false;
1865
1866 strcpy(currentFile, filename);
1867 currentLevelInfo = GetLevelInfo(currentFile);
1868
1869 loadPtr = (char*)e->Data();
1870 endLoad = loadPtr + e->DataLen();
1871 _LoadSave(NULL, save);
1872 loadPtr = endLoad = 0;
1873
1874 return true;
1875 }
1876 #else
1877 loadPtr = 0;
1878 FILE* f = file_open(filename, save ? "wb" : "rb");
1879 if (f)
1880 {
1881 strcpy(currentFile, filename);
1882 if (!save)
1883 currentLevelInfo = GetLevelInfo(currentFile);
1884
1885 if (!save)
1886 {
1887 char* data = ReadAll(f);
1888 _LoadSave(f, save);
1889 delete [] data;
1890 loadPtr = endLoad = 0;
1891 }
1892 else
1893 {
1894 _LoadSave(f, save);
1895 }
1896 fclose(f);
1897
1898 return true;
1899 }
1900 #endif
1901
1902 return false;
1903 }
1904
1905 void _LoadSave(FILE* f, bool save)
1906 {
1907 typedef unsigned int _fn(void*, unsigned int, unsigned int, FILE*);
1908 _fn * fn = save ? (_fn*)fwrite : (loadPtr ? (_fn*)fread_replace : (_fn*)fread);
1909
1910 #define VERSION 4
1911 int version = VERSION;
1912 if (save)
1913 fprintf(f, "%d\n", version);
1914 else
1915 {
1916 char c;
1917 if (fn(&c, 1, 1, f) != 1)
1918 return;
1919 version = c-'0';
1920
1921 // Remove '\n' character
1922 fn(&c, 1, 1, f);
1923 }
1924
1925 if (!save)
1926 {
1927 for (int i=0; i<MAP_SIZE; i++)
1928 for (int j=0; j<MAP_SIZE; j++)
1929 {
1930 delete [] special[i][j];
1931 special[i][j] = 0;
1932 }
1933 }
1934
1935 if (version==1)
1936 {
1937 for (int i=0; i<MAP_SIZE; i++)
1938 for (int j=0; j<MAP_SIZE; j++)
1939 fn(&map[i][j], sizeof(map[i][j]), 1, f);
1940
1941 fn(&player, sizeof(player), 1, f);
1942
1943 if (fn(map_item, sizeof(map_item), 1, f) == 0)
1944 memset(map_item, 0, sizeof(map_item));
1945 }
1946 else if (version>=2 && version<=4)
1947 {
1948 unsigned char bounds[4];
1949 if (save)
1950 {
1951 bounds[0]=bounds[1]=player.x;
1952 bounds[2]=bounds[3]=player.y;
1953 for (int i=0; i<MAP_SIZE; i++)
1954 for (int j=0; j<MAP_SIZE; j++)
1955 if (map[i][j] !=0 || map_item[i][j]!=0 || special[i][j]!=0)
1956 {
1957 if (i<bounds[0]) bounds[0] = i;
1958 if (i>bounds[1]) bounds[1] = i;
1959 if (j<bounds[2]) bounds[2] = j;
1960 if (j>bounds[3]) bounds[3] = j;
1961 }
1962 }
1963 else
1964 {
1965 memset(map, 0, sizeof(map));
1966 memset(map_item, 0, sizeof(map_item));
1967 }
1968
1969 if (version>=3)
1970 fn(&levelPar, 1, sizeof(levelPar), f);
1971 else if (!save)
1972 levelPar = 0;
1973
1974 if (version>=4)
1975 fn(&levelDiff, 1, sizeof(levelDiff), f);
1976 else if (!save)
1977 levelDiff = 0;
1978
1979 fn(bounds, sizeof(bounds), 1, f);
1980 fn(&player, sizeof(player), 1, f);
1981
1982 int offsetx=0, offsety=0;
1983
1984 if (!save && bounds[1]-bounds[0]<15) // Hacky - don't recenter map...
1985 {
1986 // Re-position map to top left (but leave a bit of space)
1987 // (This ensures the laser/boat effects don't clip prematurely against the edges of the screen)
1988 offsetx = SCREEN_W/2/TILE_W2 + 1 - (bounds[0]+bounds[1]/2);
1989 offsety = SCREEN_H/2/TILE_H2 + SCREEN_W/2/TILE_W2 - (bounds[2]+bounds[3]/2);
1990 offsetx = MAX(0, offsetx);
1991 offsety = MAX(0, offsety);
1992 // if (bounds[0] > 2)
1993 // offsetx = 2 - bounds[0];
1994 // if (bounds[2] > 2)
1995 // offsety = 2 - bounds[2];
1996 }
1997 bounds[0] += offsetx;
1998 bounds[1] += offsetx;
1999 bounds[2] += offsety;
2000 bounds[3] += offsety;
2001 player.x += offsetx;
2002 player.y += offsety;
2003
2004 for (int i=bounds[0]; i<=bounds[1]; i++)
2005 for (int j=bounds[2]; j<=bounds[3]; j++)
2006 {
2007 unsigned char comp = map[i][j] | (map_item[i][j]<<5);
2008 fn(&comp, sizeof(comp), 1, f);
2009 map[i][j] = comp & 0x1f;
2010 map_item[i][j] = (comp >> 5) & 3;
2011 }
2012
2013 if (save)
2014 {
2015 for (int i=bounds[0]; i<=bounds[1]; i++)
2016 for (int j=bounds[2]; j<=bounds[3]; j++)
2017 if (special[i][j])
2018 {
2019 short len = strlen(special[i][j]);
2020 unsigned char x=i, y=j;
2021 fn(&x, sizeof(x), 1, f);
2022 fn(&y, sizeof(y), 1, f);
2023 fn(&len, sizeof(len), 1, f);
2024 fn(special[i][j], 1, len, f);
2025 }
2026 }
2027 else
2028 {
2029 while(1){
2030 short len;
2031 unsigned char x, y;
2032 if (!fn(&x, sizeof(x), 1, f))
2033 break;
2034 fn(&y, sizeof(y), 1, f);
2035 x += offsetx; y += offsety;
2036 fn(&len, sizeof(len), 1, f);
2037 if (len<0) break;
2038 char* tmp = new char[len+1];
2039 tmp[len] = 0;
2040 fn(tmp, 1, len, f);
2041
2042 SetSpecial(Pos(x,y), tmp, true, false);
2043 }
2044 }
2045 }
2046 else
2047 return; // Unsupported version!
2048
2049 ResetLevel();
2050
2051 // Save when returning to map!
2052 if (isMap)
2053 {
2054 progress.general.completionPercentage = numComplete*100/numLevels;
2055 progress.general.masteredPercentage = numMastered*100/numLevels;
2056 LoadSaveProgress(true);
2057 }
2058 }
2059
2060 void SetTile(Pos const & p, Tile t, bool updateRenderer=true, bool undoBuffer=true)
2061 {
2062 if (p.x<0 || p.x>MAP_SIZE)
2063 return;
2064 if (p.y<0 || p.y>MAP_SIZE)
2065 return;
2066 if (map[p.x][p.y] == t)
2067 return;
2068 if (map[p.x][p.y] == t)
2069 return;
2070
2071 tileCount[map[p.x][p.y]]--;
2072 tileCount[t]++;
2073
2074 if (undoBuffer)
2075 undo[numUndo].Add(Undo::TileChange(p,GetTile(p),GetItem(p)));
2076
2077 map[p.x][p.y] = t;
2078
2079 if (updateRenderer)
2080 renderer(p).Add(new TileRender(t, p), time);
2081 }
2082
2083 Tile GetTile(Pos const & p)
2084 {
2085 if (p.x<0 || p.x>=MAP_SIZE)
2086 return EMPTY;
2087 if (p.y<0 || p.y>=MAP_SIZE)
2088 return EMPTY;
2089 return map[p.x][p.y];
2090 }
2091
2092 int GetHeight(Pos const & p)
2093 {
2094 return tileSolid[GetTile(p)]==1;
2095 }
2096
2097 char* GetSpecial(Pos const & p)
2098 {
2099 if (p.x<0 || p.x>=MAP_SIZE)
2100 return NULL;
2101 if (p.y<0 || p.y>=MAP_SIZE)
2102 return NULL;
2103 return special[p.x][p.y];
2104 }
2105
2106 void SetSpecial(Pos const & p, char * d, bool use_pointer=false, bool auto_activate=true)
2107 {
2108 if (p.x<0 || p.x>=MAP_SIZE || p.y<0 || p.y>=MAP_SIZE)
2109 {
2110 if (use_pointer)
2111 delete [] d;
2112 return;
2113 }
2114
2115 delete [] special[p.x][p.y];
2116 if (!use_pointer && d)
2117 {
2118
2119 special[p.x][p.y] = new char [strlen(d) + 1];
2120 strcpy(special[p.x][p.y], d);
2121 }
2122 else
2123 special[p.x][p.y] = d;
2124
2125 if (special[p.x][p.y]==0)
2126 renderer(p,true).Add(new ItemRender(GetItem(p), GetTile(p)==EMPTY, p), time);
2127 else if (auto_activate)
2128 ActivateSpecial(p, 0);
2129 }
2130
2131 int GetLevelState(Pos const & p, int recurse=0)
2132 {
2133 char* x = GetSpecial(p);
2134 if (!x) return 0;
2135
2136 LevelSave* l = progress.GetLevel(x, false);
2137
2138 int t = 1;
2139
2140 if (strcmp(x, STARTING_LEVEL)==0)
2141 t = 2;
2142 if (x[0]=='_' && l && l->unlocked)
2143 t=3;
2144
2145 if (l && l->Completed())
2146 {
2147 t = 3;
2148
2149 if (recurse)
2150 return t;
2151
2152 int par = GetPar(x);
2153 if (progress.general.scoringOn && l->PassesPar( par ))
2154 t = 4;
2155 }
2156 if (recurse)
2157 return t;
2158
2159 int adj=0;
2160 for (Dir d=0; d<MAX_DIR; d++)
2161 {
2162 int i = GetLevelState(p+d, 1);
2163 // if (i>1 || i==1 && t>1)
2164 if (i>=1 && t>2 || t>=1 && i>2)
2165 {
2166 adj |= 1<<d;
2167 if (t==1)
2168 t = 2;
2169 }
2170 }
2171
2172 return t | adj<<8;
2173 }
2174
2175 void ActivateSpecial(Pos const & p, int type)
2176 {
2177 if (p.x<0 || p.x>=MAP_SIZE || p.y<0 || p.y>=MAP_SIZE)
2178 return;
2179
2180 char * x = special[p.x][p.y];
2181
2182 if (x==0 || x[0]==0)
2183 return;
2184
2185 if (type==2 && x[0]=='_') // Phase2 init - unlock
2186 {
2187 int t = GetLevelState(p);
2188 int target = atoi(x+1), targetM = 0;
2189 if (target>1000) targetM=target=target-100;
2190 if (t > 1 && numComplete >= target && numMastered >= targetM)
2191 {
2192 LevelSave* l = progress.GetLevel(x, true);
2193 if (!l->unlocked)
2194 {
2195 l->unlocked = true;
2196
2197 renderer(p, true).Add(new LevelSelectRender(p, 5, GetLevelState(p)>>8), time+0.01);
2198 renderer().Add(new ExplosionRender(p, 0), time + 0.6);
2199 renderer().Add(new ExplosionRender(p, 1), time + 1.1);
2200 renderer(p, true).Add(new LevelSelectRender(p, -1, GetLevelState(p)>>8), time + 1.1);
2201 }
2202 }
2203 }
2204
2205 if (type==0) // Init & count levels
2206 {
2207 if (x[0]=='_')
2208 {
2209 int t = GetLevelState(p);
2210 int unlock = progress.GetLevel(x, true)->unlocked;
2211 LevelSelectRender* lsr = new LevelSelectRender( p, unlock ? -1 : (t>>8) ? 5 : 1, t>>8 );
2212 if ((t>>8) && p.x > mapRightBound) mapRightBound = p.x;
2213 #ifdef MAP_EDIT_HACKS
2214 lsr->magic = -atoi(x+1);
2215 SetTile(p, LIFT_DOWN, true, false);
2216 #else
2217 SetTile(p, EMPTY, true, false);
2218 #endif
2219 renderer(p,true).Add(lsr, time);
2220 }
2221 else
2222 {
2223 //printf("Level: %s\n", x);
2224
2225 int t = GetLevelState(p);
2226 numLevels++;
2227 if (t && !GetItem(p))
2228 {
2229 if (!isMap)
2230 {
2231 isMap = true;
2232 mapRightBound = 0;
2233 }
2234 currentLevelInfo = 0;
2235
2236 if ((t&0xff)>=2)
2237 {
2238 LevelSave* l = progress.GetLevel(x, true);
2239 if (!l->unlocked)
2240 {
2241 l->unlocked = true;
2242
2243 renderer(p, true).Add(new LevelSelectRender(p, -1, 0), time+0.01);
2244 renderer().Add(new ExplosionRender(p, 0), time + 0.6);
2245 renderer(p, true).Add(new LevelSelectRender(p, t & 0xff, t>>8), time + 0.6);
2246 }
2247
2248 numLevelsFound++;
2249 if (p.x > mapRightBound) mapRightBound = p.x;
2250 }
2251 if ((t&0xff)>=3)
2252 numComplete++;
2253 if ((t&0xff)>=4)
2254 numMastered++;
2255
2256 LevelSelectRender* lsr = new LevelSelectRender( p, t & 0xff, t>>8 );
2257
2258 #ifdef MAP_EDIT_HACKS
2259 lsr->magic = 0;
2260 int t = GetAutoTile(x, true);
2261 int v = GetAutoTile(x, false);
2262 if (MAP_EDIT_HACKS_DISPLAY_UNLOCK)
2263 lsr->magic = v;
2264 else
2265 lsr->magic = GetPar(x, true);
2266 t = 1;
2267 SetTile(p, t, true, false);
2268 #else
2269 SetTile(p, EMPTY, true, false);
2270 #endif
2271
2272 renderer(p,true).Add(lsr, time);
2273 }
2274 }
2275 }
2276
2277 if (type==1 && x[0]!='_') // Clicked on
2278 {
2279 int t = GetLevelState(p);
2280 if (t>1)
2281 {
2282 LoadSave(x, false);
2283 }
2284 }
2285 }
2286
2287 void SetItem(Pos const & p, int t, bool updateRenderer=true, bool undoBuffer=true)
2288 {
2289 if (p.x<0 || p.x>MAP_SIZE)
2290 return;
2291 if (p.y<0 || p.y>MAP_SIZE)
2292 return;
2293 if (map_item[p.x][p.y] == t)
2294 return;
2295
2296 if (undoBuffer)
2297 undo[numUndo].Add(Undo::TileChange(p,GetTile(p),GetItem(p)));
2298
2299 map_item[p.x][p.y] = t;
2300
2301 if (updateRenderer)
2302 renderer(p,true).Add(new ItemRender(t, GetTile(p)==EMPTY, p), time);
2303 }
2304
2305 Tile GetItem(Pos const & p)
2306 {
2307 if (p.x<0 || p.x>=MAP_SIZE)
2308 return EMPTY;
2309 if (p.y<0 || p.y>=MAP_SIZE)
2310 return EMPTY;
2311 return map_item[p.x][p.y];
2312 }
2313
2314 void LoadSaveProgress(bool save)
2315 {
2316 FILE* f = file_open(currentSlot, save ? "wb" : "rb");
2317 if (f)
2318 {
2319 progress.LoadSave(f, save);
2320 fclose(f);
2321 }
2322 else
2323 {
2324 if (!save)
2325 progress.Clear();
2326 }
2327 }
2328 void LoadProgress()
2329 {
2330 LoadSaveProgress(false);
2331 }
2332 void SaveProgress()
2333 {
2334 LoadSaveProgress(true);
2335 }
2336
2337 SDL_Surface* Load(const char * bmp, bool colourKey=true)
2338 {
2339 typedef unsigned int uint32;
2340 uint32* tmp = 0;
2341
2342 SDL_Surface * g = 0;
2343
2344 #ifdef EDIT
2345 if (strstr(bmp, ".bmp"))
2346 {
2347 g = SDL_LoadBMP(bmp);
2348
2349 char out[1024];
2350 strcpy(out, bmp);
2351 strcpy(strstr(out, ".bmp"), ".dat");
2352
2353 // SDL_PixelFormat p;
2354 // p.sf = 1;
2355 // SDL_Surface* tmp = SDL_ConvertSurface(g, &p, SDL_SWSURFACE);
2356
2357 short w=g->w, h=g->h;
2358 char* buf = (char*) g->pixels;
2359 if (colourKey)
2360 {
2361 while (IsEmpty(g, w-1, 0, 1, h) && w>1)
2362 w--;
2363 while (IsEmpty(g, 0, h-1, w, 1) && h>1)
2364 h--;
2365 }
2366
2367 FILE* f = file_open(out, "wb");
2368 fwrite(&w, sizeof(w), 1, f);
2369 fwrite(&h, sizeof(h), 1, f);
2370
2371 uint32 mask = IMAGE_DAT_OR_MASK;
2372 for (int i=0; i<(int)w*h; )
2373 {
2374 uint32 c = (*(uint32*)&buf[(i%w)*3 + (i/w)*g->pitch] | mask);
2375 int i0 = i;
2376 while (i < (int)w*h && c == (*(uint32*)&buf[(i%w)*3 + (i/w)*g->pitch] | mask))
2377 i++;
2378 c &= 0xffffff;
2379 i0 = i-i0-1;
2380 if (i0 < 0xff)
2381 c |= i0 << 24;
2382 else
2383 c |= 0xff000000;
2384
2385 fwrite(&c, sizeof(c), 1, f);
2386
2387 if (i0 >= 0xff)
2388 fwrite(&i0, sizeof(i0), 1, f);
2389 }
2390 fclose(f);
2391
2392 SDL_FreeSurface(g);
2393
2394 bmp = out;
2395 }
2396 #endif
2397
2398 FILE* f = file_open(bmp, "rb");
2399 if (!f) FATAL("Unable to open file", bmp);
2400
2401 short w,h;
2402 fread(&w, sizeof(w), 1, f);
2403 fread(&h, sizeof(h), 1, f);
2404 if (w>1500 || h>1500) FATAL("Invalid file", bmp);
2405
2406 tmp = new uint32[(int)w*h];
2407
2408 uint32 c = 0;
2409 uint32 cnt = 0;
2410 for (int p=0; p<(int)w*h; p++)
2411 {
2412 if (cnt)
2413 cnt -= 0x1;
2414 else
2415 {
2416 fread(&c, sizeof(c), 1, f);
2417 cnt = c >> 24;
2418 if (cnt==255)
2419 fread(&cnt, sizeof(cnt), 1, f);
2420 }
2421 tmp[p] = c | 0xff000000;
2422 }
2423
2424 g = SDL_CreateRGBSurfaceFrom(tmp, w, h, 32, w*4,
2425 0xff0000,
2426 0xff00,
2427 0xff,
2428 0xff000000 );
2429
2430 fclose(f);
2431
2432
2433 if (!g) FATAL("Unable to create SDL surface");
2434 if (colourKey)
2435 SDL_SetColorKey(g, SDL_SRCCOLORKEY, SDL_MapRGB(g->format, WATER_COLOUR));
2436 SDL_Surface * out = SDL_DisplayFormat(g);
2437 SDL_FreeSurface(g);
2438 delete [] tmp;
2439 if (!out) FATAL("Unable to create SDL surface (SDL_DisplayFormat)");
2440 return out;
2441 }
2442
2443 #ifdef USE_LEVEL_PACKFILE
2444 PackFile1 levelFiles;
2445 #endif
2446 HexPuzzle()
2447 {
2448 SDL_WM_SetCaption(GAMENAME, 0);
2449
2450 time = 0;
2451
2452 #ifdef USE_LEVEL_PACKFILE
2453 FILE* f = file_open("levels.dat", "rb");
2454 if (!f)
2455 FATAL("Unable to open file", "levels.dat");
2456 levelFiles.Read(f);
2457 fclose(f);
2458 #endif
2459
2460 LoadGraphics();
2461
2462 isMap = false;
2463 editMode = false;
2464
2465 currentLevelInfo = 0;
2466
2467 editTile = 0;
2468 levelPar = 0;
2469 levelDiff = 5;
2470 turboAnim = 0;
2471
2472 memset(map, 0, sizeof(map));
2473 memset(map_item, 0, sizeof(map_item));
2474 memset(special, 0, sizeof(special));
2475
2476 LoadProgress();
2477
2478 // player = Pos(1,11);
2479
2480 // ResetLevel();
2481
2482 LoadMap();
2483 }
2484
2485 void LoadMap()
2486 {
2487 #ifndef EDIT
2488 progress.GetLevel(STARTING_LEVEL, true)->unlocked = 1;
2489 if (!progress.GetLevel(STARTING_LEVEL, true)->Completed())
2490 {
2491 LoadSave(STARTING_LEVEL, false);
2492 return;
2493 }
2494 #endif
2495
2496 //editMode = false;
2497 LoadSave(mapname, false);
2498 }
2499
2500 void Render()
2501 {
2502 if (!activeMenu || activeMenu->renderBG)
2503 {
2504 SDL_Rect src = {0,0,screen->w,screen->h};
2505 SDL_Rect dst = {0,0,screen->w,screen->h};
2506 if (isRenderMap)
2507 {
2508 int boundW = mapBG->w;
2509 #ifndef EDIT
2510 boundW = MIN(boundW, (mapRightBound+4) * TILE_W2 - TILE_W1);
2511 #endif
2512 src.x = scrollX - initScrollX;
2513 if (src.x+src.w > boundW)
2514 {
2515 int diff = src.x+src.w - boundW;
2516 src.x -= diff;
2517 if (isMap)
2518 scrollX -= diff;
2519 }
2520 if (src.x < 0)
2521 {
2522 if (isMap)
2523 scrollX -= src.x;
2524 src.x = 0;
2525 }
2526 //scrollY = initScrollY;
2527
2528 if (isMap)
2529 mapScrollX = scrollX;
2530
2531 SDL_BlitSurface(mapBG, &src, screen, &dst);
2532 }
2533 else
2534 SDL_BlitSurface(gradient, &src, screen, &dst);
2535
2536 renderer.Render(time, true);
2537
2538 if (!hintsDone && !isFadeRendering)
2539 {
2540 DoHints();
2541 }
2542
2543 if (1)
2544 {
2545 SDL_Rect src = {0,SCREEN_H-1,SCREEN_W,1};
2546 SDL_Rect dst = {0,SCREEN_H-1,SCREEN_W,1};
2547 for (int i=0; i<SCREEN_H; i++)
2548 {
2549 dst.x = src.x = 0;
2550 dst.y = src.y = SCREEN_H-1-i;
2551 src.w = SCREEN_W;
2552 src.h = 1;
2553
2554 const bool farView = false;
2555 if (isRenderMap)
2556 {
2557 src.x += (int)( sin(i*0.9 + time*3.7) * sin(i*0.3 + time*0.7)*4 );
2558 src.y += (int)( (sin(i*0.3 - time*2.2) * sin(i*0.48 + time*0.47) - 1) * 1.99 );
2559 }
2560 else
2561 {
2562 src.x += (int)( sin(i*0.5 + time*6.2) * sin(i*0.3 + time*1.05) * 5 );
2563 src.y += (int)( (sin(i*0.4 - time*4.3) * sin(i*0.08 + time*1.9) - 1) * 2.5 );
2564 }
2565 SDL_BlitSurface(screen, &src, screen, &dst);
2566 }
2567 }
2568
2569 if(isRenderMap)
2570 SDL_BlitSurface(mapBG2, &src, screen, &dst);
2571
2572 renderer.Render(time, false);
2573
2574 if (!isRenderMap && !isMap && !isFadeRendering)
2575 {
2576 int v[3] = {player_items[0], player_items[1], player_score};
2577 if (numUndo > 1 && time < undo[numUndo-2].endTime)
2578 {
2579 int i = numUndo-1;
2580 while (i>1 && time<undo[i-1].time)
2581 i--;
2582 v[0] = undo[i].numItems[0];
2583 v[1] = undo[i].numItems[1];
2584 v[2] = undo[i].score;
2585 }
2586 if (numUndo>1 && time < undo[0].time)
2587 v[0]=v[1]=v[2]=0;
2588 #ifdef EDIT
2589 Print(0,0,"Anti-Ice: %d", v[0]);
2590 Print(0,FONT_SPACING,"Jumps: %d", v[1]);
2591 Print(0,FONT_SPACING*2,"Score: %d (%d)", v[2], player_score);
2592 Print(0,FONT_SPACING*3,"Par: %d", levelPar);
2593 Print(0,FONT_SPACING*4,"Diff: %d", levelDiff);
2594 #else
2595 if (showScoring)
2596 Print(0, SCREEN_H-FONT_SPACING, " Par: %d Current: %d", levelPar, v[2]);
2597
2598 if (v[0])
2599 Print(0,0," Anti-Ice: %d", v[0]);
2600 else if (v[1])
2601 Print(0,0," Jumps: %d", v[1]);
2602 #endif
2603 }
2604 if (isRenderMap && isMap && !isFadeRendering)
2605 {
2606 #if 0//def EDIT
2607 Print(0,0,"Points: %d", numComplete+numMastered);
2608 Print(0,FONT_SPACING,"Discovered: %d%% (%d/%d)", numLevelsFound*100/numLevels, numLevelsFound, numLevels);
2609 Print(0,FONT_SPACING*2,"Complete: %d%% (%d)", numComplete*100/numLevels, numComplete);
2610 Print(0,FONT_SPACING*3,"Mastered: %d%% (%d)", numMastered*100/numLevels, numMastered);
2611 #else
2612 if (numComplete==numLevels && progress.general.endSequence>0)
2613 Print(0, SCREEN_H-FONT_SPACING, " %d%% Mastered", numMastered*100/numLevels);
2614 else
2615 Print(0, SCREEN_H-FONT_SPACING, " %d%% Complete", numComplete*100/numLevels);
2616
2617 if (numMastered >= numLevels && progress.general.endSequence < 2)
2618 {
2619 progress.general.endSequence = 2;
2620 LoadSaveProgress(true);
2621
2622 new Fader(-1, -7, 0.3);
2623 }
2624 if (numComplete >= numLevels && progress.general.endSequence < 1)
2625 {
2626 progress.general.endSequence = 1;
2627 LoadSaveProgress(true);
2628
2629 new Fader(-1, -5, 0.3);
2630 }
2631 #endif
2632 }
2633 if ((currentLevelInfo || noMouse) && isMap && isRenderMap && !activeMenu && isFadeRendering<=0)
2634 {
2635 Pos p;
2636 if (noMouse)
2637 p = keyboardp;
2638 else
2639 p = mousep;
2640 int pad = SCREEN_W/80;
2641 // SDL_Rect src = {0, 0, uiGraphics->w, uiGraphics->h};
2642 SDL_Rect dst = {pad, SCREEN_H-TILE_H2-pad, 0, 0};
2643 // dst.x = p.getScreenX() + TILE_W3/2 - scrollX;
2644 // dst.y = p.getScreenY() - src.h/2 - scrollY;
2645 dst.x = p.getScreenX() - scrollX;
2646 dst.y = p.getScreenY() - scrollY - FONT_SPACING*3 - FONT_SPACING/2;
2647 // if (dst.x > SCREEN_W*2/3) dst.x -= TILE_W3 + src.w;
2648 // if (dst.y+src.h > screen->h-pad) dst.y = screen->h-pad - src.h;
2649
2650 RenderTile(false, 0, p.getScreenX(), p.getScreenY());
2651 // SDL_BlitSurface(uiGraphics, &src, screen, &dst);
2652
2653 // dst.x += src.w/2;
2654
2655 if (currentLevelInfo)
2656 {
2657 keyboardp = p;
2658
2659 PrintC(true, dst.x, dst.y - FONT_SPACING/4, currentLevelInfo->name);
2660
2661 if (currentLevelInfo->file[0]!=0)
2662 {
2663 if (player_score > 0)
2664 {
2665 if (progress.general.scoringOn)
2666 {
2667 PrintC(false, dst.x, dst.y + FONT_SPACING*4 - FONT_SPACING/4, "Best:% 3d", player_score);
2668 PrintC(false, dst.x, dst.y + FONT_SPACING*5 - FONT_SPACING/4, "Par:% 3d", levelPar);
2669 }
2670 else
2671 PrintC(false, dst.x, dst.y + FONT_SPACING*4 - FONT_SPACING/4, "Completed", player_score);
2672 }
2673 else
2674 PrintC(false, dst.x, dst.y + FONT_SPACING*4 - FONT_SPACING/4, "Incomplete", player_score);
2675 }
2676 }
2677 }
2678
2679 // "Win"
2680 if (win && numUndo > 0 && time > undo[numUndo-1].endTime + 2)
2681 {
2682 if (currentFile[0] && winFinal==0)
2683 {
2684 LevelSave* l = progress.GetLevel(currentFile, true);
2685
2686 new WinLoseScreen(true, player_score, showScoring ? levelPar : 0, l && showScoring && l->Completed() ? l->GetScore() : 0);
2687
2688 if (l->IsNewCompletionBetter(player_score))
2689 {
2690 l->SetScore(player_score);
2691
2692 l->SetSolution(numUndo);
2693
2694 for (int i=0; i<numUndo; i++)
2695 l->SetSolutionStep(i, undo[i].playerMovement);
2696 }
2697
2698 SaveProgress();
2699 }
2700
2701 winFinal = 1;
2702 }
2703 else
2704 winFinal = 0;
2705
2706 // Move up "level complete" writing so it doesn't feel like everything's ground to a halt...
2707 if (win && numUndo > 0 && time > undo[numUndo-1].endTime && !winFinal)
2708 {
2709 double t = (time - undo[numUndo-1].endTime) / 2;
2710 t=1-t;
2711 t*=t*t;
2712 t=1-t;
2713 int y = SCREEN_H/3 - FONT_SPACING + 1;
2714 y = SCREEN_H + int((y-SCREEN_H)*t);
2715 PrintC(true, SCREEN_W/2, y, "Level Complete!");
2716 }
2717 }
2718
2719 if (activeMenu)
2720 activeMenu->Render();
2721
2722 if (!noMouse)
2723 {
2724 // Edit cursor
2725 if (editMode)
2726 {
2727 RenderTile(false, editTile, mousex+scrollX, mousey+scrollY);
2728 }
2729 else
2730 {
2731 Print(mousex, mousey-2, "\x7f");
2732 }
2733 }
2734 }
2735
2736 int Count(Tile t)
2737 {
2738 return tileCount[t];
2739 }
2740 int Swap(Tile t, Tile t2)
2741 {
2742 const int num = Count(t) + Count(t2);
2743 if (t==t2 || num==0)
2744 return Count(t); // Nothing to do...
2745
2746 int count=0;
2747 for (int x=0; x<MAP_SIZE; x++)
2748 for (int y=0; y<MAP_SIZE; y++)
2749 {
2750 if (GetTile(Pos(x,y))==t)
2751 {
2752 count++;
2753 SetTile(Pos(x,y), t2);
2754 }
2755 else if (GetTile(Pos(x,y))==t2)
2756 {
2757 count++;
2758 SetTile(Pos(x,y), t);
2759 }
2760 if (count==num)
2761 return count;
2762 }
2763 return count;
2764 }
2765 int Replace(Tile t, Tile t2)
2766 {
2767 const int num = Count(t);
2768 if (t==t2 || num==0)
2769 return num; // Nothing to do...
2770
2771 int count=0;
2772 for (int x=0; x<MAP_SIZE; x++)
2773 for (int y=0; y<MAP_SIZE; y++)
2774 {
2775 Pos p(x,y);
2776 if (GetTile(p)==t)
2777 {
2778 count++;
2779
2780 SetTile(p, t2, false);
2781
2782 if (t==COLLAPSE_DOOR && t2==COLLAPSABLE)
2783 renderer(p).Add(new BuildRender(p, -1, 1, 1), time + (rand() & 255)*0.001);
2784 else if (t==COLLAPSE_DOOR2 && t2==COLLAPSABLE2)
2785 renderer(p).Add(new BuildRender(p, -1, 1, 1, 1), time + (rand() & 255)*0.001);
2786 else
2787 SetTile(p, t2);
2788
2789 if (count==num)
2790 return count;
2791 }
2792 }
2793 return count;
2794 }
2795
2796 Tile editTile;
2797 bool editMode;
2798 void ResetUndo()
2799 {
2800 UndoDone();
2801 undoTime = -1;
2802 numUndo = 0;
2803 win = false;
2804 }
2805
2806 void UpdateCursor(Pos const & s)
2807 {
2808 static Pos _s;
2809 if (s.x!=_s.x || s.y!=_s.y)
2810 {
2811 _s = s;
2812
2813 char* sp = GetSpecial(s);
2814 char tmp[1000];
2815 tmp[0]='\0';
2816 if (sp)
2817 {
2818 if (isMap)
2819 {
2820 currentLevelInfo = 0;
2821 levelPar = player_score = -1;
2822 if (GetLevelState(s)>=2)
2823 {
2824 LevelSave* l = progress.GetLevel(sp, true);
2825 if (l)
2826 {
2827 currentLevelInfo = GetLevelInfo(sp);
2828 levelPar = GetPar(sp);
2829 player_score = l->GetScore();
2830 }
2831 }
2832 }
2833
2834 #ifdef EDIT
2835 sprintf(tmp, "Special(%d,%d): %s (%d)", s.x, s.y, sp ? sp : "<None>", GetPar(sp));
2836 SDL_WM_SetCaption(tmp, NULL);
2837 #endif
2838 }
2839 else if (currentFile[0])
2840 {
2841 #ifdef EDIT
2842 SDL_WM_SetCaption(currentFile, NULL);
2843 #endif
2844 if (isMap)
2845 currentLevelInfo = 0;
2846 }
2847 }
2848 }
2849
2850 virtual void Mouse(int x, int y, int dx, int dy, int button_pressed, int button_released, int button_held)
2851 {
2852 if (activeMenu)
2853 {
2854 activeMenu->Mouse(x,y,dx,dy,button_pressed,button_released,button_held);
2855 return;
2856 }
2857
2858 if (isFadeRendering)
2859 return;
2860
2861
2862 #ifndef EDIT
2863 if (button_pressed==2 || button_pressed==4 && isMap)
2864 {
2865 KeyPressed(SDLK_ESCAPE, 0);
2866 keyState[SDLK_ESCAPE] = 0;
2867 return;
2868 }
2869 #endif
2870
2871 x += scrollX;
2872 y += scrollY;
2873
2874 Pos s = Pos::GetFromWorld(x,y);
2875 if (tileSolid[GetTile(Pos::GetFromWorld(x,y+TILE_HUP))] == 1)
2876 s = Pos::GetFromWorld(x,y+TILE_HUP);
2877
2878 mousep = s;
2879
2880 UpdateCursor(s);
2881
2882 #ifdef EDIT
2883 if (button_held & ~button_pressed & 4)
2884 {
2885 scrollX -= dx;
2886 scrollY -= dy;
2887 }
2888 #endif
2889
2890 if (!editMode)
2891 {
2892 if (isMap && (button_pressed & 1))
2893 {
2894 ActivateSpecial(s, 1);
2895 return;
2896 }
2897 if (!isMap && win && winFinal)
2898 {
2899 if (button_pressed & 1)
2900 {
2901 LoadMap();
2902 return;
2903 }
2904 }
2905 if(!isMap)
2906 {
2907 if((button_pressed & 1) || (button_held & 1) && (numUndo==0 || time>=undo[numUndo-1].endTime))
2908 {
2909 if(s.x==player.x && s.y==player.y)
2910 {
2911 // Don't activate jump powerup without a new click
2912 if (button_pressed & 1)
2913 Input(-1);
2914 }
2915 else if(s.x==player.x && s.y<player.y)
2916 Input(0);
2917 else if(s.x==player.x && s.y>player.y)
2918 Input(3);
2919 else if(s.y==player.y && s.x<player.x)
2920 Input(5);
2921 else if(s.y==player.y && s.x>player.x)
2922 Input(2);
2923 else if(s.y+s.x==player.y+player.x && s.x>player.x)
2924 Input(1);
2925 else if(s.y+s.x==player.y+player.x && s.x<player.x)
2926 Input(4);
2927 }
2928 if ((button_pressed & 4) || (button_held & 4) && (undoTime < 0))
2929 Undo();
2930 }
2931 return;
2932 }
2933
2934 #ifdef EDIT
2935 if (!button_pressed && !button_held)
2936 return;
2937
2938 if (button_pressed==1)
2939 if (editTile<0)
2940 editTile = GetItem(s)==1 ? -3 : GetItem(s)==2 ? -2 : -1;
2941
2942 if (button_held==1 || button_pressed==1)
2943 {
2944 ResetUndo();
2945 if (editTile>=0)
2946 SetTile(s, editTile, true, false);
2947 else
2948 SetItem(s, editTile==-2 ? 0 : editTile==-1 ? 1 : 2, true, false);
2949 }
2950
2951 if (button_pressed==2)
2952 {
2953 editTile = GetTile(s);
2954 }
2955
2956 if (button_pressed==8)
2957 {
2958 editTile=editTile-1;
2959 if (editTile<=0) editTile=NumTileTypes-1;
2960 }
2961
2962 if (button_pressed==16)
2963 {
2964 editTile=editTile+1;
2965 if (editTile<=0) editTile=1;
2966 if (editTile==NumTileTypes) editTile=0;
2967 }
2968
2969 if (button_pressed==64)
2970 {
2971 ResetUndo();
2972 player = s;
2973 dead = false;
2974 renderer.player.Reset(-1);
2975 renderer.player.Add(new PlayerRender(player, GetHeight(player), dead), 0);
2976 }
2977
2978 if (button_pressed==256)
2979 {
2980 char* fn = LoadSaveDialog(false, true, "Select level");
2981 if (fn)
2982 {
2983 char * l = strstr(fn, "Levels");
2984 if(l)
2985 {
2986 FILE * f = file_open(l,"rb");
2987 if (f)
2988 fclose(f);
2989 if (f)
2990 SetSpecial(s, l);
2991 else if (l[6]!=0 && l[7]=='_')
2992 SetSpecial(s, l+7);
2993 }
2994 UpdateCursor(Pos(-1,-1));
2995 }
2996 }
2997 if (button_pressed==512)
2998 {
2999 SetSpecial(s, NULL);
3000 UpdateCursor(Pos(-1,-1));
3001 }
3002 if (button_pressed==1024)
3003 {
3004 static char x[1000] = "";
3005 if (!(s.x<0 || s.x>=MAP_SIZE || s.y<0 || s.y>=MAP_SIZE))
3006 {
3007 char tmp[1000];
3008 strcpy(tmp, x);
3009 if (GetSpecial(s))
3010 strcpy(x, GetSpecial(s));
3011 else
3012 x[0] = 0;
3013 SetSpecial(s, tmp[0] ? tmp : 0);
3014 if (!tmp[0])
3015 SetTile(s, EMPTY, true, false);
3016 }
3017 }
3018
3019 if (button_pressed==32)
3020 {
3021 editTile = editTile<0 ? 1 : -1;
3022 }
3023 #endif // EDIT
3024 }
3025
3026 void CheckFinished()
3027 {
3028 bool slow = false;
3029 if (Count(COLLAPSABLE)==0)
3030 {
3031 if (Replace(COLLAPSE_DOOR, COLLAPSABLE) == 0)
3032 win = true;
3033 else
3034 slow = true;
3035 Replace(SWITCH, NORMAL);
3036 }
3037 else
3038 win = false;
3039
3040 if (Count(COLLAPSABLE2)==0)
3041 if (Replace(COLLAPSE_DOOR2, COLLAPSABLE2))
3042 slow = true;
3043
3044 if (slow)
3045 time += BUILD_TIME;
3046 }
3047 bool Collide(Pos p, bool high)
3048 {
3049 Tile t = GetTile(p);
3050 // switch(t)
3051 // {
3052 // default:
3053 if (!high)
3054 return tileSolid[t]==1;
3055 else
3056 return false;
3057 // }
3058 }
3059 void Undo()
3060 {
3061 if (numUndo==0) return;
3062
3063 UndoDone(); // Complete previous undo...
3064
3065 numUndo--;
3066
3067 if (time > undo[numUndo].endTime)
3068 time = undo[numUndo].endTime;
3069 undoTime = undo[numUndo].time;
3070
3071 undo[numUndo].Restore(this);
3072 }
3073 void UndoDone()
3074 {
3075 if (undoTime < 0)
3076 return;
3077 renderer.Reset(undoTime);
3078 time = undoTime;
3079 undoTime = -1;
3080 }
3081 void ScoreDestroy(Pos p)
3082 {
3083 Tile t = GetTile(p);
3084 if (t==COLLAPSABLE || t==COLLAPSE_DOOR)
3085 {}
3086 else if (t != EMPTY)
3087 {
3088 player_score += 10;
3089 }
3090 }
3091
3092 bool LaserTile(Pos p, int mask, double fireTime)
3093 {
3094 if (&renderer(p) == &renderer(Pos(-1,-1)))
3095 return false;
3096 //if (!renderer.Visible(p))
3097 // return false;
3098
3099 TileRender* tr = 0;
3100 if (time <= renderer(p).GetLastTime())
3101 if (fireTime < renderer(p).GetLastTime())
3102 {
3103 renderer(p).Add(tr = new TileRender(GetTile(p), p, mask), fireTime);
3104 ((TileRender*)renderer(p).GetStage(time+10/*HACKY!*/))->special |= mask;
3105 }
3106 else
3107 {
3108 tr = new TileRender(GetTile(p), p, mask | ((TileRender*)renderer(p).GetStage(time+10/*HACKY!*/))->special);
3109 renderer(p).Add(tr, fireTime);
3110 }
3111 else
3112 renderer(p).Add(tr = new TileRender(GetTile(p), p, mask), fireTime);
3113
3114 if (tr)
3115 {
3116 tr->specialDuration = time + LASER_LINE_TIME - fireTime + LASER_FADE_TIME;
3117 }
3118 return true;
3119 }
3120 void FireGun(Pos newpos, Dir d, bool recurse, double fireTime)
3121 {
3122 static Pos hits[100];
3123 static Dir hitDir[100];
3124 static int numHits=0;
3125 if (!recurse)
3126 numHits = 0;
3127
3128 double starttime = fireTime;
3129 for (Dir fd=((d<0)?0:d); fd<((d<0)?MAX_DIR:d+1); fd++)
3130 {
3131 fireTime = starttime;
3132 // starttime += 0.03;
3133
3134 Pos p = newpos + fd;
3135 int range = 0;
3136 for (range; range<MAP_SIZE; range++, p=p+fd)
3137 {
3138 Tile t = GetTile(p);
3139 if (tileSolid[t]!=-1)
3140 {
3141 if (t!=TRAP)
3142 renderer(p).Add(new TileRender(tileSolid[t]==1 ? TILE_WHITE_WALL : TILE_WHITE_TILE, p), fireTime+0.1);
3143
3144 int i;
3145 for (i=0; i<numHits; i++)
3146 if (hits[i]==p)
3147 break;
3148 if (i==numHits ||
3149 t==TRAP && (hitDir[i]&(1<<fd))==0
3150 )
3151 {
3152 if (i==numHits)
3153 {
3154 if (i >= sizeof(hits)/sizeof(hits[0]))
3155 return;
3156 hitDir[i] = 1 << fd;
3157 hits[i] = p;
3158 numHits++;
3159 }
3160 else
3161 {
3162 hitDir[i] |= 1 << fd;
3163 }
3164 if (t==TRAP)
3165 {
3166 int dirmask =
3167 1<<((fd+2) % MAX_DIR)
3168 | 1<<((fd+MAX_DIR-2) % MAX_DIR);
3169
3170 if (LaserTile(p, dirmask, fireTime))
3171 fireTime += (time+LASER_LINE_TIME - fireTime) / 40;
3172 // fireTime += LASER_SEGMENT_TIME;
3173
3174 FireGun(p, (fd+1) % MAX_DIR, true, fireTime);
3175 FireGun(p, (fd+MAX_DIR-1) % MAX_DIR, true, fireTime);
3176 }
3177 }
3178 break;
3179 }
3180 else
3181 {
3182 LaserTile(p, 1<<(fd%3), fireTime);
3183
3184 fireTime += (time+LASER_LINE_TIME - fireTime) / 40;
3185 // fireTime += LASER_SEGMENT_TIME;
3186 }
3187 }
3188
3189 // renderer().Add(new LaserRender(newpos, fd, range), time);
3190 }
3191
3192 if (!recurse)
3193 {
3194 double _time = time;
3195 time += LASER_LINE_TIME;
3196 for (int i=0; i<numHits; i++)
3197 {
3198 Pos p = hits[i];
3199 Tile t = GetTile(p);
3200
3201 if (t==TRAP)
3202 continue;
3203
3204 ScoreDestroy(p);
3205
3206 renderer(p).Add(new ExplosionRender(p, t==GUN), time);
3207 //renderer(p).Add(new TileRender(EMPTY, p), time+2);
3208 SetTile(p, EMPTY, false);
3209
3210 if (GetItem(p))
3211 renderer(p,true).Add(new ItemRender(GetItem(p), 1, p), time);
3212
3213 if (t==GUN)
3214 {
3215 for (Dir j=0; j<MAX_DIR; j++)
3216 {
3217 if (GetTile(p+j)!=EMPTY)
3218 {
3219 renderer(p+j).Add(new TileRender(tileSolid[GetTile(p+j)]==1 ? TILE_WHITE_WALL : TILE_WHITE_TILE, p+j), time+0.05);
3220 renderer(p+j).Add(new ExplosionRender(p+j), time+0.2);
3221
3222 if (GetItem(p+j))
3223 renderer(p+j,true).Add(new ItemRender(GetItem(p+j), 1, p), time);
3224
3225 //renderer(p+j).Add(new TileRender(EMPTY, p+j), time+2.2);
3226 }
3227 ScoreDestroy(p + j);
3228 SetTile(p + j, EMPTY, false);
3229 }
3230 }
3231 }
3232
3233 time += MAX(LASER_FADE_TIME, 0.15);
3234 //time = _time;
3235 CheckFinished();
3236 }
3237 }
3238 int GetLastPlayerRot()
3239 {
3240 RenderStage* rs = renderer.player.GetStage(-1);
3241 if (!rs) return 3;
3242 return ((PlayerRender*)rs)->r;
3243 }
3244 bool Input(Dir d)
3245 {
3246 if (dead || win || isMap)
3247 return false;
3248
3249 // Complete undo
3250 UndoDone();
3251
3252 // Jump forwards in time to last move finishing
3253 if (numUndo > 0 && time < undo[numUndo-1].endTime)
3254 time = undo[numUndo-1].endTime;
3255
3256 double realTime = time;
3257 double endAnimTime = time;
3258 bool high = (tileSolid[GetTile(player)] == 1);
3259 Pos playerStartPos = player;
3260 Pos oldpos = player;
3261 int oldPlayerHeight = GetHeight(oldpos);
3262 Pos newpos = player + d;
3263
3264 int playerRot = GetLastPlayerRot();
3265 if (d!=-1 && d!=playerRot)
3266 {
3267 while (d!=playerRot)
3268 {
3269 if ((d+6-playerRot) % MAX_DIR < MAX_DIR/2)
3270 playerRot = (playerRot+1) % MAX_DIR;
3271 else
3272 playerRot = (playerRot+MAX_DIR-1) % MAX_DIR;
3273
3274 time += 0.03;
3275
3276 if (GetTile(oldpos) == FLOATING_BALL)
3277 {
3278 TileRender* t = new TileRender(FLOATING_BALL, oldpos);
3279 t->special = playerRot + 256;
3280 renderer(oldpos).Add(t, time);
3281
3282 renderer.player.Add(new PlayerRender(playerRot, Pos(-20,-20), oldPlayerHeight, Pos(-20,-20), oldPlayerHeight, dead), time);
3283 }
3284 else
3285 {
3286 PlayerRender *p = new PlayerRender(playerRot, player, oldPlayerHeight, player, oldPlayerHeight, dead);
3287 p->speed = 0;
3288 renderer.player.Add(p, time);
3289 }
3290 }
3291
3292 time += 0.03;
3293 }
3294
3295 if (d<0 && player_items[1]==0)
3296 return false;
3297
3298 if (d >= 0)
3299 {
3300 if (tileSolid[GetTile(newpos)] == -1)
3301 {
3302 time = realTime;
3303 return false;
3304 }
3305 if (Collide(newpos, high))
3306 {
3307 time = realTime;
3308 return false;
3309 }
3310 }
3311
3312 // Don't change any real state before this point!
3313 if (numUndo >= MAX_UNDO)
3314 {
3315 numUndo--;
3316 for(int i=0; i<MAX_UNDO-1; i++)
3317 undo[i] = undo[i+1];
3318 }
3319 undo[numUndo].New(d, player, player_items, time, player_score);
3320
3321 if (d<0)
3322 {
3323 player_items[1]--;
3324 }
3325
3326 int old_score=player_score;
3327
3328 double time0 = time;
3329 time += 0.15; //Time for leave-tile fx
3330
3331 switch (GetTile(oldpos))
3332 {
3333 case COLLAPSABLE:
3334 SetTile(oldpos, EMPTY);
3335 renderer(oldpos).Add(new DisintegrateRender(oldpos), time);
3336 CheckFinished();
3337 break;
3338
3339 case COLLAPSE_DOOR:
3340 // Don't need to CheckFinished - can't be collapse doors around
3341 // unless there're still collapsable tiles around.
3342 SetTile(oldpos, EMPTY);
3343 renderer(oldpos).Add(new DisintegrateRender(oldpos, 1), time);
3344 break;
3345
3346 case COLLAPSABLE2:
3347 SetTile(oldpos, COLLAPSABLE, false);
3348 renderer(oldpos).Add(new DisintegrateRender(oldpos, 0, 1), time);
3349 player_score += 10;
3350 CheckFinished();
3351 break;
3352
3353 case COLLAPSE_DOOR2:
3354 SetTile(oldpos, COLLAPSE_DOOR, false);
3355 renderer(oldpos).Add(new DisintegrateRender(oldpos, 1, 1), time);
3356 player_score += 10;
3357 break;
3358
3359 case COLLAPSABLE3:
3360 SetTile(oldpos, COLLAPSABLE2);
3361 break;
3362 }
3363
3364 time = time0; //End of leave-tile fx
3365
3366 int retry_pos_count=0;
3367 retry_pos:
3368 retry_pos_count++;
3369
3370 if (GetItem(newpos)==1)
3371 {
3372 renderer(newpos, true).Add(new ItemCollectRender(GetItem(newpos), newpos), time + JUMP_TIME/2);
3373 SetItem(newpos, 0, false);
3374 player_items[0]++;
3375 }
3376 if (GetItem(newpos)==2)
3377 {
3378 renderer(newpos, true).Add(new ItemCollectRender(GetItem(newpos), newpos), time + JUMP_TIME/2);
3379 SetItem(newpos, 0, false);
3380 player_items[1]++;
3381 }
3382
3383 if (GetTile(player) == FLOATING_BALL)
3384 {
3385 TileRender* t = new TileRender(FLOATING_BALL, player);
3386 t->special = 0;
3387 renderer(oldpos).Add(t, time);
3388 }
3389
3390 PlayerRender *p = new PlayerRender(playerRot, player, oldPlayerHeight, newpos, GetHeight(newpos), dead);
3391
3392 // alternate leg (hacky!)
3393 if (1)
3394 {
3395 static int l=0;
3396 l++;
3397 p->type = l & 1;
3398 }
3399
3400 if (retry_pos_count!=0 && GetTile(player)==TRAP)
3401 {
3402 p->speed /= 1.5;
3403 p->type = 2;
3404 }
3405 if (d==-1)
3406 p->speed = JUMP_TIME * 1.5;
3407 renderer.player.Add(p, time);
3408 endAnimTime = MAX(endAnimTime, time + p->speed+0.001);
3409 time += p->speed;
3410
3411 player = newpos;
3412
3413 switch (GetTile(newpos))
3414 {
3415 case COLLAPSABLE:
3416 renderer(newpos).Add(new TileRender(TILE_GREEN_CRACKED, newpos), time);
3417 break;
3418 case COLLAPSE_DOOR:
3419 renderer(newpos).Add(new TileRender(TILE_GREEN_CRACKED_WALL, newpos), time);
3420 break;
3421 case COLLAPSABLE2:
3422 renderer(newpos).Add(new TileRender(TILE_BLUE_CRACKED, newpos), time);
3423 break;
3424 case COLLAPSE_DOOR2:
3425 renderer(newpos).Add(new TileRender(TILE_BLUE_CRACKED_WALL, newpos), time);
3426 break;
3427
3428 case EMPTY:
3429 dead = true;
3430 break;
3431
3432 case BUILDER:
3433 {
3434 double pretime = time;
3435 bool done = false;
3436 time += 0.15;
3437 for (Dir fd=0; fd<MAX_DIR; fd++)
3438 {
3439 Tile t2 = GetTile(newpos + fd);
3440 if (t2==EMPTY)
3441 {
3442 done = true;
3443 SetTile(newpos+fd, COLLAPSABLE, false);
3444 renderer(newpos+fd).Add(new BuildRender(newpos+fd, fd, 0), time);
3445 }
3446 else if (t2==COLLAPSABLE)
3447 {
3448 done = true;
3449 SetTile(newpos+fd, COLLAPSE_DOOR, false);
3450 renderer(newpos+fd).Add(new BuildRender(newpos+fd, fd, 1), time);
3451 }
3452 }
3453 if (done) time += BUILD_TIME;
3454 else time = pretime;
3455 CheckFinished();
3456 endAnimTime = MAX(endAnimTime, time + 0.1);
3457 }
3458 break;
3459
3460 case SWITCH:
3461 Swap(COLLAPSE_DOOR, COLLAPSABLE);
3462 break;
3463
3464 case FLOATING_BALL:
3465 {
3466 int step=0;
3467 renderer.player.Add(new PlayerRender(playerRot, Pos(-30,-30), 0, Pos(-30,-30), 0, dead), time);
3468 while (tileSolid[GetTile(newpos+d)]==-1)
3469 {
3470 step++;
3471
3472 if (!renderer.Visible(newpos+d))
3473 {
3474 TileRender* r = new TileRender(FLOATING_BALL, newpos);
3475 r->special = 512;
3476 renderer(newpos).Add(r, time);
3477
3478 PlayerRender* pr = new PlayerRender(playerRot, newpos, 0, newpos, 0, dead);
3479 pr->speed = JUMP_TIME*1;
3480 renderer.player.Add(pr, time);
3481
3482 time += pr->speed;
3483
3484 dead = 1;
3485 break;
3486 }
3487 oldpos = newpos;
3488 newpos = oldpos + d;
3489
3490 SetTile(oldpos, EMPTY, false);
3491 SetTile(newpos, FLOATING_BALL, false);
3492
3493 renderer(oldpos).Add(new TileRotateRender(FLOATING_BALL, oldpos, d, 2), time);
3494 renderer(oldpos).Add(new TileRender(EMPTY, oldpos), time + ROTATION_TIME/2);
3495 renderer(newpos).Add(new TileRotateRender(FLOATING_BALL, newpos, (d+3)%MAX_DIR, 3), time + ROTATION_TIME/2);
3496
3497 // PlayerRender *p = new PlayerRender(playerRot, oldpos, 0, newpos, 0, dead);
3498 // p->speed = ROTATION_TIME*0.9;
3499 // renderer.player.Add(p, time);
3500
3501 endAnimTime = MAX(endAnimTime, time + ROTATION_TIME + ROTATION_TIME/2);
3502 time += ROTATION_TIME;
3503 }
3504 player = newpos;
3505 // renderer.player.Add(new PlayerRender(playerRot, player, 0, player, 0, 0), time);
3506 if (dead)
3507 {
3508 }
3509 else
3510 {
3511 TileRender* r = new TileRender(FLOATING_BALL, newpos);
3512 r->special = playerRot + 256;
3513 renderer(newpos).Add(r, time);
3514 }
3515 }
3516 break;
3517
3518 case LIFT_DOWN:
3519 case LIFT_UP:
3520 {
3521 SetTile(newpos, GetTile(newpos)==LIFT_UP ? LIFT_DOWN : LIFT_UP, false);
3522 renderer(newpos).Add(new TileRender(GetTile(newpos), newpos, 1), time);
3523
3524 PlayerRender *p = new PlayerRender(playerRot, newpos, 1-GetHeight(newpos), newpos, GetHeight(newpos), dead);
3525 renderer.player.Add(p, time);
3526 endAnimTime = MAX(endAnimTime, time + JUMP_TIME);
3527 }
3528 break;
3529
3530 case TRAMPOLINE:
3531 if (d<0) break;
3532
3533 oldpos = newpos;
3534 if (Collide(newpos + d, high))
3535 break;
3536 if (Collide((newpos + d) + d, high) == 1)
3537 newpos = (newpos + d);
3538 else
3539 newpos = (newpos + d) + d;
3540 if (tileSolid[GetTile(newpos)] == -1)
3541 dead=1;
3542 //player = newpos;
3543 goto retry_pos;
3544
3545 case SPINNER:
3546 {
3547 for (Dir d=0; d<MAX_DIR; d++)
3548 {
3549 Tile tmp = GetTile(newpos + d);
3550 renderer(newpos + d).Add(new TileRotateRender(tmp, newpos + d, (d+2)%MAX_DIR, false), time);
3551 }
3552 Tile tmp = GetTile(newpos + Dir(MAX_DIR-1));
3553 for (Dir d=0; d<MAX_DIR; d++)
3554 {
3555 Tile t2 = GetTile(newpos + d);
3556 SetTile(newpos + d, tmp, false);
3557 renderer(newpos + d).Add(new TileRotateRender(tmp, newpos + d, (d+4)%MAX_DIR, true), time + ROTATION_TIME/2);
3558 if (GetItem(newpos + d))
3559 renderer(newpos + d,true).Add(new ItemRender(GetItem(newpos + d), GetTile(newpos + d)==EMPTY, newpos+d), time + ROTATION_TIME/2);
3560
3561 tmp = t2;
3562 }
3563 endAnimTime = MAX(endAnimTime, time+ROTATION_TIME);
3564 // renderer(newpos).Add(new TileRotateRender(SPINNER, Dir(0), 0), time);
3565 }
3566 break;
3567
3568 case TRAP:
3569 {
3570 if (d<0) break;
3571
3572 if (player_items[0]==0)
3573 {
3574 if (tileSolid[GetTile(newpos + d)] == 1)
3575 break;
3576 newpos = newpos + d;
3577 if (tileSolid[GetTile(newpos)] == -1)
3578 dead=1;
3579 //player = newpos;
3580 goto retry_pos;
3581 }
3582 else
3583 {
3584 SetTile(newpos, COLLAPSABLE3);
3585 player_items[0]--;
3586 }
3587 }
3588 break;
3589
3590 case GUN:
3591 {
3592 FireGun(newpos, d, false, time);
3593
3594 endAnimTime = MAX(endAnimTime, time);
3595
3596 if (GetTile(newpos)==EMPTY)
3597 {
3598 PlayerRender* pr = new PlayerRender(playerRot, player, 0, player, 0, dead);
3599 pr->speed = JUMP_TIME*1;
3600 renderer.player.Add(pr, time);
3601
3602 time += pr->speed;
3603 dead = 1;
3604 }
3605
3606 /*
3607 Pos hits[MAX_DIR];
3608 int numHits=0;
3609
3610 for (Dir fd=((d<0)?0:d); fd<((d<0)?MAX_DIR:d+1); fd++)
3611 {
3612 Pos p = newpos + fd;
3613 int range = 0;
3614 for (range; range<MAP_SIZE; range++, p=p+fd)
3615 {
3616 Tile t = GetTile(p);
3617 if (tileSolid[t]!=-1)
3618 {
3619 hits[numHits++] = p;
3620 break;
3621 }
3622 }
3623
3624 renderer().Add(new LaserRender(newpos, fd, range), time);
3625 }
3626
3627 double _time = time;
3628 time += 0.25;
3629 for (int i=0; i<numHits; i++)
3630 {
3631 Pos p = hits[i];
3632 Tile t = GetTile(p);
3633
3634 renderer().Add(new ExplosionRender(p), time);
3635 ScoreDestroy(p);
3636 SetTile(p, EMPTY);
3637
3638 if (t==GUN)
3639 {
3640 for (Dir j=0; j<MAX_DIR; j++)
3641 {
3642 ScoreDestroy(p + j);
3643 SetTile(p + j, EMPTY);
3644 }
3645 if (GetTile(newpos)==EMPTY)
3646 dead = 1;
3647 }
3648 }
3649 endAnimTime = MAX(endAnimTime, time);
3650
3651 time = _time;
3652
3653 CheckFinished();
3654 */
3655 break;
3656 }
3657 }
3658
3659 endAnimTime = MAX(endAnimTime, time);
3660
3661 if (dead)
3662 {
3663 win = false;
3664
3665 PlayerRender* pr = new PlayerRender(player, 0, dead);
3666 pr->speed = 0; // Don't sit around before disappearing!
3667 renderer.player.Add(pr, time);
3668
3669 // If the tile we're drowning on isn't visible, give the ownership of the splash effect to the player, rather than a tile.
3670 if (renderer.Visible(player))
3671 renderer(player).Add(new ExplosionRender(player, 0, 1), time);
3672 else
3673 renderer.player.Add(new ExplosionRender(player, 0, 1), time);
3674
3675 endAnimTime = MAX(endAnimTime, time+2);
3676 }
3677
3678 time = realTime;
3679
3680 player_score += 1;
3681
3682 undo[numUndo].endTime = endAnimTime;
3683 numUndo++;
3684
3685 return true;
3686 }
3687 void Update(double timedelta)
3688 {
3689 while(deadMenu)
3690 delete deadMenu;
3691
3692 if (activeMenu)
3693 {
3694 activeMenu->Update(timedelta);
3695 }
3696 else
3697 UpdateKeys();
3698
3699 for (int i=0; i<SDLK_LAST; i++)
3700 if (keyState[i])
3701 keyState[i] = 1;
3702
3703 if (activeMenu)
3704 return;
3705
3706 if (isMap && isRenderMap)
3707 {
3708 double min = 50;
3709 static double scrollHi = 0;
3710 double x = 0;
3711 #ifndef EDIT
3712 // if (!noMouse)
3713 {
3714 int xx = noMouse ? keyboardp.getScreenX()-scrollX : mousex;
3715 if (xx > SCREEN_W) xx = SCREEN_W;
3716 int w = TILE_W2*4;
3717 if (xx < w)
3718 x = (double)xx / (w) - 1;
3719 if (xx > SCREEN_W - w)
3720 x = 1 - (double)(SCREEN_W-xx) / (w);
3721 x *= 500;
3722 if (x<-min || x>min)
3723 {
3724 scrollHi += timedelta * x;
3725 scrollX += (int)scrollHi;
3726 scrollHi -= (int)scrollHi;
3727 }
3728 }
3729 #endif
3730 }
3731 if (undoTime>=0 && undoTime < time)
3732 {
3733 double acc = (time - undoTime) / 2;
3734 if (acc < 3) acc = 3;
3735 time -= timedelta * acc;
3736 if (undoTime >= time)
3737 UndoDone();
3738 }
3739 else
3740 {
3741 time += timedelta;
3742 if (turboAnim)
3743 time += timedelta * 20;
3744 }
3745 }
3746 void FileDrop(const char* filename)
3747 {
3748 LoadSave(filename, false);
3749 }
3750 void UpdateKeys()
3751 {
3752 #ifdef EDIT
3753 if (keyState[SDLK_LALT] || keyState[SDLK_LCTRL])
3754 return;
3755 #endif
3756
3757 if (!isMap && !editMode && undoTime < 0)
3758 {
3759 if (keyState['z'] || keyState[SDLK_BACKSPACE] || keyState['u'])
3760 {
3761 Undo();
3762 return;
3763 }
3764 }
3765 if (isMap && !editMode)
3766 {
3767
3768 if ((keyState['q'] | keyState[SDLK_KP7]) & 2) keyboardp.x--;
3769 else if ((keyState['d'] | keyState[SDLK_KP3]) & 2) keyboardp.x++;
3770 else if ((keyState['e'] | keyState[SDLK_KP9]) & 2) keyboardp.x++, keyboardp.y--;
3771 else if ((keyState['a'] | keyState[SDLK_KP1]) & 2) keyboardp.x--, keyboardp.y++;
3772 else if ((keyState['w'] | keyState[SDLK_KP8] | keyState[SDLK_UP]) & 2) keyboardp.y--;
3773 else if ((keyState['s'] | keyState[SDLK_KP2] | keyState[SDLK_DOWN]) & 2) keyboardp.y++;
3774 else if ((keyState[SDLK_LEFT]) & 2) keyboardp.x--, keyboardp.y+=keyboardp.x&1;
3775 else if (((keyState[SDLK_RIGHT]) & 2)) { if (keyboardp.x < mapRightBound) keyboardp.y-=keyboardp.x&1, keyboardp.x++; }
3776 else if ((keyState[SDLK_RETURN] | keyState[SDLK_KP5] | keyState[SDLK_SPACE] | keyState[SDLK_KP_ENTER]) & 2)
3777 {
3778 // Simulate user clicking on it...
3779 Mouse(keyboardp.getScreenX()-scrollX, keyboardp.getScreenY()-scrollY, 0, 0, 1, 0, 0);
3780 noMouse = 1;
3781 return;
3782 }
3783 else
3784 {
3785 if (noMouse)
3786 UpdateCursor(keyboardp);
3787 return;
3788 }
3789 int min[21] = { 17, 16, 15, 14, 13, 13, 13, 13, 13, 13, 12, 11, 11, 13, 12, 11, 8, 8, 7, 6, 7 };
3790 int max[21] = { 20, 20, 19, 19, 19, 19, 18, 21, 20, 20, 19, 19, 18, 18, 17, 16, 16, 16, 15, 15, 14 };
3791 if (keyboardp.x < 3) keyboardp.x = 3;
3792 if (keyboardp.x > mapRightBound) keyboardp.x = mapRightBound;
3793
3794 if (keyboardp.y < min[keyboardp.x-3]) keyboardp.y = min[keyboardp.x-3];
3795 if (keyboardp.y > max[keyboardp.x-3]) keyboardp.y = max[keyboardp.x-3];
3796 noMouse = 1;
3797 UpdateCursor(keyboardp);
3798 }
3799 else if (!editMode && (numUndo==0 || time>=undo[numUndo-1].endTime))
3800 {
3801 static int usedDiag = 0;
3802
3803 if (keyState['q'] || keyState[SDLK_KP7]) HandleKey('q', 0);
3804 else if (keyState['w'] || keyState[SDLK_KP8]) HandleKey('w', 0);
3805 else if (keyState['e'] || keyState[SDLK_KP9]) HandleKey('e', 0);
3806 else if (keyState['a'] || keyState[SDLK_KP1]) HandleKey('a', 0);
3807 else if (keyState['s'] || keyState[SDLK_KP2]) HandleKey('s', 0);
3808 else if (keyState['d'] || keyState[SDLK_KP3]) HandleKey('d', 0);
3809
3810 else if (keyState[SDLK_UP] && keyState[SDLK_LEFT]) HandleKey('q', 0), usedDiag=1;
3811 else if (keyState[SDLK_UP] && keyState[SDLK_RIGHT]) HandleKey('e', 0), usedDiag=1;
3812 else if (keyState[SDLK_DOWN] && keyState[SDLK_LEFT]) HandleKey('a', 0), usedDiag=1;
3813 else if (keyState[SDLK_DOWN] && keyState[SDLK_RIGHT]) HandleKey('d', 0), usedDiag=1;
3814 else if (keyState[SDLK_UP] && !usedDiag) HandleKey('w', 0);
3815 else if (keyState[SDLK_DOWN] && !usedDiag) HandleKey('s', 0);
3816
3817 else usedDiag = 0;
3818 }
3819 }
3820 void KeyReleased(int key)
3821 {
3822 keyState[key] = 0;
3823 }
3824 bool KeyPressed(int key, int mod)
3825 {
3826 keyState[key] = 2;
3827
3828 if (activeMenu)
3829 {
3830 bool eat = activeMenu->KeyPressed(key, mod);
3831 if (!activeMenu)
3832 memset(keyState, 0, sizeof(keyState));
3833 return eat;
3834 }
3835 else
3836 {
3837 if ((key==SDLK_ESCAPE && (mod & KMOD_CTRL)))
3838 {
3839 if (mod & KMOD_SHIFT)
3840 {
3841 time = 0;
3842 renderer.Reset();
3843 LoadSaveProgress(false);
3844 }
3845
3846 LoadMap();
3847 }
3848
3849 if (isFadeRendering)
3850 return false;
3851
3852 return HandleKey(key, mod);
3853 }
3854 }
3855 bool HandleKey(int key, int mod)
3856 {
3857 turboAnim = 0;
3858
3859 #ifdef CHEAT
3860 if (isMap && key=='r' && (mod & KMOD_ALT))
3861 {
3862 progress.Clear();
3863 LoadMap();
3864 }
3865 #endif
3866
3867 if (0) {}
3868
3869 else if ((key=='p' && !editMode || key==SDLK_PAUSE || key==SDLK_ESCAPE))
3870 {
3871 noMouse = 1;
3872 new PauseMenu(isMap, progress.GetLevel(STARTING_LEVEL, true)->Completed(), progress.general.endSequence>=1, progress.general.endSequence>=2);
3873 }
3874
3875 #ifdef EDIT
3876 else if (key=='e' && (mod & KMOD_ALT))
3877 editMode = !editMode;
3878
3879 else if (key=='p' && (mod & KMOD_ALT) && numUndo>0
3880 || key>='0' && key<='9' && (mod & KMOD_SHIFT) && !isMap)
3881 {
3882 if (key>='0' && key<='9')
3883 levelDiff = (key=='0') ? 10 : key-'0';
3884
3885 if (key=='p' && levelPar==0)
3886 levelPar = player_score;
3887
3888 if (numUndo)
3889 {
3890 do
3891 undo[numUndo-1].Restore(this);
3892 while (--numUndo);
3893 }
3894 time = 0;
3895 if (LoadSave(currentFile, true))
3896 {
3897 if (key>='0' && key<='9')
3898 LoadMap();
3899 }
3900 }
3901 #endif
3902
3903 /////////////////////////////////////////////////////////////////////////
3904 if (isMap && !editMode)
3905 return false;
3906
3907 else if (key==SDLK_KP9 || key=='e') Input(1), noMouse=1;
3908 else if (key==SDLK_KP3 || key=='d') Input(2), noMouse=1;
3909 else if (key==SDLK_KP1 || key=='a') Input(4), noMouse=1;
3910 else if (key==SDLK_KP7 || key=='q') Input(5), noMouse=1;
3911 else if (key==SDLK_KP8 || key=='w') Input(0), noMouse=1;
3912 else if (key==SDLK_KP2 || (key=='s' && (((mod & (KMOD_CTRL|KMOD_ALT))==0)||!editMode))) Input(3), noMouse=1;
3913 else if (key==SDLK_KP5 || key==SDLK_SPACE || key==SDLK_RETURN || key==SDLK_KP_ENTER)
3914 {
3915 noMouse=1;
3916 if (win && winFinal)
3917 LoadMap(), memset(keyState, 0, sizeof(keyState));
3918 else
3919 Input(-1);
3920 }
3921
3922 else if (key=='r' && (mod & KMOD_CTRL))
3923 LoadSave(currentFile, false);
3924
3925 #ifdef EDIT
3926 else if (key=='z' && (mod & KMOD_ALT))
3927 {
3928 if (numUndo>0 && !isMap)
3929 {
3930 time = undo[numUndo-1].endTime;
3931 undoTime = undo[0].time;
3932
3933 do
3934 undo[numUndo-1].Restore(this);
3935 while (--numUndo);
3936 }
3937 }
3938 #endif
3939 else if (key=='z' || key==SDLK_BACKSPACE || key==SDLK_DELETE || key=='u')
3940 {
3941 if (!isMap)
3942 Undo();
3943 }
3944
3945 #ifdef EDIT
3946 else if (key=='s' && (mod & KMOD_ALT)){
3947 if (win && strlen(currentFile)>0 && !isMap)
3948 {
3949 char tmp[1000];
3950 strcpy(tmp, currentFile);
3951 ChangeSuffix(tmp, "sol");
3952 FILE* f = file_open(tmp, "wb");
3953 if (f)
3954 {
3955 for (int i=0; i<numUndo; i++)
3956 {
3957 fputc(undo[i].playerMovement, f);
3958 }
3959 fclose(f);
3960 }
3961 }
3962 }
3963 #endif
3964
3965 #ifdef CHEAT
3966 else if (key=='/' && (mod & KMOD_ALT)){
3967 turboAnim = 1;
3968 if (!isMap)
3969 {
3970 while (numUndo)
3971 Undo();
3972 ResetLevel();
3973
3974 if (mod & KMOD_SHIFT)
3975 {
3976 LevelSave* l = progress.GetLevel(currentFile, false);
3977 if (l && l->Completed())
3978 {
3979 for (int i=0; i<l->bestSolutionLength; i++)
3980 Input(l->bestSolution[i]);
3981 time = 0;
3982 }
3983 if (!win && l)
3984 l->Clear();
3985 }
3986 else
3987 {
3988 char tmp[1000];
3989 strcpy(tmp, currentFile);
3990 ChangeSuffix(tmp, "sol");
3991 FILE* f = file_open(tmp, "rb");
3992 if (f)
3993 {
3994 int dir;
3995 while ((dir = fgetc(f)) != -1)
3996 {
3997 if (dir==0xff)
3998 dir = -1;
3999 Input(dir);
4000 }
4001 time = 0;
4002 fclose(f);
4003
4004 if (!win)
4005 remove(tmp);
4006 }
4007 }
4008 }
4009 }
4010 #endif
4011
4012 #ifdef EDIT
4013 else if (!editMode)
4014 return false;
4015
4016 else if (key>='0' && key<='9' && (mod & KMOD_ALT) && !isMap)
4017 levelPar = levelPar*10 + key-'0';
4018 else if (key==SDLK_BACKSPACE && (mod & KMOD_ALT) && !isMap)
4019 levelPar /= 10;
4020
4021 else if (key=='i')
4022 Mouse(mousex, mousey, 0, 0, 32, 0, mouse_buttons);
4023 else if (key=='p' && !(mod & KMOD_ALT))
4024 Mouse(mousex, mousey, 0, 0, 64, 0, mouse_buttons);
4025 else if (key=='x')
4026 Mouse(mousex, mousey, 0, 0, 128, 0, mouse_buttons);
4027 else if (key==SDLK_RETURN)
4028 Mouse(mousex, mousey, 0, 0, 256, 0, mouse_buttons);
4029 else if (key==SDLK_BACKSPACE)
4030 Mouse(mousex, mousey, 0, 0, 512, 0, mouse_buttons);
4031 else if (key=='c')
4032 Mouse(mousex, mousey, 0, 0, 1024, 0, mouse_buttons);
4033
4034 else if (key=='s' && (mod & KMOD_CTRL)){
4035 char *fn = LoadSaveDialog(true, true, "Save level");
4036 LoadSave(fn, true);
4037 SDL_WM_SetCaption(currentFile, NULL);
4038 }
4039
4040 else if (key=='o' && (mod & KMOD_CTRL)){
4041 char* fn = LoadSaveDialog(false, true, "Open level");
4042 LoadSave(fn, false);
4043 SDL_WM_SetCaption(currentFile, NULL);
4044 }
4045 #endif
4046
4047 else
4048 return false;
4049
4050 return true;
4051 }
4052 void LoadGraphics()
4053 {
4054 #define X(NAME,FILE,ALPHA) NAME = Load("graphics/" FILE BMP_SUFFIX, ALPHA);
4055 #include "gfx_list.h"
4056
4057 static int first = 1;
4058 if (first)
4059 {
4060 first = false;
4061 MakeFont();
4062 MakeTileInfo();
4063 }
4064
4065 // unsigned int d = {
4066
4067 // };
4068 // static SDL_Cursor * c = SDL_CreateCursor(data, mask, 32, 32, 1, 1);
4069 // SDL_SetCursor(c);
4070 SDL_ShowCursor(0);
4071 }
4072 void FreeGraphics()
4073 {
4074 #define X(NAME,FILE,ALPHA) if (NAME) SDL_FreeSurface(NAME), NAME=0;
4075 #include "gfx_list.h"
4076 }
4077 virtual void ScreenModeChanged()
4078 {
4079 // FreeGraphics();
4080 // LoadGraphics();
4081 }
4082 };
4083
4084 MAKE_STATE(HexPuzzle, SDLK_F1, false);
4085
4086 char * HexPuzzle::loadPtr = 0;
4087 char * HexPuzzle::endLoad = 0;
4088
4089 #endif //USE_OPENGL
puzzle game based on hexagonal tiles