?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add missing prototypes
[manicminer.git] / manic.c
blob0971dd621aa89fb7d60aece9331bf6479c1647a6
1 /*////////////////////////////////////////////////////////////
2 //
3 // Manic Miner PC
4 //
5 // 8/1997 By Andy Noble
6 //
7 // Compile: wcl386 /oneatx /zp4 /5 /fp3 manic.c
8 //
9 // LINUX PORT BY ADAM D. MOSS : adam@gimp.org
10 //
11 /////////////////////////////////////////////////////////////*/
12
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <math.h>
16 #include <sys/time.h>
17 #include <unistd.h>
18
19 #ifdef USE_X11
20 #include "emu_util.h"
21 #endif
22
23
24 /* ADMNOTE */
25 #ifdef USE_X11
26 #include <sys/ipc.h>
27 #include <sys/shm.h>
28 #include <X11/Xlib.h>
29 #include <X11/Xutil.h>
30 #include <X11/extensions/XShm.h>
31 #include <X11/cursorfont.h>
32 #include <X11/keysymdef.h>
33 #else
34 #include <vga.h>
35 #endif /* USE_X11 */
36
37
38 #ifdef USE_MIKMOD
39 #include <sys/stat.h>
40 #include <mikmod.h>
41 #include <ptform.h>
42 #endif /* USE_MIKMOD */
43
44
45 #include "mm-keydf.c"
46
47
48 /*/////////////////////////////////////////////////////////////
49 // Keyboard Variables
50 /////////////////////////////////////////////////////////////*/
51
52 typedef unsigned long DWORD;
53 typedef unsigned short WORD;
54 typedef unsigned char BYTE;
55
56 typedef unsigned int uint32;
57 typedef unsigned short int uint16;
58 typedef unsigned char uint8;
59
60
61
62 /*************************************************************/
63 /*************************************************************/
64 /************** X INIT STUFF *********************************/
65 #ifdef USE_X11
66
67 int wwidth = 320;
68 int wheight = 200;
69
70 Colormap cmap;
71 Display *display;
72 Window window;
73 GC gc;
74 XImage *ximage;
75 Cursor cursor;
76
77 int has_colourmap=0;
78 int depth=0;
79 int depth_bytes=0;
80 int bytesdeep;
81
82 static int shmem_flag=1;
83 static XShmSegmentInfo shminfo1;
84 static int gXErrorFlag;
85
86 XColor pal[256];
87 XColor xcolor;
88 void* pix;
89
90 #define error(x) fprintf(stderr,"%s\n",x);fflush(stderr);abort
91
92 static int HandleXError(dpy, event)
93 Display *dpy;
94 XErrorEvent *event;
95 {
96 gXErrorFlag = 1;
97
98 return 0;
99 }
100
101 static void InstallXErrorHandler()
102 {
103 XSetErrorHandler(HandleXError);
104 XFlush(display);
105 }
106
107 static void DeInstallXErrorHandler()
108 {
109 XSetErrorHandler(NULL);
110 XFlush(display);
111 }
112
113 void init_Xdisplay(char *name)
114 {
115 char *hello = "Manic Miner";
116 XSizeHints hint;
117 XSetWindowAttributes xswa;
118 XColor cursorfg, cursorbg;
119 int screen;
120
121
122 display = XOpenDisplay(name);
123
124 if (display == NULL)
125 error("Cannot open display.\n");
126
127 screen = DefaultScreen(display);
128
129 printf("DefaultDepth: %d, DisplayCells: %d, defaultvisualid: %ld, defaultclass: %d, BYTESDEEP: ",
130 DefaultDepth(display,screen),
131 DisplayCells(display,screen),
132 DefaultVisual(display,screen)->visualid,
133 DefaultVisual(display,screen)->class);
134
135 has_colourmap = (DefaultVisual(display,screen)->class&1);
136 depth = DefaultDepth(display,screen);
137 bytesdeep = (int)ceil(((double)depth)/8.0);
138 depth_bytes = bytesdeep = bytesdeep == 3 ? 4 : bytesdeep;
139
140 printf("%d \n\n", depth_bytes);
141
142 if ((bytesdeep!=1)&&(bytesdeep!=2)&&(bytesdeep!=4))
143 {
144 error("!!!WARNING!!!\nThis game probably can't cope with your X server's graphics mode.\nWe like 8, 15/16, or 32-bit modes.\nWe'll carry on regardless.\nIt probably won't work.\n");
145 }
146
147
148 hint.width = hint.max_width = hint.min_width = wwidth;
149 hint.height = hint.max_height =hint.min_height = wheight;
150
151 hint.flags = PSize|PMinSize|PMaxSize;
152
153 window = XCreateWindow(display, DefaultRootWindow(display), 0,0,
154 hint.width, hint.height, 0,
155 CopyFromParent, InputOutput, CopyFromParent,
156 0, NULL);
157
158 XSetWMNormalHints( display, window, &hint );
159
160 cursor = XCreateFontCursor( display, XC_circle );
161 cursorfg.red = 65535;
162 cursorfg.blue = cursorfg.green = 0;
163 cursorbg.red = cursorbg.green = cursorbg.blue = 0;
164 XRecolorCursor( display, cursor, &cursorfg, &cursorbg );
165 XDefineCursor( display, window, cursor );
166
167
168 xswa.event_mask = KeyPressMask | KeyReleaseMask
169 | EnterWindowMask | LeaveWindowMask;
170 XSelectInput(display, window, xswa.event_mask);
171
172 XSetStandardProperties (display, window, hello, hello, None, NULL, 0, &hint);
173 XMapWindow(display, window);
174
175 /* allocate colours */
176 gc = DefaultGC(display, screen);
177 cmap = DefaultColormap(display, screen);
178
179 pix = calloc(1, 256 * bytesdeep);
180
181 if (XShmQueryExtension(display))
182 {
183 shmem_flag = 1;
184 printf("Using SHM. Neat.\n");
185 }
186 else
187 {
188 shmem_flag = 0;
189 fprintf(stderr, "Ugh, no SHM. Never mind.\n");
190 }
191
192 XSync(display, False);
193
194 /************** SHM INIT *************************************/
195
196 InstallXErrorHandler();
197
198 if (shmem_flag)
199 {
200 ximage = XShmCreateImage(display, None, depth, ZPixmap, NULL,
201 &shminfo1,
202 wwidth, wheight);
203
204 /* If no go, then revert to normal Xlib calls. */
205
206 if (ximage==NULL)
207 {
208 if (ximage!=NULL)
209 XDestroyImage(ximage);
210 fprintf(stderr, "Shared memory error, disabling (Ximage error)\n");
211 }
212
213 /* Success here, continue. */
214
215 shminfo1.shmid = shmget(IPC_PRIVATE,
216 wwidth*wheight*depth_bytes,
217 IPC_CREAT | 0777);
218
219 if (shminfo1.shmid<0)
220 {
221 XDestroyImage(ximage);
222 fprintf(stderr, "Shared memory error, disabling (seg id error)\n");
223 }
224
225 shminfo1.shmaddr = (char *) shmat(shminfo1.shmid, 0, 0);
226
227 if (shminfo1.shmaddr==((char *) -1))
228 {
229 XDestroyImage(ximage);
230 if (shminfo1.shmaddr!=((char *) -1))
231 shmdt(shminfo1.shmaddr);
232 fprintf(stderr, "Shared memory error, disabling (address error)\n");
233 }
234
235 ximage->data = shminfo1.shmaddr;
236
237 shminfo1.readOnly = False;
238 XShmAttach(display, &shminfo1);
239
240 XSync(display, False);
241
242 if (gXErrorFlag)
243 {
244 /* Ultimate failure here. */
245 XDestroyImage(ximage);
246 shmdt(shminfo1.shmaddr);
247 fprintf(stderr, "Shared memory error, disabling.\n");
248 gXErrorFlag = 0;
249 }
250 else
251 {
252 shmctl(shminfo1.shmid, IPC_RMID, 0);
253 }
254
255 fprintf(stderr, "Sharing memory. [ %d x %d ]\n",wwidth,wheight);
256 }
257
258 DeInstallXErrorHandler();
259
260 /********* END OF SHM INIT ***********************************/
261 XSync(display, False);
262 }
263 #endif
264 /************** END OF X INIT STUFF **************************/
265 /*************************************************************/
266 /*************************************************************/
267
268
269
270 unsigned long Old_Isr;
271 BYTE KeyTable[256];
272 /*/////////////////////////////////////////////////////////////
273 // Revision Number
274 /////////////////////////////////////////////////////////////*/
275 BYTE VERSION[]={"V1.07"};
276
277
278
279 /* ADMNOTE: darn case-insensitive DOS C compilers ;) */
280 #define DrawEUGENE DrawEugene
281 #define DrawKONG DrawKong
282 #define DrawWILLY DrawWilly
283 #define DrawVROBO DrawVRobo
284 #define cls Cls
285
286
287 /* LINUX SOUND STUFF */
288 int dsp;
289 int enable_sound;
290 #define SOUNDDEVICE "/dev/dsp"
291 #define SAMPLERATE 44100
292
293 /* ADMNOTE: MIDAS STUBS - FIXME */
294 /*
295 typedef struct _MIDASsampleSTRUCT
296 {
297 BYTE* data;
298 int length;
299 } MIDASsampleSTRUCT;
300 typedef MIDASsampleSTRUCT* MIDASsample;
301 typedef void* MIDASmodule;
302 typedef void* MIDASmodulePlayHandle;
303 typedef void* MIDASplayStatus;
304 void MIDASstartup(void)
305 {
306 int bits = AFMT_U8;
307 int stereo = 0;
308 int rate = SAMPLERATE;
309 int frag=0x00020009;
310
311 if ((dsp=open(SOUNDDEVICE,O_WRONLY))==-1)
312 {
313 perror(SOUNDDEVICE);
314 enable_sound = 0;
315 return;
316 }
317
318 enable_sound = 1;
319
320 ioctl(dsp,SNDCTL_DSP_SETFRAGMENT, &frag);
321 ioctl(dsp,SNDCTL_DSP_RESET);
322 ioctl(dsp,SNDCTL_DSP_SAMPLESIZE,&bits);
323 ioctl(dsp,SNDCTL_DSP_STEREO,&stereo);
324 ioctl(dsp,SNDCTL_DSP_SPEED,&rate);
325 ioctl(dsp,SNDCTL_DSP_SYNC);
326 ioctl(dsp,SNDCTL_DSP_NONBLOCK);
327 }
328 void MIDASconfig(void) {};
329 void MIDASsaveConfig(char* a) {};
330 void MIDASloadConfig(char* a) {};
331 int MIDASgetDisplayRefreshRate(void) {};
332 int MIDASinit(void) {};
333 void MIDASsetOption(int a, int b) {};
334 void* MIDASloadModule(char* a) {};
335 void* MIDASloadWaveSample(char* a, int b)
336 {
337 MIDASsample newsample;
338 struct stat sts;
339 FILE* fp;
340
341 newsample = malloc(sizeof(MIDASsampleSTRUCT));
342
343 stat(a, &sts);
344 newsample->length = sts.st_size;
345
346 newsample->data = malloc(newsample->length);
347
348 fp = fopen(a, "rb");
349 fread(newsample->data, newsample->length, 1, fp);
350 fclose(fp);
351
352 return(newsample);
353 }
354 void MIDASsetTimerCallbacks(int a, int b, char* c, char* d, char* e) {};
355 void MIDASopenChannels(int a) {};
356 void MIDASstopModule(void* a) {};
357 void MIDAScloseChannels(void) {};
358 void MIDASclose(void) {};
359 void MIDASfreeModule(void* a) {};
360 void MIDASfreeSample(void* a)
361 {
362 free(((MIDASsample)a)->data);
363 free((MIDASsample)a);
364 }
365 void MIDASplaySample(void* a, int b, int c, int d, int e, int f)
366 {
367 if (enable_sound)
368 {
369 if (d==SAMPLERATE)
370 {
371 //int rate = d;
372 // ioctl(dsp,SNDCTL_DSP_SPEED,&rate);
373 write(dsp, ((MIDASsample)a)->data, ((MIDASsample)a)->length);
374 }
375 else
376 {
377 int i,j,len,destlen;
378 static BYTE* sbuff = NULL;
379 static sbuff_len = 0;
380
381 len = ((MIDASsample)a)->length;
382 destlen = (len*SAMPLERATE)/d;
383
384 if (destlen > sbuff_len)
385 {
386 free(sbuff);
387 sbuff = malloc(destlen);
388 sbuff_len = destlen;
389 }
390
391 for (i=0;i<destlen;i++)
392 sbuff[i] = ((((MIDASsample)a)->data)[(i*len)/destlen]);
393
394
395 write(dsp, sbuff, destlen);
396 }
397 }
398 }
399 void* MIDASplayModuleSection(void* a, int b, int c, int d, int e) {};
400 void* MIDASplayMoleSection(void* a, int b, int c, int d, int e) {};
401 void MIDASsetMusicVolume(void* a, int b) {};
402 void MIDASgetPlayStatus(void* a, void* b) {};
403 #define MIDAS_CALL
404 #define TRUE (0==0)
405 #define FALSE (0!=0)
406 #define MIDAS_OPTION_FILTER_MODE 0
407 #define MIDAS_FILTER_NONE 0
408 #define MIDAS_LOOP_NO 0
409 #define MIDAS_PAN_MIDDLE 0
410 */
411
412 #define MIDAS_CALL /**/
413 #define TRUE (0==0)
414 #define FALSE (0!=0)
415 #define MIDAS_OPTION_FILTER_MODE 0
416 #define MIDAS_FILTER_NONE 0
417 #define MIDAS_LOOP_NO 0
418 #define MIDAS_PAN_MIDDLE 0
419 #ifdef USE_MIKMOD
420 typedef SAMPLE* MIDASsample;
421 typedef UNIMOD* MIDASmodule;
422 typedef UNIMOD* MIDASmodulePlayHandle;
423 #else
424 typedef char* MIDASsample;
425 typedef char* MIDASmodule;
426 typedef char* MIDASmodulePlayHandle;
427 #endif
428 void MIDASstartup(void)
429 {
430 #ifdef USE_MIKMOD
431 md_mixfreq = 44100; /* standard mixing freq */
432 md_dmabufsize = 1024; /* standard dma buf size (max 32000) */
433 md_device = 0; /* standard device: autodetect */
434 md_volume = 128; /* driver volume (max 128) */
435 md_musicvolume = 128; /* music volume (max 128) */
436 md_sndfxvolume = 128; /* sound effects volume (max 128) */
437 md_pansep = 100; /* panning separation (0 = mono, 128 = full stereo) */
438 md_reverb = 0; /* Reverb (max 15) */
439 md_mode = DMODE_16BITS |
440 DMODE_INTERP |
441 DMODE_STEREO |
442 DMODE_SOFT_MUSIC |
443 DMODE_SOFT_SNDFX; /* default mixing mode */
444
445 MikMod_RegisterAllLoaders();
446 MikMod_RegisterAllDrivers();
447 MikMod_SetNumVoices(6,6);
448 #endif
449 }
450 void MIDASconfig(void) {};
451 void MIDASsaveConfig(char* a) {};
452 void MIDASloadConfig(char* a) {};
453 int MIDASgetDisplayRefreshRate(void) {};
454 int MIDASinit(void)
455 {
456 #ifdef USE_MIKMOD
457 MikMod_Init();
458 #endif
459 return TRUE;
460 }
461 void MIDASsetOption(int a, int b) {};
462 MIDASmodule MIDASloadModule(char* a)
463 {
464 MIDASmodule s;
465
466 #ifdef USE_MIKMOD
467 s = MikMod_LoadSong(a, 6);
468 #endif
469
470 return s;
471 };
472 MIDASsample MIDASloadWaveSample(char* a, int b)
473 {
474 MIDASsample newsample;
475 #ifdef USE_MIKMOD
476 struct stat sts;
477 FILE* fp;
478
479 newsample = calloc(1, sizeof(SAMPLE));
480
481 stat(a, &sts);
482
483 newsample->length = sts.st_size;
484 /* newsample->flags = SF_UNSIGNED; */
485 newsample->speed = 22050;
486 newsample->volume = 63;
487
488 fp = fopen(a, "rb");
489 SL_RegisterSample(newsample,MD_SNDFX,fp);
490 SL_LoadSamples();
491
492 /* printf("%p\n",newsample);fflush(stdout); */
493 #endif
494
495 return(newsample);
496 }
497 void MIDASsetTimerCallbacks(int a, int b, char* c, char* d, char* e) {};
498 void MIDASopenChannels(int a) {};
499 void MIDASstopModule(void* a)
500 {
501 #ifdef USE_MIKMOD
502 MP_SetPosition(a, 17);
503 /* MikMod_Update(); */
504 Player_Stop();
505 #endif
506 }
507 void MIDAScloseChannels(void) {};
508 void MIDASclose(void) {};
509 void MIDASfreeModule(MIDASmodule a) {};
510 void MIDASfreeSample(MIDASsample a)
511 {
512 #ifdef USE_MIKMOD
513 if (a != NULL)
514 {
515 MD_SampleUnLoad(a->handle);
516 free(a);
517 }
518 #endif
519 }
520 void MIDASplaySample(MIDASsample a, int b, int c, int d, int e, int f)
521 {
522 #ifdef USE_MIKMOD
523 int voice;
524
525 /* MikMod_Update(); */
526 voice = MikMod_PlaySample(a, 0, 0);
527 /* Voice_SetVolume(voice, e); */
528 Voice_SetFrequency(voice, d);
529 Voice_SetPanning(voice, 128);
530 /* MikMod_Update(); */
531 #endif
532 }
533 MIDASmodule MIDASplayModuleSection(MIDASmodule a, int b, int c, int d, int e)
534 {
535 #ifdef USE_MIKMOD
536 MP_SetPosition(a, b);
537
538 Player_Start(a);
539 /* MikMod_Update(); */
540 #endif
541 return a;
542 }
543 void MIDASsetMusicVolume(MIDASmodule a, int b)
544 {
545 /* md_musicvolume = (b*127)/64; */
546 }
547
548
549
550
551 /*/////////////////////////////////////////////////////////////
552 // Includes
553 /////////////////////////////////////////////////////////////*/
554 #include "mm-pal.c"
555
556 #include "mm-map2.c"
557 #include "mm-blocx.c"
558 #include "mm-conv.c"
559 #include "mm-exits.c"
560 #include "mm-keys2.c"
561 #include "mm-tplat.c"
562 #include "mm-air.c"
563 #include "mm-hrobo.c"
564 #include "mm-vrobo.c"
565 #include "mm-final.c"
566 #include "mm-swit.c"
567 #include "mm-font.c"
568 #include "mm-fant.c"
569 #include "mm-over.c"
570
571 #include "mm-eug2.c"
572 #include "mm-kong.c"
573 #include "mm-sky.c"
574 #include "mm-sun.c"
575 #include "mm-fill.c"
576 #include "mm-piano.c"
577 #include "mm-pkeys.c"
578 #include "mm-load.c"
579
580 #include "mm-willy.c"
581 #include "mm-ftsml.c"
582
583 #include "mm-house.c"
584 #include "mm-win.c"
585
586 #include "mm-end.c"
587
588 /*/////////////////////////////////////////////////////////////
589 // Globals
590 /////////////////////////////////////////////////////////////*/
591
592 BYTE old_video;
593 /*ADMNOTE
594 //BYTE *screen=(BYTE *)0xa0000;
595 //BYTE screen[64000 * 4]; */
596 BYTE* screen = NULL;
597 #ifdef USE_X11
598 #else
599 BYTE* realscreen = NULL;
600 #endif
601 BYTE page1[64000];
602 BYTE page2[64000];
603 int pix_offset = 0;
604 int yoff[400];
605
606 BYTE page,vpage;
607
608 BYTE bright[]= {0,1,2,3,4,5,6,7,8,7,6,5,4,3,2,1};
609 BYTE bright2[]={0,1,2,3,4,3,2,1,0,1,2,3,4,3,2,1};
610
611 #define KONGPAUSE 8
612
613 BYTE PALwhite[768];
614 BYTE PALblack[768];
615 BYTE PALfade[768];
616 BYTE PALover[768];
617
618 /*/////////////////////////////////////////////////////////////
619 // Current Map Info
620 /////////////////////////////////////////////////////////////*/
621
622 BYTE cMAP[512];
623 BYTE cCRUMB[512];
624 BYTE cTITLE[33];
625
626 BYTE cBGink;
627 BYTE cBGpaper;
628
629 BYTE cPLAT1ink;
630 BYTE cPLAT1paper;
631
632 BYTE cPLAT2ink;
633 BYTE cPLAT2paper;
634
635 BYTE cWALLink;
636 BYTE cWALLpaper;
637
638 BYTE cCRUMBink;
639 BYTE cCRUMBpaper;
640
641 BYTE cKILL1ink;
642 BYTE cKILL1paper;
643
644 BYTE cKILL2ink;
645 BYTE cKILL2paper;
646
647 BYTE cCONVink;
648 BYTE cCONVpaper;
649
650 BYTE cBORDER;
651
652 BYTE cPLAT1gfx;
653 BYTE cPLAT2gfx;
654 BYTE cWALLgfx;
655 BYTE cCRUMBgfx;
656 BYTE cKILL1gfx;
657 BYTE cKILL2gfx;
658 BYTE cCONVgfx;
659 BYTE cEXITgfx;
660 BYTE cKEYgfx;
661
662 WORD cWILLYx;
663 WORD cWILLYy;
664 WORD cWILLYxold[2];
665 WORD cWILLYyold[2];
666 WORD cWILLYf;
667 BYTE cWILLYd;
668 BYTE cWILLYm;
669 BYTE cWILLYj;
670 BYTE cWILLYbuff[2][256];
671 WORD cWILLYjp[]={4,4,3,3,2,2,1,1,0,0,1,1,2,2,3,3,4,4};
672 WORD cWILLYfall;
673 WORD cWILLYjs;
674
675 WORD cCONVx;
676 WORD cCONVy;
677 BYTE cCONVd;
678 BYTE cCONVl;
679 BYTE cCONVf;
680 BYTE cCONVm;
681
682 WORD cKEYx[5];
683 WORD cKEYy[5];
684 BYTE cKEYb[5];
685 BYTE cKEYs[5];
686
687 WORD cSWITCHx[2];
688 WORD cSWITCHy[2];
689 BYTE cSWITCHs[2];
690
691 WORD cEXITx;
692 WORD cEXITy;
693 BYTE cEXITb;
694 BYTE cEXITm;
695
696 BYTE cAIR;
697 BYTE cAIRp;
698
699 BYTE cHROBOink[4];
700 BYTE cHROBOpaper[4];
701 WORD cHROBOx[4];
702 WORD cHROBOy[4];
703 WORD cHROBOmin[4];
704 WORD cHROBOmax[4];
705 BYTE cHROBOd[4];
706 BYTE cHROBOs[4];
707 WORD cHROBOgfx[4];
708 BYTE cHROBOflip[4];
709 BYTE cHROBOanim[4];
710 WORD cHROBOxold[4][2];
711 WORD cHROBOyold[4][2];
712
713 BYTE cVROBOink[4];
714 BYTE cVROBOpaper[4];
715 WORD cVROBOx[4];
716 WORD cVROBOy[4];
717 WORD cVROBOmin[4];
718 WORD cVROBOmax[4];
719 BYTE cVROBOd[4];
720 BYTE cVROBOs[4];
721 WORD cVROBOgfx[4];
722 BYTE cVROBOanim[4];
723 WORD cVROBOxold[4][2];
724 WORD cVROBOyold[4][2];
725
726 /*/////////////////////////////////////////////////////////////
727 // Special Robots
728 /////////////////////////////////////////////////////////////*/
729
730 WORD EUGENEx;
731 WORD EUGENEy;
732 WORD EUGENEmin;
733 WORD EUGENEmax;
734 BYTE EUGENEd;
735 BYTE EUGENEm;
736 BYTE EUGENEc;
737 WORD EUGENExold[2];
738 WORD EUGENEyold[2];
739
740 BYTE SWITCH1m;
741 BYTE SWITCH2m;
742
743 WORD HOLEy;
744 BYTE HOLEl;
745
746 WORD KONGx;
747 WORD KONGy;
748 WORD KONGxold[2];
749 WORD KONGyold[2];
750 WORD KONGmax;
751 BYTE KONGm;
752 BYTE KONGc;
753 BYTE KONGf;
754 BYTE KONGp;
755
756 WORD SKYx[3];
757 WORD SKYy[3];
758 WORD SKYmax[3];
759 WORD SKYxold[3][2];
760 WORD SKYyold[3][2];
761 BYTE SKYs[3];
762 BYTE SKYf[3];
763 BYTE SKYm[3];
764 BYTE SKYc[3];
765 BYTE SKYp[3];
766
767 BYTE DEATHm;
768 WORD DEATHc;
769
770 WORD BOOTy;
771
772 WORD SUNy;
773 BYTE SUNm;
774 BYTE SUNh;
775 BYTE SUNbuff[2][384];
776 WORD SUNyold[2];
777 BYTE SUNhold[2];
778
779 /*/////////////////////////////////////////////////////////////
780 // Solar Power Generator
781 /////////////////////////////////////////////////////////////*/
782
783 WORD SPGx[2][64];
784 WORD SPGy[2][64];
785
786 /*/////////////////////////////////////////////////////////////
787 // Game Globals
788 /////////////////////////////////////////////////////////////*/
789
790 unsigned long SCORE;
791 unsigned long HISCORE=0;
792 unsigned long EXTRA;
793 unsigned long EXTRAdelta=10000;
794 BYTE EXTRAm;
795 BYTE EXTRAc;
796
797 WORD LIVES;
798 BYTE LIVESf;
799 BYTE LIVESp;
800 BYTE LEVEL=0;
801
802 BYTE MUSICon=1;
803
804 BYTE old=0;
805
806 BYTE SPEED=2;
807
808 BYTE MODE=3;
809 BYTE GAMEm=0;
810
811 BYTE DEMOm=0;
812 BYTE DEMOp;
813
814 BYTE TITLEm=0;
815 BYTE TITLEwf;
816 BYTE TITLEwp;
817
818 BYTE OVERm=0;
819 BYTE OVERink;
820 BYTE OVERp;
821
822 BYTE INK=7;
823 BYTE PAPER=0;
824
825 BYTE CHEAT=0;
826 BYTE CHEATp=0;
827 BYTE CHEATh;
828 BYTE CHEATkey[]={9,11,3,10,3,7};
829
830 BYTE PAUSE;
831 BYTE LASTm;
832 WORD LASTc;
833 BYTE LASTp;
834 WORD WINDOW[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
835
836 BYTE TEXTm;
837 WORD TEXTpause;
838 BYTE TEXTpoint;
839 BYTE TEXTink;
840 BYTE TEXTfade;
841
842 /*///////////////////////////////////////////////////////////*/
843
844 BYTE PIANOkhit[32];
845 BYTE PIANOkey[]={0,1,1,2,0,1,2,0,1,1,2,0,1,2,0,1,2,0,1,1,2,0,1,2,0,1,1,2,0,1,2,3};
846 WORD PIANOc;
847 BYTE PIANObodge1;
848 BYTE PIANObodge2;
849 BYTE PIANObodgep;
850 BYTE PIANObodgep2;
851
852 BYTE SCROLLbuff[]=" ";
853 WORD SCROLLpos;
854 BYTE PIXELbuff[264*8];
855 WORD PIXELoff;
856
857 BYTE LOADm;
858 BYTE LOADp;
859
860 BYTE PREFSm;
861 BYTE PREFSh1;
862 BYTE PREFSh2;
863 BYTE PREFSh3;
864
865 BYTE CHAN[]={0,1,2,8,9,10,16,17,18};
866
867
868 /*/////////////////////////////////////////////////////////////
869 // Tales from a Parallel Universe
870 /////////////////////////////////////////////////////////////*/
871
872 BYTE TONKS=0;
873
874 /*/////////////////////////////////////////////////////////////
875 // Audio Stuff
876 /////////////////////////////////////////////////////////////*/
877 #define INGAMEpc 0x00
878 #define INGAMEspec 0x09
879 #define TITLEmusic 0x0d
880 #define OPTIONSmusic 0x12
881 #define FINALcavern 0x16
882 #define ENDsequence 0x20
883
884 BYTE MUSICtype=0;
885 BYTE VOL=64;
886
887 BYTE MUSICh;
888
889
890
891
892 /*ADMNOTE: we manually handle timers on UNIX
893 //WORD volatile FrCt=0; */
894 WORD FrCt=0;
895 /* 60 Hz */
896 #define FHZ 60
897 #define microsec_per_frame 16666
898 WORD UpdateFrCt(void)
899 {
900 static int firsttime = TRUE;
901 static long long first_timer_ctr;
902 static long long this_timer_ctr;
903 static int this_frnum;
904 static int last_frnum;
905 struct timeval tv;
906
907 if (firsttime)
908 {
909 gettimeofday(&tv, NULL);
910 first_timer_ctr = (tv.tv_sec*1000000)+tv.tv_usec;
911 firsttime = FALSE;
912 last_frnum = 0;
913 }
914
915 gettimeofday(&tv, NULL);
916 this_timer_ctr = (tv.tv_sec*1000000)+tv.tv_usec;
917
918 this_frnum = (this_timer_ctr - first_timer_ctr) / microsec_per_frame;
919
920 FrCt += (this_frnum - last_frnum);
921
922 last_frnum = this_frnum;
923
924 return(FrCt);
925 }
926
927
928 WORD NEXTBIT=0;
929 DWORD REFRESH;
930 MIDASsample wav;
931 MIDASsample die;
932 MIDASsample pick;
933 MIDASmodule mod;
934 MIDASmodulePlayHandle modon=0;
935
936 BYTE FORCE;
937 /*/////////////////////////////////////////////////////////////
938 //
939 /////////////////////////////////////////////////////////////*/
940
941 void MIDAS_CALL PREvr(void);
942
943 /*/////////////////////////////////////////////////////////////
944 // Main Code.
945 /////////////////////////////////////////////////////////////*/
946 int main(int argc, BYTE *argv[])
947 {
948 int quit=0;
949
950 #ifdef USE_X11
951 init_Xdisplay(NULL);
952
953 slowdown_init(FHZ);
954 #else
955 /*ADMNOTE: set up SVGALIB */
956 vga_init();
957 vga_setmode(5);
958 keyboard_init();
959 keyboard_setdefaulteventhandler();
960 realscreen=(BYTE*) vga_getgraphmem();
961 #endif
962
963 pix_offset = 33 + 4*320; /* for screen centering in this mode */
964
965
966 if(argc==2)
967 {
968 FORCE=1;
969 }
970 else
971 {
972 FORCE=0;
973 }
974
975 MIDASstartup();
976
977 LoadInfo();
978
979 SetupSound();
980
981 GetVideoMode( &old_video );
982
983 screen = page1;
984
985 /*------------------------------------------------------------- */
986
987 REFRESH=MIDASgetDisplayRefreshRate();
988 if(REFRESH==0)
989 REFRESH=59450;
990
991 MIDASsetOption(MIDAS_OPTION_FILTER_MODE,MIDAS_FILTER_NONE);
992
993 if(MIDASinit()==FALSE)
994 {
995 return(0);
996 }
997
998 mod=MIDASloadModule("mm-data1.dat");
999 //ADMNOTE: filenames changed, now not M$ wav
1000 wav=MIDASloadWaveSample("mm-data2.raw",MIDAS_LOOP_NO);
1001 die=MIDASloadWaveSample("mm-data3.raw",MIDAS_LOOP_NO);
1002 pick=MIDASloadWaveSample("mm-data4.raw",MIDAS_LOOP_NO);
1003 /* wav=MIDASloadWaveSample("mm-data2.dat",MIDAS_LOOP_NO);
1004 die=MIDASloadWaveSample("mm-data3.dat",MIDAS_LOOP_NO);
1005 pick=MIDASloadWaveSample("mm-data4.dat",MIDAS_LOOP_NO);*/
1006
1007 MIDASsetTimerCallbacks(REFRESH,TRUE,&PREvr,NULL,NULL);
1008 MIDASopenChannels(9);
1009
1010 /*------------------------------------------------------------- */
1011
1012 SetKeyboard();
1013
1014 Cls(0);
1015 WaitVR();
1016 PaletteSet(PALblack);
1017
1018 WaitVR();
1019 Cls(0);
1020 SwapPage();
1021
1022 WaitVR();
1023 PaletteSet(PALmain);
1024 Cls(0);
1025 SwapPage();
1026
1027 LOADm=0;
1028
1029 do
1030 {
1031
1032
1033 switch(MODE)
1034 {
1035 case 0://TITLES
1036 Titles();
1037 break;
1038 case 1://DEMO
1039 DoDemo();
1040 break;
1041 case 2://GAME
1042 DoGame();
1043 break;
1044 case 3://LOADING
1045 DoLoading();
1046 break;
1047 }
1048
1049
1050 if( KeyTable[key_f10]==1 )
1051 quit=1;
1052
1053 }
1054 while( quit==0 );
1055
1056 /*------------------------------------------------------------- */
1057 if(modon!=0)
1058 MIDASstopModule(modon);
1059
1060 MIDAScloseChannels();
1061 MIDASfreeModule(mod);
1062 MIDASfreeSample(wav);
1063 MIDASfreeSample(die);
1064 MIDASfreeSample(pick);
1065 MIDASclose();
1066
1067 /*------------------------------------------------------------- */
1068
1069 WaitVR2();
1070 PaletteSet(PALblack);
1071
1072 WaitVR2();
1073 SetVideoMode(old_video);
1074
1075 SaveInfo();
1076
1077 printf("Manic Miner PC %s.\n",VERSION);
1078 printf("Andy Noble (andy@andyn.demon.co.uk) 8/1997 - DOS version\n");
1079 printf("Adam D. Moss (adam@foxbox.org) 12/1997 - UNIX port\n");
1080
1081 /*printf("Refresh=%d\n\n",REFRESH); */
1082
1083 /*ADMNOTE - vga/kbd stuff*/
1084 #ifdef USE_X11
1085 #else
1086 keyboard_close();
1087 vga_setmode(TEXT);
1088 #endif
1089
1090
1091 return(0);
1092 }
1093
1094 /*/////////////////////////////////////////////////////////////
1095 // Restore Bios Keyboard Interupt
1096 /////////////////////////////////////////////////////////////*/
1097 void RemoveKeyboard( void )
1098 {
1099 }
1100
1101 /*/////////////////////////////////////////////////////////////
1102 // Set Our Keyboard Interupt
1103 /////////////////////////////////////////////////////////////*/
1104 void SetKeyboard( void )
1105 {
1106
1107 memset( KeyTable, (BYTE)0, 256 );
1108
1109 }
1110
1111
1112 /*/////////////////////////////////////////////////////////////
1113 // Pressed any key ?
1114 /////////////////////////////////////////////////////////////*/
1115
1116 int
1117 AnyKeyx
1118 (void)
1119 {
1120
1121 int count;
1122
1123 /* ADMNOTE */
1124 /* if (random()%3000 == 0) return (1);*/
1125
1126 for( count=0; count<128; count++ )
1127 {
1128 if(KeyTable[count] != 0 )
1129 return(1);
1130 }
1131 return(0);
1132 }
1133
1134
1135 ///////////////////////////////////////////////////////////////
1136 // Flush our Keyboard Buffer
1137 ///////////////////////////////////////////////////////////////
1138 void FlushKey( void )
1139 {
1140 memset( KeyTable, (BYTE)0, 256 );
1141 }
1142
1143 ///////////////////////////////////////////////////////////////
1144 // Set Screen Mode.
1145 ///////////////////////////////////////////////////////////////
1146 void SetVideoMode(int mode)
1147 {
1148
1149 }
1150
1151 ///////////////////////////////////////////////////////////////
1152 // Get Screen Mode.
1153 ///////////////////////////////////////////////////////////////
1154 void GetVideoMode( BYTE *vidmode )
1155 {
1156
1157 }
1158
1159
1160 /*/////////////////////////////////////////////////////////////
1161 // Wait Vertical Retrace
1162 /////////////////////////////////////////////////////////////*/
1163 void WaitVR( void )
1164 {
1165 #ifdef USE_X11
1166 #else
1167 WORD old;
1168
1169 /*ADMNOTE*/
1170 old=UpdateFrCt();
1171 #endif
1172
1173 #ifdef USE_MIKMOD
1174 MikMod_Update();
1175 #endif
1176
1177 #ifdef USE_X11
1178 /*putchar('1'+slowdown_slow());*/
1179 XFlush(display);
1180 slowdown_slow();
1181 #else
1182 while(old==UpdateFrCt()) {};
1183 #endif
1184
1185 /*ADMNOTE: we throw in a keyboard check here! */
1186 DoKeymap();
1187
1188 /*old=FrCt;
1189 while(old==FrCt);*/
1190
1191 }
1192
1193 /*/////////////////////////////////////////////////////////////
1194 // Wait Vertical Retrace
1195 /////////////////////////////////////////////////////////////*/
1196 void WaitVR2( void )
1197 {
1198 DoKeymap();
1199
1200 #ifdef USE_MIKMOD
1201 MikMod_Update();
1202 #endif
1203
1204 WaitVR3();
1205
1206
1207 #ifdef USE_X11
1208
1209 #ifdef USE_MIKMOD
1210 MikMod_Update();
1211 #endif
1212 WaitVR3();
1213 #ifdef USE_MIKMOD
1214 MikMod_Update();
1215 #endif
1216 WaitVR3();
1217
1218 #else
1219 vga_waitretrace();
1220 #endif
1221
1222 }
1223
1224
1225
1226 /*/////////////////////////////////////////////////////////////
1227 // ADMNOTE: UNIX: Update keyboard state
1228 /////////////////////////////////////////////////////////////*/
1229 int DoKeymap ( void )
1230 {
1231 #ifdef USE_X11
1232
1233 KeySym ks = 0;
1234 int kstat;
1235 XEvent event;
1236 char buf[21];
1237
1238 while (XPending(display))
1239 {
1240 XNextEvent(display, &event);
1241
1242 switch (event.type)
1243 {
1244 case KeyPress:
1245 kstat = 1;
1246 case KeyRelease:
1247 if (event.type == KeyRelease)
1248 kstat = 0;
1249
1250 XLookupString(&event.xkey, buf, 20, &ks, NULL);
1251
1252 switch (ks)
1253 {
1254 case 0xFF0D : KeyTable[key_return] = kstat; break;
1255 case 0xFF52 :
1256 case 0xFF97 :
1257 case ' ' : KeyTable[key_space] = kstat; break;
1258 case 0xFF51 :
1259 case 'O' :
1260 case 'o' : KeyTable[key_o] = kstat; break;
1261 case 0xFF53 :
1262 case 'P' :
1263 case 'p' : KeyTable[key_p] = kstat; break;
1264 case 0xFF1B : KeyTable[key_esc] = kstat; break;
1265 case 0xFF91 :
1266 case 0xFFBE : KeyTable[key_f1] = kstat; break;
1267 case 0xFF92 :
1268 case 0xFFBF : KeyTable[key_f2] = kstat; break;
1269 case 0xFF93 :
1270 case 0xFFC0 : KeyTable[key_f3] = kstat; break;
1271 case 0xFF94 :
1272 case 0xFFC1 : KeyTable[key_f4] = kstat; break;
1273 case 0xFFC7 : KeyTable[key_f10] = kstat; break;
1274 default: break;
1275 }
1276
1277 break;
1278 default: break;
1279 }
1280 }
1281
1282 #else
1283 if (keyboard_update()==0) return;
1284
1285 /* Otherwise, something changed with the keyboard...
1286 // ah, sod it... */
1287
1288 memcpy(KeyTable, keyboard_getstate(), 256);
1289 #endif
1290 }
1291
1292
1293 /*
1294 * PHYSICALLY DISPLAY 'SCREEN'
1295 */
1296 void showscreen(void)
1297 {
1298 #ifdef USE_X11
1299 if (shmem_flag)
1300 {
1301 XShmPutImage(display, window, gc, ximage,
1302 0,0,
1303 0,0,
1304 wwidth, wheight, False);
1305 }
1306 else
1307 {
1308 XPutImage(display, window, gc, ximage,
1309 0,0,
1310 0,0,
1311 wwidth, wheight);
1312 }
1313 XSync(display, False);
1314 #else
1315 memcpy(realscreen, screen, 64000);
1316 #endif
1317 }
1318
1319
1320 /*/////////////////////////////////////////////////////////////
1321 // Swap Pages
1322 /////////////////////////////////////////////////////////////*/
1323 void SwapPage( void )
1324 {
1325 WORD data;
1326 BYTE temp;
1327
1328 /* ADMNOTE */
1329 page++;
1330 page&=1;
1331 vpage++;
1332 vpage&=1;
1333 WaitVR();
1334 showscreen();
1335 screen = (page==0 ? page1 : page2);
1336 old++;
1337 old&=1;
1338 return;
1339 }
1340 /*/////////////////////////////////////////////////////////////
1341 // Swap Pages
1342 /////////////////////////////////////////////////////////////*/
1343 void SwapPage2( void)
1344 {
1345 WORD data;
1346 BYTE temp;
1347
1348 /*ADMNOTE */
1349 page++;
1350 page&=1;
1351 vpage++;
1352 vpage&=1;
1353 WaitVR3();
1354 showscreen();
1355 screen = (page==0 ? page1 : page2);
1356 old++;
1357 old&=1;
1358 return;
1359 }
1360
1361 /*/////////////////////////////////////////////////////////////
1362 // Wait Vertical Retrace
1363 /////////////////////////////////////////////////////////////*/
1364 void WaitVR3( void )
1365 {
1366 WORD old;
1367
1368 /* ADMNOTE: */
1369
1370 #ifdef USE_MIKMOD
1371 MikMod_Update();
1372 #endif
1373
1374 #ifdef USE_X11
1375 /*putchar('1'+slowdown_slow()); */
1376 XFlush(display);
1377 slowdown_slow();
1378 #else
1379 while(NEXTBIT>=UpdateFrCt()) {};
1380 #endif
1381 FrCt=0;
1382 DoKeymap();
1383
1384 /*while(NEXTBIT>=FrCt);
1385 FrCt=0; */
1386 }
1387
1388 /*/////////////////////////////////////////////////////////////
1389 // Plot a Pixel to the Screen
1390 /////////////////////////////////////////////////////////////*/
1391
1392 void PlotPixel( int x, int y, BYTE colour )
1393 {
1394 int offset = 320*y + x + pix_offset;
1395
1396 screen[offset] = colour;
1397
1398 #ifdef USE_X11
1399 switch (bytesdeep)
1400 {
1401 case 1:
1402 ((uint8 *)ximage->data)[offset] = ((uint8 *)pix)[colour]; break;
1403 case 2:
1404 ((uint16 *)ximage->data)[offset] = ((uint16 *)pix)[colour]; break;
1405 default:
1406 ((uint32 *)ximage->data)[offset] = ((uint32 *)pix)[colour]; break;
1407 }
1408 #endif
1409 }
1410
1411 /*/////////////////////////////////////////////////////////////
1412 // Get a Pixel from the Screen
1413 /////////////////////////////////////////////////////////////*/
1414 char GetPixel( int x, int y )
1415 {
1416 return (screen[320*y + x + pix_offset]);
1417 }
1418
1419 /*/////////////////////////////////////////////////////////////
1420 // Clear Current Page
1421 /////////////////////////////////////////////////////////////*/
1422 void Cls( BYTE col )
1423 {
1424 int pcol, i;
1425 uint16* u16p;
1426 uint32* u32p;
1427
1428 memset(screen, col, 64000);
1429
1430 #ifdef USE_X11
1431 switch (bytesdeep)
1432 {
1433 case 1:
1434 pcol = ((uint8 *)pix)[col];
1435 memset((uint8 *)ximage->data, pcol, wwidth*wheight);
1436 break;
1437 case 2:
1438 pcol = ((uint16 *)pix)[col];
1439 u16p = (uint16 *)ximage->data;
1440 for (i=0;i<wwidth*wheight;i++)
1441 {
1442 *u16p++ = pcol;
1443 }
1444 break;
1445 default:
1446 pcol = ((uint32 *)pix)[col];
1447 u32p = (uint32 *)ximage->data;
1448 for (i=0;i<wwidth*wheight;i++)
1449 {
1450 *u32p++ = pcol;
1451 }
1452 break;
1453 }
1454 #endif
1455 }
1456
1457
1458 /*/////////////////////////////////////////////////////////////
1459 // Set Palette1 with Palette2
1460 /////////////////////////////////////////////////////////////*/
1461
1462 void PaletteFill( char *pal1, char *pal2 )
1463 {
1464 int count;
1465
1466 for(count=0;count<768;count++)
1467 pal1[count]=pal2[count];
1468 }
1469
1470 /*/////////////////////////////////////////////////////////////
1471 // Set palette
1472 /////////////////////////////////////////////////////////////*/
1473
1474 void PaletteSet( char *pal1 )
1475 {
1476 int count;
1477
1478 #ifdef USE_X11
1479 static uint8 *lastpal = NULL;
1480
1481 if (lastpal == NULL)
1482 {
1483 lastpal = calloc(1, 256*3);
1484 }
1485
1486 for (count=0; count<256; count++)
1487 {
1488 if (
1489 (lastpal[count*3+0] != pal1[count*3+0]) ||
1490 (lastpal[count*3+1] != pal1[count*3+1]) ||
1491 (lastpal[count*3+2] != pal1[count*3+2])
1492 )
1493 {
1494 pal[count].red = (pal1[count*3+0] * 65535) / 63 ;
1495 pal[count].green = (pal1[count*3+1] * 65535) / 63 ;
1496 pal[count].blue = (pal1[count*3+2] * 65535) / 63 ;
1497 pal[count].flags|=DoRed|DoGreen|DoBlue;
1498
1499 if ( XAllocColor(display, cmap, &pal[count]) == 0 )
1500 printf("** XAllocColor FAILED **\n");
1501
1502 switch (bytesdeep)
1503 {
1504 case 1: ((uint8 *)pix)[count] =
1505 (uint8) pal[count].pixel; break;
1506 case 2: ((uint16 *)pix)[count] =
1507 (uint16) pal[count].pixel; break;
1508 default: ((uint32 *)pix)[count] =
1509 (uint32) pal[count].pixel; break;
1510 }
1511 }
1512 }
1513 memcpy(lastpal, pal1, 256*3);
1514
1515 #else
1516
1517 for (count=0;count<256;count++)
1518 vga_setpalette(count,pal1[count*3],
1519 pal1[count*3 +1],
1520 pal1[count*3 +2]);
1521
1522 #endif
1523 }
1524
1525 /*/////////////////////////////////////////////////////////////
1526 // Fade Palette
1527 /////////////////////////////////////////////////////////////*/
1528
1529 int PaletteFade( unsigned char *pal1, unsigned char *pal2 )
1530 {
1531 int count,changed;
1532
1533 changed=0;
1534
1535 for(count=0;count<768;count++)
1536 {
1537
1538 if(*pal1 != *pal2)
1539 {
1540 if(*pal1 > *pal2)
1541 {
1542 *pal2+=1;
1543 changed=1;
1544 }
1545 else
1546 {
1547 *pal2-=1;
1548 changed=1;
1549 }
1550 }
1551
1552 pal1++;
1553 pal2++;
1554
1555 }
1556 return(changed);
1557 }
1558
1559 /*/////////////////////////////////////////////////////////////
1560 // Print Text
1561 /////////////////////////////////////////////////////////////*/
1562 void FontPrint( int xpos, int ypos, BYTE *text )
1563 {
1564 int count,count2,count3;
1565 int currentx,currenty;
1566 int alpha;
1567 BYTE *fonty;
1568
1569 count=0;
1570
1571 xpos*=8;
1572 ypos*=8;
1573
1574 currentx=xpos;
1575 currenty=ypos;
1576
1577 while( *text != 0 )
1578 {
1579 alpha=(int)*text;
1580 text++;
1581
1582 if(alpha==170) /*="|" */
1583 {
1584 currentx=0;
1585 currenty+=8;
1586 alpha=(int)*text;
1587 text++;
1588 }
1589
1590
1591 alpha-=32;
1592
1593 if(alpha>96)
1594 alpha-=32;
1595
1596 alpha*=64;
1597 count++;
1598 if(count==33)
1599 return;
1600
1601 fonty=(fontb+alpha);
1602
1603 xpos=currentx;
1604 ypos=currenty;
1605
1606 for(count2=0;count2<8;count2++)
1607 {
1608 for(count3=0;count3<8;count3++)
1609 {
1610 if( (*fonty != 0))
1611 PlotPixel(xpos,ypos,INK);
1612 else
1613 PlotPixel(xpos,ypos,PAPER);
1614
1615 fonty++;
1616 xpos++;
1617 }
1618 xpos=currentx;
1619 ypos++;
1620 }
1621 currentx+=8;
1622 }
1623
1624 }
1625 /*/////////////////////////////////////////////////////////////
1626 // Print Text
1627 /////////////////////////////////////////////////////////////*/
1628 void FontPrint2( int xpos, int ypos, BYTE *text )
1629 {
1630 int count,count2,count3;
1631 int currentx,currenty;
1632 int alpha;
1633 BYTE *fonty,*fonty2,data,data2;
1634
1635 count=0;
1636
1637 xpos*=8;
1638 ypos*=8;
1639
1640 currentx=xpos;
1641 currenty=ypos;
1642
1643 while( *text != 0 )
1644 {
1645 alpha=(int)*text;
1646 text++;
1647
1648 if(alpha==170) /*="|" */
1649 {
1650 currentx=0;
1651 currenty+=8;
1652 alpha=(int)*text;
1653 text++;
1654 }
1655
1656
1657 alpha-=32;
1658
1659 if(alpha>96)
1660 alpha-=32;
1661
1662 alpha*=64;
1663 count++;
1664 if(count==33)
1665 return;
1666
1667 fonty=(fontb+alpha);
1668 fonty2=(GFXfant+alpha);
1669
1670 xpos=currentx;
1671 ypos=currenty;
1672
1673 for(count2=0;count2<8;count2++)
1674 {
1675 for(count3=0;count3<8;count3++)
1676 {
1677 if( (*fonty != 0))
1678 PlotPixel(xpos,ypos,0);
1679 else
1680 {
1681 if(*fonty2==1)
1682 {
1683 data=GetPixel(xpos,ypos);
1684 data2=data&15;
1685 data2+=3;
1686 if(data2>15)
1687 data2=15;
1688 data&=240;
1689 data|=data2;
1690 PlotPixel(xpos,ypos,data);
1691 }
1692 }
1693 fonty++;
1694 fonty2++;
1695 xpos++;
1696 }
1697 xpos=currentx;
1698 ypos++;
1699 }
1700 currentx+=8;
1701 }
1702
1703 }
1704
1705
1706 /*/////////////////////////////////////////////////////////////
1707 // Show a Long Word
1708 /////////////////////////////////////////////////////////////*/
1709 void ShowSix( int xpos, int ypos, unsigned long data )
1710 {
1711 BYTE convtext[]={" "};
1712 BYTE printtext[]={" "};
1713 int count1,count2;
1714 BYTE *pointy;
1715
1716 /* ADMNOTE: no ultoa in ansi/iso C
1717 /* ultoa( data,&convtext,10);*/
1718 sprintf(convtext, "%u", data);
1719
1720 count2=0;
1721 for(count1=0;count1<7;count1++)
1722 {
1723 if(convtext[count1]!=32)
1724 count2++;
1725 }
1726
1727 pointy=printtext+7;
1728 pointy-=count2;
1729
1730 for(count1=0;count1<count2;count1++)
1731 {
1732 *pointy=convtext[count1];
1733 pointy++;
1734 }
1735
1736
1737 for(count1=0;count1<6;count1++)
1738 {
1739 if(printtext[count1]==32)
1740 printtext[count1]=48;
1741 }
1742
1743 FontPrint(xpos,ypos,&printtext);
1744 }
1745
1746 /*/////////////////////////////////////////////////////////////
1747 // Print Text Small
1748 /////////////////////////////////////////////////////////////*/
1749 void FontPrintSmall( int xpos, int ypos, BYTE *text )
1750 {
1751 int count,count2,count3;
1752 int currentx,currenty;
1753 int alpha;
1754 BYTE *fonty;
1755
1756 count=0;
1757
1758 xpos*=4;
1759 ypos*=6;
1760
1761 currentx=xpos;
1762 currenty=ypos;
1763
1764 while( *text != 0 )
1765 {
1766 alpha=(int)*text;
1767 text++;
1768
1769 if(alpha==170) /*="ª" */
1770 {
1771 currentx=0;
1772 currenty+=8;
1773 alpha=(int)*text;
1774 text++;
1775 }
1776
1777 if(alpha==96) /*="`" */
1778 {
1779 INK=(*text)-96;
1780 text++;
1781 alpha=(int)*text;
1782 text++;
1783 }
1784
1785 alpha-=32;
1786
1787 if(alpha>64)
1788 alpha-=32;
1789
1790 alpha*=64;
1791
1792 fonty=(fonts+alpha);
1793
1794 xpos=currentx;
1795 ypos=currenty;
1796
1797 for(count2=0;count2<6;count2++)
1798 {
1799 for(count3=0;count3<4;count3++)
1800 {
1801 if( (*fonty != 0))
1802 PlotPixel(xpos,ypos,INK);
1803 else
1804 PlotPixel(xpos,ypos,PAPER);
1805
1806 fonty++;
1807 xpos++;
1808 }
1809 fonty+=4;
1810 xpos=currentx;
1811 ypos++;
1812 }
1813 currentx+=4;
1814 }
1815
1816 }
1817
1818 /*/////////////////////////////////////////////////////////////
1819 // Main Code Includes
1820 /////////////////////////////////////////////////////////////*/
1821 #include "mm-core.c"
1822 #include "mm-game.c"
1823 #include "mm-demo.c"
1824 /*/////////////////////////////////////////////////////////////
1825 // Titles
1826 /////////////////////////////////////////////////////////////*/
1827 void Titles(void)
1828 {
1829 switch(TITLEm)
1830 {
1831 case 0:
1832 TitleSetup();
1833 break;
1834 case 1:
1835 DoPiano();
1836 break;
1837 case 2:
1838 ClearPiano();
1839 break;
1840 case 3:
1841 DoTitleScroll();
1842 break;
1843 case 4:
1844 DoPrefs();
1845 break;
1846
1847 }
1848 }
1849 /*/////////////////////////////////////////////////////////////
1850 // Do Background Fill 1
1851 /////////////////////////////////////////////////////////////*/
1852 void Fill1(void)
1853 {
1854 int x,y,block2;
1855 BYTE data;
1856
1857 block2=0;
1858
1859 for(y=0;y<24;y++)
1860 {
1861 for(x=0;x<16;x++)
1862 {
1863 data=GFXfill[block2];
1864 PlotPixel(152+x,40+y,data);
1865 block2++;
1866 }
1867 }
1868 }
1869
1870 /*////////////////////////////////////////////////////////////
1871 // Do Background Fill 2
1872 /////////////////////////////////////////////////////////////*/
1873 void Fill2(void)
1874 {
1875 int x,y,block2;
1876 BYTE data;
1877
1878 block2=384;
1879
1880 for(y=0;y<24;y++)
1881 {
1882 for(x=0;x<72;x++)
1883 {
1884 data=GFXfill[block2];
1885 PlotPixel(176+x,40+y,data);
1886 block2++;
1887 }
1888 }
1889 }
1890 /*/////////////////////////////////////////////////////////////
1891 // Setup Tiltes
1892 /////////////////////////////////////////////////////////////*/
1893 void TitleSetup(void)
1894 {
1895 int i;
1896
1897 for(i=0;i<768;i++)
1898 {
1899 PALover[i]=PALmain[i];
1900 }
1901
1902 PIANOc=0;
1903 for(i=0;i<32;i++)
1904 PIANOkhit[i]=0;
1905
1906 TITLEwf=2;
1907 TITLEwp=0;
1908 SCROLLpos=0;
1909 PIXELoff=0;
1910
1911 UpdateScrollBuffer();
1912 FillPixelBuff();
1913
1914 TITLEm=1;
1915
1916 modon=MIDASplayModuleSection(mod,0x0d,0x11,0x0d,FALSE);
1917
1918 TitleSetupExtra();
1919 SwapPage();
1920 PaletteSet(PALmain);
1921 TitleSetupExtra();
1922 SwapPage();
1923
1924 }
1925 /*/////////////////////////////////////////////////////////////
1926 // Setup Extra Bits
1927 /////////////////////////////////////////////////////////////*/
1928 void TitleSetupExtra(void)
1929 {
1930 int i;
1931
1932 cls(240);
1933
1934 PAPER=0;
1935 for(i=0;i<24;i++)
1936 {
1937 FontPrint(0,i," ");
1938 }
1939 DrawFinal();
1940
1941 SUNm=1;
1942 SUNy=32;
1943 SUNh=16;
1944 DoSun();
1945
1946 Fill1();
1947 Fill2();
1948
1949 DrawPiano();
1950 DrawWilly4(TITLEwf);
1951
1952 DrawTPlate2();
1953 DrawAirBG();
1954
1955 }
1956 /*/////////////////////////////////////////////////////////////
1957 // Draw Piano
1958 /////////////////////////////////////////////////////////////*/
1959 void DrawPiano(void)
1960 {
1961 int x,y,block2;
1962 BYTE data;
1963
1964 block2=0;
1965
1966 for(y=0;y<64;y++)
1967 {
1968 for(x=0;x<256;x++)
1969 {
1970 data=GFXpiano[block2];
1971 PlotPixel(x,64+y,data);
1972 block2++;
1973 }
1974 }
1975 }
1976 /*/////////////////////////////////////////////////////////////
1977 // Draw Level Title Plate
1978 /////////////////////////////////////////////////////////////*/
1979 void DrawTPlate2(void)
1980 {
1981 int x,y;
1982 BYTE data;
1983
1984 for(y=0;y<8;y++)
1985 {
1986 for(x=0;x<256;x++)
1987 {
1988 PlotPixel(x,128+y,GFXtplate[(y*256)+x]);
1989 }
1990 }
1991 FontPrint2(8,16,"\x7f1997 Andy Noble");
1992 }
1993 /*/////////////////////////////////////////////////////////////
1994 // Play The Piano
1995 /////////////////////////////////////////////////////////////*/
1996 void DoPiano(void)
1997 {
1998 int i,j;
1999 BYTE key1,key2,key3,key4;
2000
2001 for(i=0;i<32;i++)
2002 PIANOkhit[i]=0;
2003
2004 /* ADM */
2005 /* MIDASgetPlayStatus(modon,&stat);
2006
2007 if(stat.pattern==14)
2008 {
2009 TITLEm=2;
2010 MIDASstopModule(modon);
2011 modon=0;
2012 } */
2013
2014 #ifdef USE_MIKMOD
2015 if(mod->sngpos==17)
2016 {
2017 TITLEm=2;
2018 MIDASstopModule(modon);
2019 modon=0;
2020 }
2021 #endif
2022
2023
2024 UpdatePianoKeys();
2025 SwapPage();
2026
2027 if(KeyTable[key_f1]==1)
2028 {
2029 TITLEm=4;
2030 PREFSm=0;
2031 MIDASstopModule(modon);
2032 modon=0;
2033 }
2034
2035 if( KeyTable[key_return]==1 )
2036 {
2037
2038 TITLEm=0;
2039 DEMOm=0;
2040 MODE=2;
2041 MIDASstopModule(modon);
2042 modon=0;
2043 }
2044
2045 }
2046
2047 /*/////////////////////////////////////////////////////////////
2048 // Draw Piano Key
2049 /////////////////////////////////////////////////////////////*/
2050 void DrawKey(int xpos,int ypos,BYTE block)
2051 {
2052 int x,y,block2;
2053 BYTE data;
2054
2055 xpos*=8;
2056 ypos*=8;
2057
2058 block2=(WORD)block;
2059 block2*=128;
2060
2061 for(y=0;y<16;y++)
2062 {
2063 for(x=0;x<8;x++)
2064 {
2065 data=GFXpkeys[block2];
2066 PlotPixel(xpos+x,ypos+y,data);
2067 block2++;
2068 }
2069 }
2070
2071 }
2072 /*/////////////////////////////////////////////////////////////
2073 // Update Piano Keys
2074 ////////////////////////////////////////////////////////////*/
2075 void UpdatePianoKeys(void)
2076 {
2077 int i;
2078
2079 for(i=0;i<32;i++)
2080 {
2081 if(PIANOkhit[i]==1)
2082 {
2083 DrawKey(i,14,PIANOkey[i]+4);
2084 }
2085 else
2086 {
2087 DrawKey(i,14,PIANOkey[i]);
2088 }
2089 }
2090 }
2091 /*/////////////////////////////////////////////////////////////
2092 // Clear Piano
2093 /////////////////////////////////////////////////////////////*/
2094 void ClearPiano(void)
2095 {
2096 int i;
2097
2098 for(i=0;i<32;i++)
2099 PIANOkhit[i]=0;
2100
2101 UpdatePianoKeys();
2102 SwapPage();
2103 UpdatePianoKeys();
2104 SwapPage();
2105
2106 TITLEm=3;
2107 SCROLLpos=0;
2108 }
2109 /*/////////////////////////////////////////////////////////////
2110 // Draw Willy
2111 /////////////////////////////////////////////////////////////*/
2112 void DrawWilly4(BYTE block)
2113 {
2114 int x,y,block2;
2115 BYTE data;
2116
2117 block2=(WORD)block;
2118 block2*=256;
2119
2120 for(y=0;y<16;y++)
2121 {
2122 for(x=0;x<16;x++)
2123 {
2124 data=GFXwilly[block2];
2125
2126 if(data)
2127 {
2128 PlotPixel(232+x,72+y,data);
2129 }
2130 else
2131 {
2132 PlotPixel(232+x,72+y,39);
2133 }
2134 block2++;
2135 }
2136 }
2137 }
2138
2139 /*/////////////////////////////////////////////////////////////
2140 // Do Title Scroll
2141 /////////////////////////////////////////////////////////////*/
2142 void DoTitleScroll(void)
2143 {
2144 SwapPage();
2145
2146 TITLEwp++;
2147 if(TITLEwp==16)
2148 {
2149 TITLEwp=0;
2150 TITLEwf+=2;
2151 TITLEwf&=7;
2152 }
2153 DrawWilly4(TITLEwf+4);
2154
2155 DrawScroll();
2156
2157 PIXELoff++;
2158 if(PIXELoff==8)
2159 {
2160 PIXELoff=0;
2161 SCROLLpos++;
2162 if(SCROLLpos==290)
2163 {
2164 TITLEm=0;
2165 DEMOm=0;
2166 MODE=1;
2167
2168 if(MUSICtype==0)
2169 modon=MIDASplayModuleSection(mod,0x00,0x08,0x00,TRUE);
2170 else
2171 modon=MIDASplayModuleSection(mod,0x09,0x0c,0x00,TRUE);
2172
2173 if(MUSICon==1)
2174 MIDASsetMusicVolume(modon,64);
2175 else
2176 MIDASsetMusicVolume(modon,0);
2177
2178 }
2179 else
2180 {
2181 UpdateScrollBuffer();
2182 FillPixelBuff();
2183 }
2184 }
2185
2186 if(KeyTable[key_f1]==1)
2187 {
2188 TITLEm=4;
2189 PREFSm=0;
2190 }
2191
2192 if( KeyTable[key_return]==1 )
2193 {
2194
2195 TITLEm=0;
2196 DEMOm=0;
2197 MODE=2;
2198 }
2199 }
2200
2201 /*/////////////////////////////////////////////////////////////
2202 // Update Scroll Buffer
2203 /////////////////////////////////////////////////////////////*/
2204 void UpdateScrollBuffer(void)
2205 {
2206 int i;
2207
2208 for(i=0;i<33;i++)
2209 {
2210 SCROLLbuff[i]=SCROLLtext[SCROLLpos+i];
2211 }
2212 }
2213
2214 /*/////////////////////////////////////////////////////////////
2215 // Fill Pixel buffer with text
2216 /////////////////////////////////////////////////////////////*/
2217 void FillPixelBuff(void)
2218 {
2219 int i,x,y,dx,dy;
2220 WORD alpha;
2221 WORD point;
2222 BYTE *font,*alias,data,data2;
2223
2224 dx=0;dy=0;
2225
2226 for(i=0;i<33;i++)
2227 {
2228 alpha=(WORD)SCROLLbuff[i];
2229 alpha-=32;
2230 alpha*=64;
2231
2232 font=(fontb+alpha);
2233 alias=(GFXfant+alpha);
2234
2235 for(y=0;y<8;y++)
2236 {
2237 for(x=0;x<8;x++)
2238 {
2239 data=*font;
2240 if(data!=0)
2241 PIXELbuff[((dy+y)*264)+(dx+x)]=102;
2242 else
2243 PIXELbuff[((dy+y)*264)+(dx+x)]=PAPER;
2244
2245 data2=*alias;
2246 if(data2!=0)
2247 PIXELbuff[((dy+y)*264)+(dx+x)]=107;
2248
2249 font++;
2250 alias++;
2251
2252 }
2253 }
2254 dx+=8;
2255 }
2256 }
2257
2258 /*/////////////////////////////////////////////////////////////
2259 // Draw Scroll
2260 /////////////////////////////////////////////////////////////*/
2261 void DrawScroll(void)
2262 {
2263 int x,y;
2264
2265 for(y=0;y<8;y++)
2266 {
2267 for(x=0;x<256;x++)
2268 {
2269 PlotPixel(x,152+y,PIXELbuff[(y*264)+(PIXELoff+x)]);
2270 }
2271 }
2272 }
2273
2274 /*/////////////////////////////////////////////////////////////
2275 // Do Loading Screen
2276 /////////////////////////////////////////////////////////////*/
2277 void DoLoading(void)
2278 {
2279 switch(LOADm)
2280 {
2281 case 0:
2282 LoadSetup();
2283 break;
2284 case 1:
2285 LoadAnim();
2286 break;
2287 }
2288 }
2289
2290 /*/////////////////////////////////////////////////////////////
2291 // Setup Loading Screen
2292 /////////////////////////////////////////////////////////////*/
2293 void LoadSetup(void)
2294 {
2295 int i,x,y;
2296 BYTE data;
2297
2298 for(y=0;y<8;y++)
2299 {
2300 for(x=0;x<32;x++)
2301 {
2302 data=GFXload[(y*32)+x];
2303 PAPER=data;
2304 FontPrint(x,9+y," ");
2305 }
2306 }
2307 PAPER=0;
2308 INK=124;
2309
2310 FontPrint(28,23,VERSION);
2311
2312 SwapPage();
2313
2314 for(y=0;y<8;y++)
2315 {
2316 for(x=0;x<32;x++)
2317 {
2318 data=GFXload[256+((y*32)+x)];
2319 PAPER=data;
2320 FontPrint(x,9+y," ");
2321 }
2322 }
2323 PAPER=0;
2324 INK=124;
2325 FontPrint(28,23,VERSION);
2326
2327 LOADm=1;
2328 }
2329
2330 /*/////////////////////////////////////////////////////////////
2331 // Animate Loading Screen
2332 /////////////////////////////////////////////////////////////*/
2333 void LoadAnim(void)
2334 {
2335 LOADp++;
2336 if(LOADp==25)
2337 {
2338 LOADp=0;
2339 SwapPage();
2340 }
2341 else
2342 {
2343 WaitVR();
2344 }
2345
2346 if(AnyKeyx()==1)
2347 {
2348 MODE=0;
2349 }
2350 }
2351
2352 /*/////////////////////////////////////////////////////////////
2353 // Preferences Screen
2354 /////////////////////////////////////////////////////////////*/
2355 void DoPrefs(void)
2356 {
2357 switch(PREFSm)
2358 {
2359 case 0:
2360 SetupPrefs();
2361 break;
2362 case 1:
2363 PrefsUpdate();
2364 break;
2365 }
2366 }
2367
2368 /*/////////////////////////////////////////////////////////////
2369 // Setup Prefs
2370 /////////////////////////////////////////////////////////////*/
2371 void SetupPrefs(void)
2372 {
2373 int count;
2374
2375 for(count=0;count<768;count++)
2376 {
2377 PALover[count]=PALmain[count];
2378 }
2379
2380 DoPrefsExtra();
2381 SwapPage();
2382
2383 PaletteSet(PALover);
2384 DoPrefsExtra();
2385
2386 PREFSh1=0;
2387 PREFSh2=0;
2388 PREFSh3=0;
2389 PREFSm=1;
2390
2391 modon=MIDASplayModuleSection(mod,0x12,0x15,0x12,TRUE);
2392 }
2393
2394 /*/////////////////////////////////////////////////////////////
2395 // Prefs Screen Setup
2396 /////////////////////////////////////////////////////////////*/
2397 void DoPrefsExtra(void)
2398 {
2399 int x,y,i;
2400
2401 i=240;
2402
2403 cls(0);
2404
2405 for(x=0;x<32;x++)
2406 {
2407 PAPER=i;
2408 FontPrint(x,0," ");
2409 i++;
2410 if(i>254)
2411 i=240;
2412 }
2413
2414 for(y=1;y<24;y++)
2415 {
2416 PAPER=i;
2417 FontPrint(31,y," ");
2418 i++;
2419 if(i>254)
2420 i=240;
2421 }
2422
2423 for(x=1;x<32;x++)
2424 {
2425 PAPER=i;
2426 FontPrint(31-x,23," ");
2427 i++;
2428 if(i>254)
2429 i=240;
2430 }
2431
2432 for(y=1;y<23;y++)
2433 {
2434 PAPER=i;
2435 FontPrint(0,23-y," ");
2436 i++;
2437 if(i>254)
2438 i=240;
2439 }
2440
2441
2442 PAPER=0;
2443 INK=7;
2444
2445 FontPrintSmall(24,2, "`fManic Miner PC");
2446
2447 FontPrintSmall(23,3, "`g(C)`e1997 `gAndy Noble");
2448 FontPrintSmall(10,4, "`gBased on an original game by `eMatthew Smith`g.");
2449 FontPrintSmall(7,5, "`g(C) `e1983 `fBUG-BYTE`g Ltd. And `fSoftware Projects`g Ltd.");
2450 FontPrintSmall(18,6, "`g(C) `e1997 `fAlchemist Research`g.");
2451
2452 FontPrintSmall(7,8, "`dProgramming`g, `dGraphics`e...............`fAndy Noble`e.");
2453 FontPrintSmall(7,9, "`dMUSIC ARRANGED BY`e.................`fMatt Simmonds`e.");
2454 FontPrintSmall(7,10,"`dExtra Levels`e.................`fLee `d'`gBLOOD!`d' `fTonks`e.");
2455 FontPrintSmall(7,11,"`dTesting and Ideas`e.................`fEwan Christie`e.");
2456
2457 FontPrintSmall(3,13, "`dI would just like to say ThankYou to the following people");
2458
2459 FontPrintSmall(3,15, "`fSahara Surfers`d..............`eFor MIDAS Digital Audio System");
2460 FontPrintSmall(3,16, "`fCharles Scheffold and Thomas Pytel`d.....`eFor the fab PMODE/W");
2461 FontPrintSmall(3,17, "`fTyrone L. Cartwright`d............`eFor help with the bad guys");
2462
2463 FontPrintSmall(3,19, "`fDavid H. Tolley`d.................`eFor the constant slaggings");
2464 FontPrintSmall(3,20, "`fGerton Lunter`d........................`eFor the excellent Z80");
2465 FontPrintSmall(3,21, "`fJames McKay`d.................`eFor the equally excellent X128");
2466
2467 FontPrintSmall(5,22, "`cEverybody who e-mailed me with words of encouragement.");
2468
2469 FontPrintSmall(13,24,"`fAnd all the Guys on COMP.SYS.SINCLAIR");
2470 FontPrintSmall(4,25, "`eWho keep me informed and amused about all things Speccy.");
2471
2472 FontPrintSmall(15,27,"`f F2 F3 F4");
2473 FontPrintSmall(15,28,"`bGame Speed Levels Melody");
2474 FontPrintSmall(15,29,"`c ORIGINAL ORIGINAL ORIGINAL");
2475
2476 PrintSpeed();
2477 PrintMaps();
2478 PrintMusic();
2479
2480 }
2481
2482 /*/////////////////////////////////////////////////////////////
2483 // Update setup screen
2484 /////////////////////////////////////////////////////////////*/
2485 void PrefsUpdate(void)
2486 {
2487 RotPal();
2488 SwapPage();
2489 PaletteSet(PALover);
2490
2491 if(PREFSh1==1)
2492 {
2493 if(KeyTable[key_f2]!=1)
2494 {
2495 SPEED++;
2496 if(SPEED==5)
2497 SPEED=0;
2498 }
2499 PREFSh1=0;
2500 }
2501
2502 if(KeyTable[key_f2]==1)
2503 {
2504 PREFSh1=1;
2505 }
2506
2507 if(PREFSh2==1)
2508 {
2509 if(KeyTable[key_f3]!=1)
2510 {
2511 TONKS++;
2512 TONKS&=1;
2513 }
2514 PREFSh2=0;
2515 }
2516
2517 if(KeyTable[key_f3]==1)
2518 {
2519 PREFSh2=1;
2520 }
2521
2522 if(PREFSh3==1)
2523 {
2524 if(KeyTable[key_f4]!=1)
2525 {
2526 MUSICtype++;
2527 MUSICtype&=1;
2528 }
2529 PREFSh3=0;
2530 }
2531
2532 if(KeyTable[key_f4]==1)
2533 {
2534 PREFSh3=1;
2535 }
2536
2537 if(KeyTable[key_esc]==1)
2538 {
2539 MODE=0;
2540 TITLEm=0;
2541 MIDASstopModule(modon);
2542 modon=0;
2543 }
2544
2545 PrintSpeed();
2546 PrintMaps();
2547 PrintMusic();
2548
2549 }
2550
2551 /*/////////////////////////////////////////////////////////////
2552 // Display Game Speed
2553 /////////////////////////////////////////////////////////////*/
2554 void PrintSpeed(void)
2555 {
2556 switch(SPEED)
2557 {
2558 case 0:
2559 INK=1;
2560 FontPrintSmall(16,29," SILLY! ");
2561 break;
2562 case 1:
2563 INK=3;
2564 FontPrintSmall(16,29," HARD ");
2565 break;
2566 case 2:
2567 INK=4;
2568 FontPrintSmall(16,29," 1997 ");
2569 break;
2570 case 3:
2571 INK=7;
2572 FontPrintSmall(16,29,"ORIGINAL");
2573 break;
2574 case 4:
2575 INK=5;
2576 FontPrintSmall(16,29," BORING ");
2577 break;
2578 }
2579 }
2580
2581 /*/////////////////////////////////////////////////////////////
2582 // Display Game Maps
2583 /////////////////////////////////////////////////////////////*/
2584 void PrintMaps(void)
2585 {
2586 switch(TONKS)
2587 {
2588 case 0:
2589 INK=7;
2590 FontPrintSmall(28,29,"ORIGINAL");
2591 break;
2592 case 1:
2593 INK=4;
2594 FontPrintSmall(28,29," BLOOD! ");
2595 break;
2596 }
2597 }
2598
2599 /*/////////////////////////////////////////////////////////////
2600 // Display Game Music
2601 /////////////////////////////////////////////////////////////*/
2602 void PrintMusic(void)
2603 {
2604 switch(MUSICtype)
2605 {
2606 case 0:
2607 INK=4;
2608 FontPrintSmall(40,29," 1997 ");
2609 break;
2610 case 1:
2611 INK=7;
2612 FontPrintSmall(40,29,"ORIGINAL");
2613 break;
2614 }
2615 }
2616
2617 /*/////////////////////////////////////////////////////////////
2618 // Save Stuff on Exit
2619 /////////////////////////////////////////////////////////////*/
2620 void SaveInfo(void)
2621 {
2622 FILE *file;
2623
2624 file=fopen( "mm-conf.cfg", "wb" );
2625 fwrite( &HISCORE, sizeof(unsigned long), 1, file );
2626 fwrite( &SPEED, sizeof(BYTE), 1, file );
2627 fwrite( &TONKS, sizeof(BYTE), 1, file );
2628 fwrite( &MUSICtype, sizeof(BYTE), 1, file );
2629 fclose( file );
2630 }
2631
2632 /*/////////////////////////////////////////////////////////////
2633 // Load Stuff at Start
2634 /////////////////////////////////////////////////////////////*/
2635 void LoadInfo(void)
2636 {
2637 FILE *file;
2638
2639 file=fopen( "mm-conf.cfg", "rb" );
2640 if(file==NULL)
2641 {
2642 HISCORE=0;
2643 SPEED=3;
2644 TONKS=0;
2645 MUSICtype=0;
2646 return;
2647 }
2648 fread( &HISCORE, sizeof(unsigned long), 1, file );
2649 fread( &SPEED, sizeof(BYTE), 1, file );
2650 fread( &TONKS, sizeof(BYTE), 1, file );
2651 fread( &MUSICtype, sizeof(BYTE), 1, file );
2652 fclose( file );
2653 }
2654
2655 /*/////////////////////////////////////////////////////////////
2656 // Pre Vertical Retrace
2657 /////////////////////////////////////////////////////////////*/
2658 void PREvr(void)
2659 {
2660 FrCt++;
2661 }
2662
2663 /*/////////////////////////////////////////////////////////////
2664 // Setup Sound Card
2665 /////////////////////////////////////////////////////////////*/
2666 void SetupSound(void)
2667 {
2668 FILE *file;
2669
2670 file=fopen( "mm-midas.cfg", "rb" );
2671 if((file==NULL)||(FORCE==1))
2672 {
2673 if(file!=NULL)
2674 fclose(file);
2675
2676 MIDASconfig();
2677 MIDASsaveConfig("mm-midas.cfg");
2678 }
2679 else
2680 {
2681 fclose(file);
2682 MIDASloadConfig("mm-midas.cfg");
2683 }
2684 }
Manic Miner PC Linux version