?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add missing prototypes
[manicminer.git] / mm-core.c
blob70ce871c31d91d3d0bcc6a6aaeb5429122cca093
1 SPGCheckRobo(WORD x, WORD y);
2 GetBlock(WORD x, WORD y);
3
4 ///////////////////////////////////////////////////////////////
5 // Copy Level to Current Level
6 ///////////////////////////////////////////////////////////////
7 void CopyLevelInfo(void)
8 {
9 int count1,count2;
10
11 for(count1=0;count1<512;count1++)
12 {
13 cMAP[count1]=map[LEVEL][count1];
14
15 if(map[LEVEL][count1]==4)
16 cCRUMB[count1]=8;
17 else
18 cCRUMB[count1]=0;
19
20 }
21
22 for(count1=0;count1<32;count1++)
23 cTITLE[count1]=title[LEVEL][count1];
24
25 cBGink=BGink[LEVEL];
26 cBGpaper=BGpaper[LEVEL];
27
28 cPLAT1ink=PLAT1ink[LEVEL];
29 cPLAT1paper=PLAT1paper[LEVEL];
30
31 cPLAT2ink=PLAT2ink[LEVEL];
32 cPLAT2paper=PLAT2paper[LEVEL];
33
34 cWALLink=WALLink[LEVEL];
35 cWALLpaper=WALLpaper[LEVEL];
36
37 cCRUMBink=CRUMBink[LEVEL];
38 cCRUMBpaper=CRUMBpaper[LEVEL];
39
40 cKILL1ink=KILL1ink[LEVEL];
41 cKILL1paper=KILL1paper[LEVEL];
42
43 cKILL2ink=KILL2ink[LEVEL];
44 cKILL2paper=KILL2paper[LEVEL];
45
46 cCONVink=CONVink[LEVEL];
47 cCONVpaper=CONVpaper[LEVEL];
48 cCONVx=CONVx[LEVEL];
49 cCONVy=CONVy[LEVEL];
50 cCONVd=CONVd[LEVEL];
51 cCONVl=CONVl[LEVEL];
52 cCONVf=0;
53 cCONVm=0;
54
55 cBORDER=BORDER[LEVEL];
56
57 cPLAT1gfx=PLAT1gfx[LEVEL];
58 cPLAT2gfx=PLAT2gfx[LEVEL];
59 cWALLgfx=WALLgfx[LEVEL];
60 cCRUMBgfx=CRUMBgfx[LEVEL];
61 cKILL1gfx=KILL1gfx[LEVEL];
62 cKILL2gfx=KILL2gfx[LEVEL];
63 cCONVgfx=CONVgfx[LEVEL];
64 cEXITgfx=EXITgfx[LEVEL];
65 cKEYgfx=KEYgfx[LEVEL];
66
67 cWILLYx=WILLYsx[LEVEL];
68 cWILLYy=WILLYsy[LEVEL];
69 cWILLYd=WILLYsd[LEVEL];
70 cWILLYm=0;
71 cWILLYf=0;
72 cWILLYfall=0;
73 cWILLYj=0;
74 cWILLYxold[0]=65535;
75 cWILLYyold[0]=65535;
76 cWILLYxold[1]=65535;
77 cWILLYyold[1]=65535;
78 cWILLYjs=0;
79
80 for(count1=0;count1<5;count1++)
81 {
82 cKEYx[count1]=KEYx[LEVEL][count1];
83 cKEYy[count1]=KEYy[LEVEL][count1];
84 cKEYb[count1]=(count1*2);
85 cKEYs[count1]=KEYs[LEVEL][count1];
86 }
87
88 for(count1=0;count1<2;count1++)
89 {
90 cSWITCHx[count1]=SWITCHx[LEVEL][count1];
91 cSWITCHy[count1]=SWITCHy[LEVEL][count1];
92 cSWITCHs[count1]=SWITCHs[LEVEL][count1];
93 }
94
95 cEXITx=EXITx[LEVEL];
96 cEXITy=EXITy[LEVEL];
97 cEXITb=0;
98 cEXITm=0;
99
100 cAIR=AIR[LEVEL]+31;
101 cAIRp=8;
102
103 for(count1=0;count1<4;count1++)
104 {
105 cHROBOink[count1]=HROBOink[LEVEL][count1];
106 cHROBOpaper[count1]=HROBOpaper[LEVEL][count1];
107 cHROBOx[count1]=HROBOx[LEVEL][count1];
108 cHROBOy[count1]=HROBOy[LEVEL][count1];
109 cHROBOmin[count1]=HROBOmin[LEVEL][count1];
110 cHROBOmax[count1]=HROBOmax[LEVEL][count1];
111 cHROBOd[count1]=HROBOd[LEVEL][count1];
112 cHROBOs[count1]=HROBOs[LEVEL][count1];
113 cHROBOgfx[count1]=HROBOgfx[LEVEL][count1];
114 cHROBOflip[count1]=HROBOflip[LEVEL][count1];
115 cHROBOanim[count1]=HROBOanim[LEVEL][count1];
116 cHROBOxold[count1][0]=65535;
117 cHROBOxold[count1][1]=65535;
118 cHROBOyold[count1][0]=65535;
119 cHROBOyold[count1][1]=65535;
120 }
121
122 for(count1=0;count1<4;count1++)
123 {
124 cVROBOink[count1]=VROBOink[LEVEL][count1];
125 cVROBOpaper[count1]=VROBOpaper[LEVEL][count1];
126 cVROBOx[count1]=VROBOx[LEVEL][count1];
127 cVROBOy[count1]=VROBOy[LEVEL][count1];
128 cVROBOmin[count1]=VROBOmin[LEVEL][count1];
129 cVROBOmax[count1]=VROBOmax[LEVEL][count1];
130 cVROBOd[count1]=VROBOd[LEVEL][count1];
131 cVROBOs[count1]=VROBOs[LEVEL][count1];
132 cVROBOgfx[count1]=VROBOgfx[LEVEL][count1];
133 //cVROBOanim[count1]=VROBOanim[LEVEL][count1];
134 cVROBOanim[count1]=count1;
135 cVROBOyold[count1][0]=65535;
136 cVROBOyold[count1][1]=65535;
137 cVROBOxold[count1][0]=65535;
138 cVROBOxold[count1][1]=65535;
139 }
140
141 EUGENEx=120;
142 EUGENEy=1;
143 EUGENEd=0;
144 EUGENEm=0;
145 EUGENEc=7;
146 EUGENEmin=1;
147 EUGENEmax=87;
148 EUGENExold[0]=65535;
149 EUGENEyold[0]=65535;
150 EUGENExold[1]=65535;
151 EUGENEyold[1]=65535;
152
153 SWITCH1m=0;
154 SWITCH2m=0;
155
156 HOLEl=2;
157 HOLEy=95;
158
159 KONGx=120;
160 KONGy=0;
161 KONGmax=104;
162 KONGm=0;
163 KONGc=3;
164 KONGf=0;
165 KONGp=KONGPAUSE;
166 KONGxold[0]=65535;
167 KONGyold[0]=65535;
168 KONGxold[1]=65535;
169 KONGyold[1]=65535;
170
171 SKYp[0]=0;
172 SKYp[1]=2;
173 SKYp[2]=1;
174
175 SKYs[0]=4;
176 SKYs[1]=3;
177 SKYs[2]=1;
178
179 SKYc[0]=6;
180 SKYc[1]=5;
181 SKYc[2]=4;
182
183 SKYmax[0]=72;
184 SKYmax[1]=56;
185 SKYmax[2]=32;
186
187 SKYxold[0][0]=65535;
188 SKYyold[0][0]=65535;
189
190
191 for(count1=0;count1<3;count1++)
192 {
193 SKYx[count1]=SKYpx[count1][SKYp[count1]];
194 SKYy[count1]=SKYpy[count1][SKYp[count1]];
195 SKYm[count1]=0;
196 SKYf[count1]=0;
197 SKYxold[count1][0]=65535;
198 SKYyold[count1][0]=65535;
199 SKYxold[count1][1]=65535;
200 SKYyold[count1][1]=65535;
201 }
202
203 for(count1=0;count1<64;count1++)
204 {
205 SPGx[0][count1]=65535;
206 SPGy[0][count1]=65535;
207 SPGx[1][count1]=65535;
208 SPGy[1][count1]=65535;
209 }
210
211 DEATHm=0;
212 DEATHc=0;
213
214 for(count1=0;count1<768;count1++)
215 {
216 PALfade[count1]=PALmain[count1];
217 }
218
219 SUNm=0;
220 SUNy=32;
221 SUNh=16;
222 SUNyold[0]=65535;
223 SUNyold[1]=65535;
224 SUNhold[0]=255;
225 SUNhold[1]=255;
226 }
227
228 ///////////////////////////////////////////////////////////////
229 // Draw Current Level
230 ///////////////////////////////////////////////////////////////
231 void DrawCurrentLevel(void)
232 {
233 int xpos,ypos;
234 BYTE block;
235
236 cls(cBORDER);
237
238 for(ypos=0;ypos<16;ypos++)
239 {
240 for(xpos=0;xpos<32;xpos++)
241 {
242 block=cMAP[(ypos*32)+xpos];
243
244 switch(block)
245 {
246 case 0:
247 DrawBGBlock(xpos,ypos);
248 break;
249 case 1:
250 DrawBlock(xpos,ypos,cPLAT1gfx,cPLAT1ink);
251 break;
252 case 2:
253 DrawBlock(xpos,ypos,cPLAT2gfx,cPLAT2ink);
254 break;
255 case 3:
256 DrawBlock(xpos,ypos,cWALLgfx,cWALLink);
257 break;
258 case 4:
259 DrawBlock(xpos,ypos,cCRUMBgfx,cCRUMBink);
260 break;
261 case 5:
262 DrawBlock(xpos,ypos,cKILL1gfx,cKILL1ink);
263 break;
264 case 6:
265 DrawBlock(xpos,ypos,cKILL2gfx,cKILL2ink);
266 break;
267 }
268 }
269 }
270 if((LEVEL==19)||(LEVEL==39))
271 {
272 DrawFinal();
273 SUNm=1;
274 SUNy=32;
275 SUNh=16;
276 DoSun();
277 }
278 }
279
280 ///////////////////////////////////////////////////////////////
281 // Draw a BackGround Block
282 ///////////////////////////////////////////////////////////////
283 void DrawBGBlock(int xpos,int ypos)
284 {
285 int x,y;
286
287 xpos*=8;
288 ypos*=8;
289
290 for(y=0;y<8;y++)
291 {
292 for(x=0;x<8;x++)
293 {
294 PlotPixel(xpos+x,ypos+y,cBGpaper);
295 }
296 }
297 }
298
299 ///////////////////////////////////////////////////////////////
300 // Draw a Block
301 ///////////////////////////////////////////////////////////////
302 void DrawBlock(int xpos,int ypos,BYTE block, BYTE ink)
303 {
304 int x,y,block2;
305 BYTE data;
306
307 xpos*=8;
308 ypos*=8;
309
310 block2=(WORD)block;
311 block2*=64;
312
313 for(y=0;y<8;y++)
314 {
315 for(x=0;x<8;x++)
316 {
317 data=GFXblocks[block2];
318
319 if(!data)
320 PlotPixel(xpos+x,ypos+y,cBGpaper);
321 else
322 PlotPixel(xpos+x,ypos+y,data+(ink*16));
323
324 block2++;
325 }
326 }
327 }
328
329 ///////////////////////////////////////////////////////////////
330 // Draw a Convayor Block
331 ///////////////////////////////////////////////////////////////
332 void DrawConvBlock(int xpos,int ypos,BYTE block,BYTE frame)
333 {
334 int x,y,block2,frame2;
335 BYTE data;
336
337 block2=(WORD)block;
338 block2*=256;
339
340 frame2=(WORD)frame;
341 frame2*=64;
342
343 block2+=frame2;
344
345 for(y=0;y<8;y++)
346 {
347 for(x=0;x<8;x++)
348 {
349 data=GFXconv[block2];
350
351 if(!data)
352 PlotPixel(xpos+x,ypos+y,cBGpaper);
353 else
354 PlotPixel(xpos+x,ypos+y,data+(cCONVink*16));
355
356 block2++;
357 }
358 }
359 }
360 ///////////////////////////////////////////////////////////////
361 // Draw Convayor
362 ///////////////////////////////////////////////////////////////
363 void DrawConv(void)
364 {
365 int count;
366
367
368 if(cCONVy!=0)
369 {
370
371 for(count=0;count<cCONVl;count++)
372 {
373 DrawConvBlock(cCONVx+(count*8),cCONVy,cCONVgfx,cCONVf);
374 }
375
376
377 switch(cCONVd)
378 {
379 case 0:
380 cCONVf++;
381 cCONVf&=3;
382 break;
383
384 case 1:
385 cCONVf--;
386 cCONVf&=3;
387 break;
388 }
389 }
390 }
391 ///////////////////////////////////////////////////////////////
392 // Draw Exit
393 ///////////////////////////////////////////////////////////////
394 void DrawExit(void)
395 {
396 int x,y,block2;
397 BYTE data,temp;
398 WORD xpos,ypos;
399
400 xpos=cEXITx;
401 ypos=cEXITy;
402
403 block2=(WORD)cEXITgfx;
404 block2*=256;
405
406 switch(cEXITm)
407 {
408 case 0:
409 for(y=0;y<16;y++)
410 {
411 for(x=0;x<16;x++)
412 {
413 data=GFXexit[block2];
414
415 if(data)
416 PlotPixel(xpos+x,ypos+y,data);
417
418 block2++;
419 }
420 }
421
422 break;
423
424 case 1:
425
426 for(y=0;y<16;y++)
427 {
428 for(x=0;x<16;x++)
429 {
430 data=GFXexit[block2];
431
432 if(data)
433 {
434 temp=data&15;
435 temp-=bright[cEXITb];
436
437 if(temp>15)
438 temp=0;
439
440 data&=240;
441 data|=temp;
442
443 PlotPixel(xpos+x,ypos+y,data);
444 }
445 block2++;
446 }
447 }
448
449 cEXITb++;
450 cEXITb&=15;
451 break;
452 }
453
454 }
455 ///////////////////////////////////////////////////////////////
456 // Draw a Key
457 ///////////////////////////////////////////////////////////////
458 void DrawKeyBlock(int xpos,int ypos,BYTE block,BYTE shine)
459 {
460 int x,y,block2;
461 BYTE data,temp;
462
463 block2=(WORD)block;
464 block2*=64;
465
466 for(y=0;y<8;y++)
467 {
468 for(x=0;x<8;x++)
469 {
470 data=GFXkey[block2];
471
472 if(!data)
473 PlotPixel(xpos+x,ypos+y,cBGpaper);
474 else
475 {
476 temp=data&15;
477 temp-=shine;
478
479 if(temp>15)
480 temp=0;
481
482 data&=240;
483 data|=temp;
484
485 PlotPixel(xpos+x,ypos+y,data);
486 }
487 block2++;
488 }
489 }
490 }
491 ///////////////////////////////////////////////////////////////
492 // Draw Keys
493 ///////////////////////////////////////////////////////////////
494 void DrawKeys(void)
495 {
496 int i,count;
497
498 count=0;
499
500 for(i=0;i<5;i++)
501 {
502 if(cKEYs[i]==1)
503 {
504 if((cKEYx[i]!=65535)&&(cKEYy[i]!=65535))
505 {
506 DrawKeyBlock(cKEYx[i],cKEYy[i],cKEYgfx,bright2[cKEYb[i]]);
507 count++;
508 }
509
510 cKEYb[i]++;
511 cKEYb[i]&=15;
512 }
513 else
514 {
515 if((cKEYx[i]!=65535)&&(cKEYy[i]!=65535))
516 {
517 DrawBGBlock(cKEYx[i]/8,cKEYy[i]/8);
518 }
519 }
520 }
521
522 if(!count)
523 cEXITm=1;
524 }
525
526 ///////////////////////////////////////////////////////////////
527 // Draw Level Title Plate
528 ///////////////////////////////////////////////////////////////
529 void DrawTPlate(void)
530 {
531 int x,y;
532 BYTE data;
533
534 for(y=0;y<8;y++)
535 {
536 for(x=0;x<256;x++)
537 {
538 PlotPixel(x,128+y,GFXtplate[(y*256)+x]);
539 }
540 }
541
542 FontPrint2(0,16,cTITLE);
543 }
544 ///////////////////////////////////////////////////////////////
545 // Draw Air Background
546 ///////////////////////////////////////////////////////////////
547 void DrawAirBG(void)
548 {
549 int x,y;
550 BYTE data;
551
552 for(y=0;y<8;y++)
553 {
554 for(x=0;x<256;x++)
555 {
556 PlotPixel(x,136+y,GFXair[(y*256)+x]);
557 }
558 }
559
560 FontPrint2(0,17,"AIR");
561 }
562 ///////////////////////////////////////////////////////////////
563 // Draw Air
564 ///////////////////////////////////////////////////////////////
565 void DrawAir(void)
566 {
567 int x,y;
568
569 cAIRp--;
570 if(cAIRp==0)
571 {
572 cAIRp=8;
573
574 cAIR--;
575
576 if(cAIR<=33)
577 {
578 cAIR=33;
579 cWILLYm=6;
580 }
581 }
582
583
584 for(x=30;x<256;x++)
585 {
586 PlotPixel(x,138,GFXair[512+x]);
587 PlotPixel(x,139,GFXair[768+x]);
588 PlotPixel(x,140,GFXair[1024+x]);
589 PlotPixel(x,141,GFXair[1280+x]);
590 }
591
592 PlotPixel(32,138,122);
593 PlotPixel(32,139,116);
594 PlotPixel(32,140,119);
595 PlotPixel(32,141,123);
596
597 for(x=33;x<(cAIR-1);x++)
598 {
599 PlotPixel(x,138,120);
600 PlotPixel(x,139,114);
601 PlotPixel(x,140,117);
602 PlotPixel(x,141,121);
603 }
604
605 PlotPixel(cAIR-1,138,122);
606 PlotPixel(cAIR-1,139,116);
607 PlotPixel(cAIR-1,140,119);
608 PlotPixel(cAIR-1,141,123);
609
610 }
611
612 ///////////////////////////////////////////////////////////////
613 // Draw a HORIZONTAL Robot
614 ///////////////////////////////////////////////////////////////
615 void DrawHRobo(WORD xpos, WORD ypos, WORD sprite, BYTE col)
616 {
617 int x,y,block2,frame2;
618 BYTE data;
619
620 sprite*=256;
621 col--;
622
623 for(y=0;y<16;y++)
624 {
625 for(x=0;x<16;x++)
626 {
627 data=GFXhrobo[sprite];
628
629 if(data)
630 PlotPixel(xpos+x,ypos+y,data+(col*16));
631
632 sprite++;
633 }
634 }
635 }
636 ///////////////////////////////////////////////////////////////
637 // Do Horizontal Robots
638 ///////////////////////////////////////////////////////////////
639 void DoHRobo(void)
640 {
641 int i;
642
643
644 for(i=0;i<4;i++)
645 {
646 if(cHROBOx[i]!=65535)
647 {
648 if( cHROBOd[i] )
649 {
650
651 cHROBOx[i]-=(2>>cHROBOs[i]);
652
653 if(cHROBOx[i]<cHROBOmin[i])
654 {
655 cHROBOd[i]=0;
656 cHROBOx[i]+=(2>>cHROBOs[i]);
657 DrawHRobo((cHROBOx[i]&248),cHROBOy[i],cHROBOgfx[i]+((cHROBOx[i]&cHROBOanim[i])>>1),cHROBOink[i]);
658 }
659 else
660 DrawHRobo((cHROBOx[i]&248),cHROBOy[i],(cHROBOgfx[i]+((cHROBOx[i]&cHROBOanim[i])>>1))+cHROBOflip[i],cHROBOink[i]);
661 }
662 else
663 {
664 cHROBOx[i]+=(2>>cHROBOs[i]);
665
666 if(cHROBOx[i]>(cHROBOmax[i]+6))
667 {
668 cHROBOd[i]=1;
669 cHROBOx[i]-=(2>>cHROBOs[i]);
670 DrawHRobo((cHROBOx[i]&248),cHROBOy[i],(cHROBOgfx[i]+((cHROBOx[i]&cHROBOanim[i])>>1))+cHROBOflip[i],cHROBOink[i]);
671 }
672 else
673 DrawHRobo((cHROBOx[i]&248),cHROBOy[i],cHROBOgfx[i]+((cHROBOx[i]&cHROBOanim[i])>>1),cHROBOink[i]);
674 }
675
676 cHROBOxold[i][old]=cHROBOx[i]&248;
677 cHROBOyold[i][old]=cHROBOy[i];
678 }
679 }
680 }
681 ///////////////////////////////////////////////////////////////
682 // Remove Horizontal Robots
683 ///////////////////////////////////////////////////////////////
684 void RemoveHRobo(void)
685 {
686 int i,x,y;
687
688 for(i=0;i<4;i++)
689 {
690 if(cHROBOxold[i][old]!=65535)
691 {
692 for(y=0;y<16;y++)
693 {
694 for(x=0;x<16;x++)
695 {
696 PlotPixel(cHROBOxold[i][old]+x,cHROBOyold[i][old]+y,cBGpaper);
697 }
698 }
699 }
700 }
701 }
702
703 ///////////////////////////////////////////////////////////////
704 // Draw a VERTICAL Robot
705 ///////////////////////////////////////////////////////////////
706 void DrawVRobo(WORD xpos, WORD ypos, WORD sprite, BYTE col)
707 {
708 int x,y,block2,frame2;
709 BYTE data;
710
711 sprite*=256;
712 col--;
713
714 for(y=0;y<16;y++)
715 {
716 for(x=0;x<16;x++)
717 {
718 data=GFXvrobo[sprite];
719
720 if(data)
721 PlotPixel(xpos+x,ypos+y,data+(col*16));
722
723 sprite++;
724 }
725 }
726 }
727 ///////////////////////////////////////////////////////////////
728 // Do Vertical Robots
729 ///////////////////////////////////////////////////////////////
730 void DoVRobo(void)
731 {
732 int i;
733
734
735 for(i=0;i<4;i++)
736 {
737 if(cVROBOx[i]!=65535)
738 {
739 if( cVROBOd[i] )
740 {
741
742 cVROBOy[i]-=(cVROBOs[i]);
743
744 if((cVROBOy[i]<cVROBOmin[i])||(cVROBOy[i]>256))
745 {
746 cVROBOd[i]=0;
747 cVROBOy[i]+=(cVROBOs[i]);
748 DrawVRobo(cVROBOx[i],cVROBOy[i],(cVROBOgfx[i]+cVROBOanim[i]),cVROBOink[i]);
749 }
750 else
751 DrawVRobo(cVROBOx[i],cVROBOy[i],(cVROBOgfx[i]+cVROBOanim[i]),cVROBOink[i]);
752 }
753 else
754 {
755 cVROBOy[i]+=(cVROBOs[i]);
756
757 if(cVROBOy[i]>cVROBOmax[i])
758 {
759 cVROBOd[i]=1;
760 cVROBOy[i]-=(cVROBOs[i]);
761 DrawVRobo(cVROBOx[i],cVROBOy[i],(cVROBOgfx[i]+cVROBOanim[i]),cVROBOink[i]);
762 }
763 else
764 DrawVRobo(cVROBOx[i],cVROBOy[i],(cVROBOgfx[i]+cVROBOanim[i]),cVROBOink[i]);
765 }
766 cVROBOanim[i]++;
767 cVROBOanim[i]&=3;
768
769 cVROBOxold[i][old]=cVROBOx[i];
770 cVROBOyold[i][old]=cVROBOy[i];
771 }
772 }
773 }
774 ///////////////////////////////////////////////////////////////
775 // Remove Vertical Robots
776 ///////////////////////////////////////////////////////////////
777 void RemoveVRobo(void)
778 {
779 int i,x,y;
780
781 for(i=0;i<4;i++)
782 {
783 if(cVROBOxold[i][old]!=65535)
784 {
785 for(y=0;y<16;y++)
786 {
787 for(x=0;x<16;x++)
788 {
789 PlotPixel(cVROBOxold[i][old]+x,cVROBOyold[i][old]+y,cBGpaper);
790 }
791 }
792 }
793 }
794 }
795 ///////////////////////////////////////////////////////////////
796 // Draw Final Screen Background
797 ///////////////////////////////////////////////////////////////
798 void DrawFinal(void)
799 {
800 int x,y;
801 BYTE data;
802
803 for(y=0;y<64;y++)
804 {
805 for(x=0;x<256;x++)
806 {
807 data=GFXfinal[(y*256)+x];
808
809 if(!data)
810 PlotPixel(x,y,cBGpaper);
811 else
812 PlotPixel(x,y,data);
813
814 }
815 }
816 }
817 ///////////////////////////////////////////////////////////////
818 // Draw a Switch
819 ///////////////////////////////////////////////////////////////
820 void DrawSwitchBlock(int xpos,int ypos,BYTE block)
821 {
822 int x,y,block2;
823 BYTE data,temp;
824
825 block2=(WORD)block;
826 block2*=64;
827
828 for(y=0;y<8;y++)
829 {
830 for(x=0;x<8;x++)
831 {
832 data=GFXswitch[block2];
833
834 if(!data)
835 PlotPixel(xpos+x,ypos+y,cBGpaper);
836 else
837 {
838 PlotPixel(xpos+x,ypos+y,data+((cPLAT2ink-1)*16));
839 }
840 block2++;
841 }
842 }
843 }
844 ///////////////////////////////////////////////////////////////
845 // Draw Switches
846 ///////////////////////////////////////////////////////////////
847 void DrawSwitches(void)
848 {
849 int i;
850
851 for(i=0;i<2;i++)
852 {
853 if(cSWITCHs[i]!=0)
854 DrawSwitchBlock(cSWITCHx[i],cSWITCHy[i],cSWITCHs[i]-1);
855 }
856 }
857 ///////////////////////////////////////////////////////////////
858 // Do Special Robo
859 ///////////////////////////////////////////////////////////////
860 void DoSpecialRobo(void)
861 {
862
863 switch(LEVEL)
864 {
865 case 4:
866 DoEugene();
867 break;
868 case 7:
869 DoLevelSeven();
870 break;
871 case 11:
872 DoLevelSeven();
873 break;
874 case 13:
875 DoLevelThirteen();
876 break;
877 case 18:
878 DoSPG();
879 CheckSPG();
880 break;
881
882 case 24:
883 DoEugene();
884 break;
885 case 27:
886 DoLevelSeven();
887 break;
888 case 31:
889 DoLevelSeven();
890 break;
891 case 33:
892 DoLevelThirteen();
893 break;
894 case 38:
895 DoSPG();
896 CheckSPG();
897 break;
898 }
899 }
900 ///////////////////////////////////////////////////////////////
901 // Draw Eugene
902 ///////////////////////////////////////////////////////////////
903 void DrawEugene(WORD xpos, WORD ypos, BYTE col)
904 {
905 int x,y;
906 BYTE data;
907
908 col--;
909
910 for(y=0;y<16;y++)
911 {
912 for(x=0;x<16;x++)
913 {
914 if(TONKS==0)
915 data=GFXeugene[((y*16)+x)];
916 else
917 data=GFXeugene[256+((y*16)+x)];
918
919 if(data)
920 PlotPixel(xpos+x,ypos+y,data+(col*16));
921
922 }
923 }
924 }
925 ///////////////////////////////////////////////////////////////
926 // Remove Eugene
927 ///////////////////////////////////////////////////////////////
928 void RemoveEugene(void)
929 {
930 int i,x,y;
931
932 if(EUGENExold[old]!=65535)
933 {
934 for(y=0;y<16;y++)
935 {
936 for(x=0;x<16;x++)
937 {
938 PlotPixel(EUGENExold[old]+x,EUGENEyold[old]+y,cBGpaper);
939 }
940 }
941 }
942 }
943
944 ///////////////////////////////////////////////////////////////
945 // Do Eugene
946 ///////////////////////////////////////////////////////////////
947 void DoEugene(void)
948 {
949
950 if(cEXITm==1)
951 EUGENEm=1;
952
953 switch(EUGENEm)
954 {
955 case 0:
956 if( EUGENEd )
957 {
958
959 EUGENEy--;
960
961 if(EUGENEy<EUGENEmin)
962 {
963 EUGENEd=0;
964 EUGENEy++;
965 DrawEUGENE(EUGENEx,EUGENEy,EUGENEc);
966 }
967 else
968 DrawEUGENE(EUGENEx,EUGENEy,EUGENEc);
969 }
970 else
971 {
972 EUGENEy++;
973
974 if(EUGENEy>EUGENEmax)
975 {
976 EUGENEd=1;
977 EUGENEy--;
978 DrawEUGENE(EUGENEx,EUGENEy,EUGENEc);
979 }
980 else
981 DrawEUGENE(EUGENEx,EUGENEy,EUGENEc);
982 }
983
984 EUGENExold[old]=EUGENEx;
985 EUGENEyold[old]=EUGENEy;
986
987 break;
988
989 case 1:
990 EUGENEc++;
991 if(EUGENEc==8)
992 EUGENEc=1;
993
994 EUGENEy++;
995
996 if(EUGENEy>EUGENEmax)
997 {
998 EUGENEy--;
999 DrawEUGENE(EUGENEx,EUGENEy,EUGENEc);
1000 }
1001 else
1002 DrawEUGENE(EUGENEx,EUGENEy,EUGENEc);
1003
1004 EUGENExold[old]=EUGENEx;
1005 EUGENEyold[old]=EUGENEy;
1006 }
1007 }
1008
1009 ///////////////////////////////////////////////////////////////
1010 // Do Hole
1011 ///////////////////////////////////////////////////////////////
1012 void DoHole(void)
1013 {
1014 int x,y;
1015
1016 switch(SWITCH1m)
1017 {
1018 case 0:
1019 for(y=0;y<HOLEl;y++)
1020 {
1021 for(x=0;x<8;x++)
1022 {
1023 PlotPixel(136+x,HOLEy+y,cBGpaper);
1024 }
1025 }
1026 HOLEy--;
1027 HOLEl+=2;
1028
1029 if(HOLEy==87)
1030 {
1031 SWITCH1m=1;
1032 cMAP[((88/8)*32)+(136/8)]=0;
1033 cMAP[((96/8)*32)+(136/8)]=0;
1034 }
1035 break;
1036
1037 case 1:
1038 for(y=0;y<16;y++)
1039 {
1040 for(x=0;x<8;x++)
1041 {
1042 PlotPixel(136+x,88+y,cBGpaper);
1043 }
1044 }
1045 SWITCH1m=2;
1046 cHROBOmax[1]+=24;
1047 break;
1048 }
1049 }
1050
1051 ///////////////////////////////////////////////////////////////
1052 // Level 7 "Miner Willy meets the Kong Beast"
1053 ///////////////////////////////////////////////////////////////
1054 void DoLevelSeven(void)
1055 {
1056
1057 KONGp--;
1058 if(KONGp==0)
1059 {
1060 KONGp=KONGPAUSE;
1061 KONGf++;
1062 KONGf&=1;
1063 }
1064
1065 if(cSWITCHs[0]==2)
1066 {
1067 DoHole();
1068 }
1069
1070 if(cSWITCHs[1]==1)
1071 {
1072 DoKongStood();
1073 }
1074
1075 if(cSWITCHs[1]==2)
1076 {
1077 DoKongFall();
1078 }
1079 }
1080
1081 ///////////////////////////////////////////////////////////////
1082 // Do Kong Stood
1083 ///////////////////////////////////////////////////////////////
1084 void DoKongStood(void)
1085 {
1086 DrawKong(KONGx,KONGy,KONGf,KONGc);
1087
1088 KONGxold[old]=KONGx;
1089 KONGyold[old]=KONGy;
1090 }
1091
1092 ///////////////////////////////////////////////////////////////
1093 // Do Kong Falling
1094 ///////////////////////////////////////////////////////////////
1095 void DoKongFall(void)
1096 {
1097 switch(KONGm)
1098 {
1099 case 0:
1100 KONGm=1;
1101
1102 cMAP[((16/8)*32)+(120/8)]=0;
1103 cMAP[((16/8)*32)+(128/8)]=0;
1104
1105 DrawBGBlock(120/8,16/8);
1106 DrawBGBlock(128/8,16/8);
1107
1108 DrawKong(KONGx,KONGy,KONGf,KONGc);
1109 KONGxold[old]=KONGx;
1110 KONGyold[old]=KONGy;
1111 break;
1112
1113 case 1:
1114 KONGm=2;
1115
1116 DrawBGBlock(120/8,16/8);
1117 DrawBGBlock(128/8,16/8);
1118
1119 DrawKong(KONGx,KONGy,KONGf,KONGc);
1120 KONGxold[old]=KONGx;
1121 KONGyold[old]=KONGy;
1122
1123 KONGc=5;
1124
1125 break;
1126
1127 case 2:
1128 KONGy+=4;
1129
1130 MIDASplaySample(wav,8,255,22050-(KONGy*((old+1)*50)),64,MIDAS_PAN_MIDDLE);
1131
1132 if(KONGy>=KONGmax)
1133 {
1134 //KONGy-=4;
1135 DrawKONG(KONGx,KONGy,KONGf+2,KONGc);
1136 KONGm=3;
1137 }
1138 else
1139 {
1140 DrawKONG(KONGx,KONGy,KONGf+2,KONGc);
1141 SCORE+=100;
1142 }
1143 KONGxold[old]=KONGx;
1144 KONGyold[old]=KONGy;
1145 break;
1146 }
1147 }
1148
1149 ///////////////////////////////////////////////////////////////
1150 // Draw Kong
1151 ///////////////////////////////////////////////////////////////
1152 void DrawKong(int xpos,int ypos,BYTE block, BYTE ink)
1153 {
1154 int x,y,block2;
1155 BYTE data;
1156
1157 block2=(WORD)block;
1158 block2*=256;
1159
1160 for(y=0;y<16;y++)
1161 {
1162 for(x=0;x<16;x++)
1163 {
1164 data=GFXkong[block2];
1165
1166 if(data)
1167 PlotPixel(xpos+x,ypos+y,data+(ink*16));
1168
1169 block2++;
1170 }
1171 }
1172 }
1173 ///////////////////////////////////////////////////////////////
1174 // Remove Kong
1175 ///////////////////////////////////////////////////////////////
1176 void RemoveKong(void)
1177 {
1178 int i,x,y;
1179
1180 if(KONGxold[old]!=65535)
1181 {
1182 for(y=0;y<16;y++)
1183 {
1184 for(x=0;x<16;x++)
1185 {
1186 PlotPixel(KONGxold[old]+x,KONGyold[old]+y,cBGpaper);
1187 }
1188 }
1189 }
1190 }
1191 ///////////////////////////////////////////////////////////////
1192 // Draw Skylab
1193 ///////////////////////////////////////////////////////////////
1194 void DrawSky(int xpos,int ypos,BYTE block, BYTE ink)
1195 {
1196 int x,y,block2;
1197 BYTE data;
1198
1199 block2=(WORD)block;
1200 block2*=256;
1201
1202 for(y=0;y<16;y++)
1203 {
1204 for(x=0;x<16;x++)
1205 {
1206 data=GFXsky[block2];
1207
1208 if(data)
1209 PlotPixel(xpos+x,ypos+y,data+(ink*16));
1210
1211 block2++;
1212 }
1213 }
1214 }
1215 ///////////////////////////////////////////////////////////////
1216 // Remove Skylab
1217 ///////////////////////////////////////////////////////////////
1218 void RemoveSky(void)
1219 {
1220 int i,x,y;
1221
1222 for(i=0;i<3;i++)
1223 {
1224 if(SKYxold[i][old]!=65535)
1225 {
1226 for(y=0;y<16;y++)
1227 {
1228 for(x=0;x<16;x++)
1229 {
1230 PlotPixel(SKYxold[i][old]+x,SKYyold[i][old]+y,cBGpaper);
1231 }
1232 }
1233 }
1234 }
1235 }
1236 ///////////////////////////////////////////////////////////////
1237 // Level 13 " Skylab Landing Bay "
1238 ///////////////////////////////////////////////////////////////
1239 void DoLevelThirteen(void)
1240 {
1241 int i;
1242
1243 for(i=0;i<3;i++)
1244 {
1245 switch(SKYm[i])
1246 {
1247 case 0:
1248 SKYy[i]+=SKYs[i];
1249
1250 if(SKYy[i]>SKYmax[i])
1251 {
1252 SKYy[i]=SKYmax[i];
1253 SKYm[i]=1;
1254 SKYf[i]++;
1255
1256 DrawSky(SKYx[i],SKYy[i],SKYf[i],SKYc[i]);
1257 }
1258
1259 DrawSky(SKYx[i],SKYy[i],SKYf[i],SKYc[i]);
1260 break;
1261
1262 case 1:
1263 SKYf[i]++;
1264
1265 if(SKYf[i]==7)
1266 {
1267 SKYm[i]=2;
1268 }
1269 DrawSky(SKYx[i],SKYy[i],SKYf[i],SKYc[i]);
1270 break;
1271
1272 case 2:
1273 SKYp[i]++;
1274 SKYp[i]&=3;
1275
1276 SKYx[i]=SKYpx[i][SKYp[i]];
1277 SKYy[i]=SKYpy[i][SKYp[i]];
1278
1279 SKYf[i]=0;
1280 SKYm[i]=0;
1281
1282 }
1283
1284 SKYxold[i][old]=SKYx[i];
1285 SKYyold[i][old]=SKYy[i];
1286 }
1287
1288 }
1289 ///////////////////////////////////////////////////////////////
1290 // Draw a SPG Block
1291 ///////////////////////////////////////////////////////////////
1292 void DrawSPGBlock(int x, int y)
1293 {
1294 int c1,c2;
1295 BYTE data;
1296
1297 x*=8;
1298 y*=8;
1299
1300 for(c1=0;c1<8;c1++)
1301 {
1302 for(c2=0;c2<8;c2++)
1303 {
1304 data=GetPixel(x+c2,y+c1);
1305
1306 data&=15;
1307 data-=4;
1308 if(data>15)
1309 data=0;
1310
1311 data+=96;
1312
1313 PlotPixel(x+c2,y+c1,data);
1314 }
1315 }
1316
1317 }
1318
1319 ///////////////////////////////////////////////////////////////
1320 // Remove SPG
1321 ///////////////////////////////////////////////////////////////
1322 void RemoveSPG(void)
1323 {
1324 int i;
1325
1326 for(i=0;i<64;i++)
1327 {
1328 if(SPGx[old][i]!=65535)
1329 DrawBGBlock(SPGx[old][i],SPGy[old][i]);
1330 else
1331 break;
1332 }
1333 }
1334
1335 ///////////////////////////////////////////////////////////////
1336 // Find Route
1337 ///////////////////////////////////////////////////////////////
1338 void FindSPG(void)
1339 {
1340 int x,y,i,done,blockhit,robohit;
1341 BYTE data,dir;
1342
1343
1344 for(i=0;i<64;i++)
1345 {
1346 SPGx[old][i]=65535;
1347 SPGy[old][i]=65535;
1348 }
1349
1350 x=23;
1351 y=0;
1352 dir=0;
1353 done=0;
1354 i=0;
1355
1356 do
1357 {
1358
1359 blockhit=cMAP[(y*32)+x];
1360 robohit=SPGCheckRobo(x,y);
1361
1362 //------------------------------------------------------------------------------
1363
1364 if( (blockhit!=0)&&(robohit!=0) )
1365 {
1366 SPGx[old][i]=65535;
1367 SPGy[old][i]=65535;
1368 done=1;
1369 }
1370
1371 //------------------------------------------------------------------------------
1372
1373 if( (blockhit==0)&&(robohit!=0) )
1374 {
1375 if((SPGx[old][i-1]==x)&&(SPGy[old][i-1]==y))
1376 {
1377 SPGx[old][i]=65535;
1378 SPGy[old][i]=65535;
1379 done=1;
1380 }
1381
1382 SPGx[old][i]=x;
1383 SPGy[old][i]=y;
1384 i++;
1385
1386 dir++;
1387 dir&=1;
1388 }
1389
1390 //------------------------------------------------------------------------------
1391
1392 if( (blockhit==0)&&(robohit==0) )
1393 {
1394 SPGx[old][i]=x;
1395 SPGy[old][i]=y;
1396 i++;
1397 }
1398
1399 //------------------------------------------------------------------------------
1400
1401 if( (blockhit!=0)&&(robohit==0) )
1402 {
1403 if((SPGx[old][i-1]==x)&&(SPGy[old][i-1]==y))
1404 {
1405 SPGx[old][i]=65535;
1406 SPGy[old][i]=65535;
1407 done=1;
1408 }
1409 dir++;
1410 dir&=1;
1411 }
1412
1413 //------------------------------------------------------------------------------
1414
1415 if(blockhit==0)
1416 {
1417 if(dir==0)
1418 {
1419 y++;
1420 blockhit=cMAP[(y*32)+x];
1421
1422 if((y==15)||(blockhit!=0))
1423 {
1424 SPGx[old][i]=65535;
1425 SPGy[old][i]=65535;
1426 done=1;
1427 }
1428 }
1429 else
1430 {
1431 x--;
1432 blockhit=cMAP[(y*32)+x];
1433
1434 if((x==0)||(blockhit!=0))
1435 {
1436 SPGx[old][i]=65535;
1437 SPGy[old][i]=65535;
1438 done=1;
1439 }
1440 }
1441 }
1442 else
1443 {
1444 if(dir==0)
1445 {
1446 x--;
1447 if(x==0)
1448 {
1449 SPGx[old][i]=65535;
1450 SPGy[old][i]=65535;
1451 done=1;
1452 }
1453 }
1454 else
1455 {
1456 y++;
1457 if(y==15)
1458 {
1459 SPGx[old][i]=65535;
1460 SPGy[old][i]=65535;
1461 done=1;
1462 }
1463 }
1464 }
1465
1466 //------------------------------------------------------------------------------
1467 }while(done==0);
1468
1469
1470 SPGx[old][i]=65535;
1471 SPGy[old][i]=65535;
1472
1473 }
1474
1475 ///////////////////////////////////////////////////////////////
1476 // Check if hit Robo
1477 ///////////////////////////////////////////////////////////////
1478 int SPGCheckRobo(WORD x, WORD y)
1479 {
1480 int i;
1481 int hit;
1482
1483 x*=8;
1484 y*=8;
1485
1486 hit=0;
1487
1488 for(i=0;i<4;i++)
1489 {
1490 if(cHROBOx[i]!=65535)
1491 {
1492 if( ((x+7)>=cHROBOx[i]) && (x<=(cHROBOx[i]+15)) &&
1493 ((y+7)>=cHROBOy[i]) && (y<=(cHROBOy[i]+15)))
1494 {
1495 hit++;
1496 }
1497 }
1498
1499 if(cVROBOx[i]!=65535)
1500 {
1501 if( ((x+7)>=cVROBOx[i]) && (x<=(cVROBOx[i]+15)) &&
1502 ((y+7)>=cVROBOy[i]) && (y<=(cVROBOy[i]+15)))
1503 {
1504 hit++;
1505 }
1506 }
1507 }
1508
1509
1510 return(hit);
1511 }
1512 ///////////////////////////////////////////////////////////////
1513 // Do the Solar Power Generator
1514 ///////////////////////////////////////////////////////////////
1515 void DoSPG(void)
1516 {
1517 int i;
1518
1519 FindSPG();
1520
1521 for(i=0;i<64;i++)
1522 {
1523 if(SPGx[old][i]!=65535)
1524 {
1525 DrawSPGBlock(SPGx[old][i],SPGy[old][i]);
1526 }
1527
1528 }
1529
1530 }
1531 ///////////////////////////////////////////////////////////////
1532 // Check SPG
1533 ///////////////////////////////////////////////////////////////
1534 void CheckSPG(void)
1535 {
1536 int i,hit;
1537
1538 for(i=0;i<64;i++)
1539 {
1540 if(SPGx[old][i]!=65535)
1541 {
1542 hit=0;
1543
1544 if(((SPGx[old][i]*8)>=cWILLYx)&&((SPGy[old][i]*8)>=cWILLYy))
1545 {
1546 if( ((SPGx[old][i]*8)<(cWILLYx+8))&&((SPGy[old][i]*8)<(cWILLYy+16)) )
1547 {
1548 if(hit==0)
1549 {
1550 cAIR--;
1551 hit=1;
1552 }
1553 }
1554 }
1555
1556 if((((SPGx[old][i]*8)+7)>=cWILLYx)&&((SPGy[old][i]*8)>=cWILLYy))
1557 {
1558 if( (((SPGx[old][i]*8)+7)<(cWILLYx+8))&&((SPGy[old][i]*8)<(cWILLYy+16)) )
1559 {
1560 if(hit==0)
1561 {
1562 cAIR--;
1563 hit=1;
1564 }
1565 }
1566 }
1567
1568 if(((SPGx[old][i]*8)>=cWILLYx)&&(((SPGy[old][i]*8)+7)>=cWILLYy))
1569 {
1570 if( ((SPGx[old][i]*8)<(cWILLYx+8))&&(((SPGy[old][i]*8)+7)<(cWILLYy+16)) )
1571 {
1572 if(hit==0)
1573 {
1574 cAIR--;
1575 hit=1;
1576 }
1577 }
1578 }
1579
1580 if((((SPGx[old][i]*8)+7)>=cWILLYx)&&(((SPGy[old][i]*8)+7)>=cWILLYy))
1581 {
1582 if( (((SPGx[old][i]*8)+7)<(cWILLYx+8))&&(((SPGy[old][i]*8)+7)<(cWILLYy+16)) )
1583 {
1584 if(hit==0)
1585 {
1586 cAIR--;
1587 hit=1;
1588 }
1589 }
1590 }
1591
1592 }
1593 }
1594
1595 }
1596
1597
1598 ///////////////////////////////////////////////////////////////
1599 // Draw Willy
1600 ///////////////////////////////////////////////////////////////
1601 void DrawWilly(int xpos,int ypos,BYTE block)
1602 {
1603 int x,y,block2;
1604 BYTE data;
1605
1606 block2=(WORD)block;
1607 block2*=256;
1608
1609 for(y=0;y<16;y++)
1610 {
1611 for(x=0;x<16;x++)
1612 {
1613 data=GFXwilly[block2];
1614
1615 if(data)
1616 {
1617 if(GetPixel(xpos+x,ypos+y)==cBGpaper)
1618 PlotPixel(xpos+x,ypos+y,data);
1619 }
1620 block2++;
1621 }
1622 }
1623 }
1624 ///////////////////////////////////////////////////////////////
1625 // Get Willy Background
1626 ///////////////////////////////////////////////////////////////
1627 void GetWillyBG(int xpos, int ypos)
1628 {
1629 int x,y;
1630 BYTE data;
1631
1632 for(y=0;y<16;y++)
1633 {
1634 for(x=0;x<16;x++)
1635 {
1636 cWILLYbuff[old][(y*16)+x]=GetPixel(xpos+x,ypos+y);
1637 }
1638 }
1639 }
1640 ///////////////////////////////////////////////////////////////
1641 // Remove Willy
1642 ///////////////////////////////////////////////////////////////
1643 void RemoveWilly(void)
1644 {
1645 int x,y;
1646
1647 if(cWILLYxold[old]!=65535)
1648 {
1649 for(y=0;y<16;y++)
1650 {
1651 for(x=0;x<16;x++)
1652 {
1653 PlotPixel(cWILLYxold[old]+x,cWILLYyold[old]+y,cWILLYbuff[old][(y*16)+x]);
1654 }
1655 }
1656 }
1657
1658 }
1659 ///////////////////////////////////////////////////////////////
1660 // Do Willy Stuff
1661 //
1662 // Modes:-
1663 // 0=Walking Left\Right
1664 // 1=Jump Up
1665 // 2=Jump Left
1666 // 3=jump Right
1667 // 4=Fall
1668 // 5=On Conv
1669 // 6=Death
1670 //
1671 ///////////////////////////////////////////////////////////////
1672 void DoWilly(void)
1673 {
1674 int input,block1,block2;
1675
1676 input=GetWillyInput();
1677
1678 //------------------------------------------------------------------------------
1679 if(CheckWillyKillBlock()!=0)
1680 cWILLYm=6;
1681 //------------------------------------------------------------------------------
1682 if(WillyCheckRobo()!=0)
1683 cWILLYm=6;
1684 //------------------------------------------------------------------------------
1685 if(cWILLYm==0)
1686 {
1687 CheckWillyFall();
1688 }
1689 //------------------------------------------------------------------------------
1690 switch( cWILLYm)
1691 {
1692 //------------------------------------------------------------------------------
1693 case 0:
1694 CheckCrumb();
1695
1696 if(input==1)
1697 {
1698 if((CheckWillyConv()==1)&&(cCONVd==0))
1699 {
1700 cWILLYm=5;
1701 cCONVm=0;
1702 }
1703 else
1704 {
1705 DoWillyLeft();
1706 cWILLYfall=0;
1707 }
1708 }
1709 else
1710 {
1711 if(input==2)
1712 {
1713 if((CheckWillyConv()==1)&&(cCONVd==1))
1714 {
1715 cWILLYm=5;
1716 cCONVm=0;
1717 }
1718 else
1719 {
1720 DoWillyRight();
1721 cWILLYfall=0;
1722 }
1723
1724 }
1725 else
1726 {
1727 if(input==4)
1728 {
1729 cWILLYm=1;
1730 cWILLYj=0;
1731 cWILLYfall=0;
1732 cWILLYjs=0;
1733
1734 if(CheckWillyConv()==1)
1735 {
1736 cWILLYm=5;
1737 if(cWILLYm==cCONVd)
1738 {
1739 cCONVm=2;
1740 }
1741 else
1742 {
1743 cWILLYd++;
1744 cWILLYd&=1;
1745 cCONVm=1;
1746 }
1747 }
1748 else
1749 {
1750 DoWillyJump();
1751 }
1752 }
1753 else
1754 {
1755 if(input==5)
1756 {
1757 if(cWILLYd==0)
1758 {
1759 cWILLYd=1;
1760 cWILLYm=1;
1761 cWILLYj=0;
1762 cWILLYfall=0;
1763 cWILLYjs=0;
1764
1765 if((CheckWillyConv()==1)&&(cCONVd==0))
1766 {
1767 cWILLYm=5;
1768 cCONVm=1;
1769 }
1770
1771 DoWillyJump();
1772 }
1773 else
1774 {
1775 cWILLYm=2;
1776 cWILLYj=0;
1777
1778 if((CheckWillyConv()==1)&&(cCONVd==0))
1779 {
1780 cWILLYm=5;
1781 cCONVm=1;
1782 }
1783 else
1784 {
1785 DoWillyLeft();
1786 DoWillyJump();
1787 }
1788
1789 cWILLYfall=0;
1790 cWILLYjs=0;
1791 }
1792 }
1793 else
1794 {
1795 if(input==6)
1796 {
1797 if(cWILLYd==1)
1798 {
1799 cWILLYd=0;
1800 cWILLYm=1;
1801 cWILLYj=0;
1802 cWILLYfall=0;
1803 cWILLYjs=0;
1804
1805 if((CheckWillyConv()==1)&&(cCONVd==1))
1806 {
1807 cWILLYm=5;
1808 cCONVm=1;
1809 }
1810
1811 DoWillyJump();
1812 }
1813 else
1814 {
1815 cWILLYm=3;
1816 cWILLYj=0;
1817
1818
1819 if((CheckWillyConv()==1)&&(cCONVd==1))
1820 {
1821 cWILLYm=5;
1822 cCONVm=1;
1823 }
1824 else
1825 {
1826 DoWillyRight();
1827 DoWillyJump();
1828 }
1829 cWILLYfall=0;
1830 cWILLYjs=0;
1831 }
1832 }
1833 else
1834 {
1835 cWILLYfall=0;
1836 cWILLYjs=0;
1837
1838 if(CheckWillyConv()!=0)
1839 {
1840 cWILLYm=5;
1841 cCONVm=0;
1842 DoOnConv(input);
1843 }
1844 }
1845
1846 }
1847 }
1848 }
1849 }
1850 break;
1851 //------------------------------------------------------------------------------
1852 case 1:
1853 DoWillyJump();
1854 break;
1855 //------------------------------------------------------------------------------
1856 case 2:
1857 DoWillyLeft();
1858 DoWillyJump();
1859 break;
1860 //------------------------------------------------------------------------------
1861 case 3:
1862 DoWillyRight();
1863 DoWillyJump();
1864 break;
1865 //------------------------------------------------------------------------------
1866 case 4:
1867 DoWillyFall();
1868 break;
1869 //------------------------------------------------------------------------------
1870 case 5:
1871 DoOnConv(input);
1872 break;
1873 //------------------------------------------------------------------------------
1874 case 6:
1875 DoDeath();
1876 break;
1877 }
1878 //------------------------------------------------------------------------------
1879 CheckKeys();
1880 CheckExit();
1881 CheckSwitches();
1882 //------------------------------------------------------------------------------
1883 PutWilly();
1884 cWILLYxold[old]=cWILLYx&248;
1885 cWILLYyold[old]=cWILLYy;
1886
1887 }
1888
1889 ///////////////////////////////////////////////////////////////
1890 // Do Willy Left
1891 ///////////////////////////////////////////////////////////////
1892 void DoWillyLeft(void)
1893 {
1894 int block1,block2,block3;
1895
1896 if(cWILLYd==0)
1897 {
1898 cWILLYd=1;
1899 }
1900 else
1901 {
1902 cWILLYx-=2;
1903
1904 block1=GetBlock(cWILLYx,cWILLYy);
1905 block2=GetBlock(cWILLYx,cWILLYy+8);
1906 block3=GetBlock(cWILLYx,cWILLYy+12);
1907 if((block1==3)||(block2==3)||(block3==3))
1908 {
1909 cWILLYx+=2;
1910 }
1911
1912 }
1913 }
1914 ///////////////////////////////////////////////////////////////
1915 // Do Willy Right
1916 ///////////////////////////////////////////////////////////////
1917 void DoWillyRight(void)
1918 {
1919 int block1,block2,block3;
1920
1921 if(cWILLYd==1)
1922 {
1923 cWILLYd=0;
1924 }
1925 else
1926 {
1927 cWILLYx+=2;
1928
1929 block1=GetBlock(cWILLYx+8,cWILLYy);
1930 block2=GetBlock(cWILLYx+8,cWILLYy+8);
1931 block3=GetBlock(cWILLYx+8,cWILLYy+12);
1932 if((block1==3)||(block2==3)||(block3==3))
1933 {
1934 cWILLYx-=2;
1935 }
1936 }
1937 }
1938 ///////////////////////////////////////////////////////////////
1939 // Do Willy Jump
1940 ///////////////////////////////////////////////////////////////
1941 void DoWillyJump(void)
1942 {
1943 int block1,block2;
1944
1945 if(cWILLYj<8)
1946 {
1947 cWILLYy-=cWILLYjp[cWILLYj];
1948
1949 block1=GetBlock(cWILLYx,cWILLYy);
1950 block2=GetBlock(cWILLYx+8,cWILLYy);
1951 if((block1==3)||(block2==3))
1952 {
1953 cWILLYjs=0;
1954 cWILLYm=4;
1955 DoWillyFall();
1956 }
1957
1958 }
1959 else
1960 {
1961 if(cWILLYj>11)
1962 {
1963 if((cWILLYy&7)==0)
1964 {
1965 block1=GetBlock(cWILLYx,cWILLYy+16);
1966 block2=GetBlock(cWILLYx+8,cWILLYy+16);
1967 if((block1!=0)||(block2!=0))
1968 {
1969 cWILLYm=0;
1970 cWILLYy&=248;
1971 if((block1==7)||(block2==7))
1972 {
1973 if(cCONVd!=cWILLYd)
1974 {
1975 cWILLYm=5;
1976 cCONVm=0;
1977 cWILLYfall=0;
1978 }
1979 }
1980 }
1981 else
1982 {
1983 cWILLYy+=cWILLYjp[cWILLYj];
1984 }
1985 }
1986 else
1987 {
1988 cWILLYy+=cWILLYjp[cWILLYj];
1989 }
1990
1991 }
1992 else
1993 {
1994 cWILLYy+=cWILLYjp[cWILLYj];
1995 }
1996
1997
1998 if(cWILLYj>12)
1999 {
2000 cWILLYfall+=cWILLYjp[cWILLYj];
2001 }
2002 }
2003
2004
2005 cWILLYj++;
2006 if(cWILLYj==18)
2007 {
2008 cWILLYm=0;
2009 }
2010
2011 if(cWILLYj<10)
2012 {
2013 cWILLYjs++;
2014 }
2015
2016 if(cWILLYj>9)
2017 {
2018 cWILLYjs--;
2019 }
2020
2021 MIDASplaySample(wav,6,255,16384+(cWILLYjs*1500),64,MIDAS_PAN_MIDDLE);
2022
2023 if(cWILLYy>104)
2024 {
2025 //cWILLYy=104;
2026 cWILLYm=4;
2027 DoWillyFall();
2028 }
2029
2030 }
2031 ///////////////////////////////////////////////////////////////
2032 // Check Fall
2033 ///////////////////////////////////////////////////////////////
2034 void CheckWillyFall(void)
2035 {
2036 int block1,block2;
2037
2038 block1=GetBlock(cWILLYx,cWILLYy+16);
2039 block2=GetBlock(cWILLYx+8,cWILLYy+16);
2040 if((block1==0)&&(block2==0))
2041 {
2042 cWILLYjs=0;
2043 cWILLYm=4;
2044 }
2045 else
2046 {
2047 if((block1==5)||(block2==5)||(block1==6)||(block2==6))
2048 {
2049 cWILLYm=6;
2050 }
2051 }
2052 }
2053 ///////////////////////////////////////////////////////////////
2054 // Do Willy Fall
2055 ///////////////////////////////////////////////////////////////
2056 void DoWillyFall(void)
2057 {
2058 int block1,block2;
2059
2060 cWILLYy+=4;
2061 cWILLYjs++;
2062 if(cWILLYjs>11)
2063 cWILLYjs=0;
2064
2065 MIDASplaySample(wav,6,255,16384-(cWILLYjs*1000),64,MIDAS_PAN_MIDDLE);
2066
2067 block1=GetBlock(cWILLYx,cWILLYy+16);
2068 block2=GetBlock(cWILLYx+8,cWILLYy+16);
2069 if((block1!=0)||(block2!=0))
2070 {
2071 cWILLYm=0;
2072 cWILLYy&=248;
2073
2074 if(CheckWillyConv()==1)
2075 {
2076 cWILLYm=5;
2077 cCONVm=0;
2078 }
2079 if(cWILLYfall>=32)
2080 cWILLYm=6;
2081 else
2082 cWILLYfall=0;
2083 }
2084 else
2085 {
2086 cWILLYfall+=4;
2087 }
2088
2089 }
2090 ///////////////////////////////////////////////////////////////
2091 // Do Willy Normal
2092 ///////////////////////////////////////////////////////////////
2093 void PutWilly(void)
2094 {
2095 if( cWILLYd )
2096 {
2097 GetWillyBG((cWILLYx&248),cWILLYy);
2098 DrawWILLY((cWILLYx&248),cWILLYy,((cWILLYx&15)>>1)+8);
2099 }
2100 else
2101 {
2102 GetWillyBG((cWILLYx&248),cWILLYy);
2103 DrawWILLY((cWILLYx&248),cWILLYy,((cWILLYx&15)>>1));
2104 }
2105
2106
2107 }
2108 ///////////////////////////////////////////////////////////////
2109 // Get Willy Input
2110 ///////////////////////////////////////////////////////////////
2111 int GetWillyInput(void)
2112 {
2113 int left=0;
2114 int right=0;
2115 int jump=0;
2116
2117 if( (KeyTable[key_q]==1) ||
2118 (KeyTable[key_e]==1) ||
2119 (KeyTable[key_tee]==1) ||
2120 (KeyTable[key_u]==1) ||
2121 (KeyTable[key_o]==1) ||
2122 (KeyTable[key_n4]==1) ||
2123 (KeyTable[key_opensqu]==1) )
2124 {
2125 left=1;
2126 }
2127
2128 if( (KeyTable[key_tab]==1) ||
2129 (KeyTable[key_w]==1) ||
2130 (KeyTable[key_r]==1) ||
2131 (KeyTable[key_y]==1) ||
2132 (KeyTable[key_i]==1) ||
2133 (KeyTable[key_p]==1) ||
2134 (KeyTable[key_n6]==1) ||
2135 (KeyTable[key_closedsqu]==1) )
2136 {
2137 right=2;
2138 }
2139
2140 if( (KeyTable[key_leftshift]==1) ||
2141 (KeyTable[key_backslash]==1) ||
2142 (KeyTable[key_z]==1) ||
2143 (KeyTable[key_x]==1) ||
2144 (KeyTable[key_c]==1) ||
2145 (KeyTable[key_v]==1) ||
2146 (KeyTable[key_b]==1) ||
2147 (KeyTable[key_n]==1) ||
2148 (KeyTable[key_m]==1) ||
2149 (KeyTable[key_n8]==1) ||
2150 (KeyTable[key_comma]==1) ||
2151 (KeyTable[key_stop]==1) ||
2152 (KeyTable[key_fwdslash]==1) ||
2153 (KeyTable[key_rightshift]==1) ||
2154 (KeyTable[key_space]==1) )
2155 {
2156 jump=4;
2157 }
2158
2159
2160 return(left|right|jump);
2161 }
2162 ///////////////////////////////////////////////////////////////
2163 // Get Block
2164 ///////////////////////////////////////////////////////////////
2165 int GetBlock(WORD x, WORD y)
2166 {
2167 BYTE data;
2168
2169 data=cMAP[ (((y/8)*32)+(x/8)) ];
2170 return((int)data);
2171 }
2172 ///////////////////////////////////////////////////////////////
2173 // Check Willy Against Kill Blocks
2174 ///////////////////////////////////////////////////////////////
2175 int CheckWillyKillBlock(void)
2176 {
2177 int block1,block2;
2178 int block3,block4;
2179 int block5,block6;
2180 int hit;
2181
2182 hit=0;
2183
2184 block1=GetBlock(cWILLYx,cWILLYy);
2185 block2=GetBlock(cWILLYx+8,cWILLYy+8);
2186 block3=GetBlock(cWILLYx,cWILLYy+8);
2187 block4=GetBlock(cWILLYx+8,cWILLYy);
2188 block5=GetBlock(cWILLYx,cWILLYy+14);
2189 block6=GetBlock(cWILLYx+8,cWILLYy+14);
2190
2191 if((block1==5)||(block2==5)||
2192 (block3==5)||(block4==5)||
2193 (block5==5)||(block6==5))
2194 {
2195 hit=1;
2196 }
2197
2198 if((block1==6)||(block2==6)||
2199 (block3==6)||(block4==6)||
2200 (block5==6)||(block6==6))
2201 {
2202 hit=1;
2203 }
2204
2205 return(hit);
2206 }
2207 ///////////////////////////////////////////////////////////////
2208 // Check if hit Robo
2209 ///////////////////////////////////////////////////////////////
2210 int WillyCheckRobo(void)
2211 {
2212 int i;
2213 int hit;
2214
2215 hit=0;
2216
2217 for(i=0;i<4;i++)
2218 {
2219 if(cHROBOx[i]!=65535)
2220 {
2221 if(((cWILLYx+7)>cHROBOx[i])&&(cWILLYy>cHROBOy[i]))
2222 {
2223 if( ((cWILLYx+7)<(cHROBOx[i]+16))&&(cWILLYy+2<(cHROBOy[i]+16)) )
2224 {
2225 hit++;
2226 }
2227 }
2228
2229 if(((cWILLYx+8)>cHROBOx[i])&&(cWILLYy>cHROBOy[i]))
2230 {
2231 if( ((cWILLYx+8)<(cHROBOx[i]+16))&&(cWILLYy<(cHROBOy[i]+16)) )
2232 {
2233 hit++;
2234 }
2235 }
2236
2237 if(((cWILLYx+7)>cHROBOx[i])&&((cWILLYy+13)>cHROBOy[i]))
2238 {
2239 if( ((cWILLYx+7)<(cHROBOx[i]+16))&&((cWILLYy+13)<(cHROBOy[i]+16)) )
2240 {
2241 hit++;
2242 }
2243 }
2244
2245 if(((cWILLYx+8)>cHROBOx[i])&&((cWILLYy+13)>cHROBOy[i]))
2246 {
2247 if( ((cWILLYx+8)<(cHROBOx[i]+16))&&((cWILLYy+13)<(cHROBOy[i]+16)) )
2248 {
2249 hit++;
2250 }
2251 }
2252
2253 }
2254
2255 if(cVROBOx[i]!=65535)
2256 {
2257 if(((cWILLYx+3)>cVROBOx[i])&&((cWILLYy+3)>cVROBOy[i]))
2258 {
2259 if( ((cWILLYx+3)<(cVROBOx[i]+16))&&((cWILLYy+3)<(cVROBOy[i]+16)) )
2260 {
2261 hit++;
2262 }
2263 }
2264
2265 if(((cWILLYx+7)>cVROBOx[i])&&((cWILLYy+3)>cVROBOy[i]))
2266 {
2267 if( ((cWILLYx+7)<(cVROBOx[i]+16))&&((cWILLYy+3)<(cVROBOy[i]+16)) )
2268 {
2269 hit++;
2270 }
2271 }
2272
2273 if(((cWILLYx+3)>cVROBOx[i])&&((cWILLYy+11)>cVROBOy[i]))
2274 {
2275 if( ((cWILLYx+3)<(cVROBOx[i]+16))&&((cWILLYy+11)<(cVROBOy[i]+16)) )
2276 {
2277 hit++;
2278 }
2279 }
2280
2281 if(((cWILLYx+7)>cVROBOx[i])&&((cWILLYy+11)>cVROBOy[i]))
2282 {
2283 if( ((cWILLYx+7)<(cVROBOx[i]+16))&&((cWILLYy+11)<(cVROBOy[i]+16)) )
2284 {
2285 hit++;
2286 }
2287 }
2288
2289 }
2290 }
2291
2292 if((LEVEL==4)||(LEVEL==24))
2293 {
2294 if(((cWILLYx+7)>EUGENEx)&&(cWILLYy>EUGENEy))
2295 {
2296 if( ((cWILLYx+7)<(EUGENEx+16))&&(cWILLYy<(EUGENEy+16)) )
2297 {
2298 hit++;
2299 }
2300 }
2301
2302 if(((cWILLYx+8)>EUGENEx)&&(cWILLYy>EUGENEy))
2303 {
2304 if( ((cWILLYx+8)<(EUGENEx+16))&&(cWILLYy<(EUGENEy+16)) )
2305 {
2306 hit++;
2307 }
2308 }
2309
2310 if(((cWILLYx+7)>EUGENEx)&&((cWILLYy+15)>EUGENEy))
2311 {
2312 if( ((cWILLYx+7)<(EUGENEx+16))&&((cWILLYy+15)<(EUGENEy+16)) )
2313 {
2314 hit++;
2315 }
2316 }
2317
2318 if(((cWILLYx+8)>EUGENEx)&&((cWILLYy+15)>EUGENEy))
2319 {
2320 if( ((cWILLYx+8)<(EUGENEx+16))&&((cWILLYy+15)<(EUGENEy+16)) )
2321 {
2322 hit++;
2323 }
2324 }
2325
2326 }
2327
2328 if(((LEVEL==7)||(LEVEL==11)||(LEVEL==27)||(LEVEL==31))&&(KONGm!=3))
2329 {
2330 if(((cWILLYx+7)>KONGx)&&(cWILLYy>KONGy))
2331 {
2332 if( ((cWILLYx+7)<(KONGx+16))&&(cWILLYy<(KONGy+16)) )
2333 {
2334 hit++;
2335 }
2336 }
2337
2338 if(((cWILLYx+8)>KONGx)&&(cWILLYy>KONGy))
2339 {
2340 if( ((cWILLYx+8)<(KONGx+16))&&(cWILLYy<(KONGy+16)) )
2341 {
2342 hit++;
2343 }
2344 }
2345
2346 if(((cWILLYx+7)>KONGx)&&((cWILLYy+15)>KONGy))
2347 {
2348 if( ((cWILLYx+7)<(KONGx+16))&&((cWILLYy+15)<(KONGy+16)) )
2349 {
2350 hit++;
2351 }
2352 }
2353
2354 if(((cWILLYx+8)>KONGx)&&((cWILLYy+15)>KONGy))
2355 {
2356 if( ((cWILLYx+8)<(KONGx+16))&&((cWILLYy+15)<(KONGy+16)) )
2357 {
2358 hit++;
2359 }
2360 }
2361
2362 }
2363
2364 if((LEVEL==13)||(LEVEL==33))
2365 {
2366
2367 for(i=0;i<3;i++)
2368 {
2369 if(((cWILLYx+7)>SKYx[i])&&(cWILLYy>SKYy[i]))
2370 {
2371 if( ((cWILLYx+7)<(SKYx[i]+16))&&(cWILLYy<(SKYy[i]+16)) )
2372 {
2373 hit++;
2374 }
2375 }
2376
2377 if(((cWILLYx+8)>SKYx[i])&&(cWILLYy>SKYy[i]))
2378 {
2379 if( ((cWILLYx+8)<(SKYx[i]+16))&&(cWILLYy<(SKYy[i]+16)) )
2380 {
2381 hit++;
2382 }
2383 }
2384
2385 if(((cWILLYx+7)>SKYx[i])&&((cWILLYy+15)>SKYy[i]))
2386 {
2387 if( ((cWILLYx+7)<(SKYx[i]+16))&&((cWILLYy+15)<(SKYy[i]+16)) )
2388 {
2389 hit++;
2390 }
2391 }
2392
2393 if(((cWILLYx+8)>SKYx[i])&&((cWILLYy+15)>SKYy[i]))
2394 {
2395 if( ((cWILLYx+8)<(SKYx[i]+16))&&((cWILLYy+15)<(SKYy[i]+16)) )
2396 {
2397 hit++;
2398 }
2399 }
2400
2401 }
2402 }
2403
2404 return(hit);
2405 }
2406 ///////////////////////////////////////////////////////////////
2407 // Check Keys
2408 ///////////////////////////////////////////////////////////////
2409 void CheckKeys(void)
2410 {
2411 int i,hit;
2412
2413 hit=0;
2414
2415 for(i=0;i<5;i++)
2416 {
2417 if(cKEYs[i]==1)
2418 {
2419 if((cKEYx[i]>=cWILLYx)&&(cKEYy[i]>=cWILLYy))
2420 {
2421 if( (cKEYx[i]<(cWILLYx+10))&&(cKEYy[i]<(cWILLYy+18)) )
2422 {
2423 cKEYs[i]=0;
2424 hit=1;
2425 SCORE+=100;
2426 }
2427 }
2428
2429 if(((cKEYx[i]+7)>=cWILLYx)&&(cKEYy[i]>=cWILLYy))
2430 {
2431 if( ((cKEYx[i]+7)<(cWILLYx+10))&&(cKEYy[i]<(cWILLYy+18)) )
2432 {
2433 if(hit==0)
2434 {
2435 cKEYs[i]=0;
2436 SCORE+=100;
2437 hit=1;
2438 }
2439 }
2440 }
2441
2442 if((cKEYx[i]>=cWILLYx)&&((cKEYy[i]+7)>=cWILLYy))
2443 {
2444 if( (cKEYx[i]<(cWILLYx+10))&&((cKEYy[i]+7)<(cWILLYy+18)) )
2445 {
2446 if(hit==0)
2447 {
2448 cKEYs[i]=0;
2449 SCORE+=100;
2450 hit=1;
2451 }
2452 }
2453 }
2454
2455 if(((cKEYx[i]+7)>=cWILLYx)&&((cKEYy[i]+7)>=cWILLYy))
2456 {
2457 if( ((cKEYx[i]+7)<(cWILLYx+10))&&((cKEYy[i]+7)<(cWILLYy+18)) )
2458 {
2459 if(hit==0)
2460 {
2461 cKEYs[i]=0;
2462 SCORE+=100;
2463 hit=1;
2464 }
2465 }
2466 }
2467
2468 }
2469
2470 }
2471
2472 if(hit==1)
2473 MIDASplaySample(pick,8,300,22050,64,MIDAS_PAN_MIDDLE);
2474
2475 }
2476 ///////////////////////////////////////////////////////////////
2477 // Check Switches
2478 ///////////////////////////////////////////////////////////////
2479 void CheckSwitches(void)
2480 {
2481 int i;
2482
2483 for(i=0;i<2;i++)
2484 {
2485 if(cSWITCHs[i]==1)
2486 {
2487 if((cSWITCHx[i]+7>=cWILLYx)&&(cSWITCHy[i]+7>=cWILLYy)&&
2488 (cSWITCHx[i]<cWILLYx+8)&&(cSWITCHy[i]<cWILLYy+16))
2489 {
2490 cSWITCHs[i]=2;
2491 }
2492 }
2493 }
2494
2495 }
2496 ///////////////////////////////////////////////////////////////
2497 // Check Crumb
2498 ///////////////////////////////////////////////////////////////
2499 void CheckCrumb(void)
2500 {
2501 int block1,block2;
2502
2503 block1=GetBlock(cWILLYx,cWILLYy+16);
2504 if(block1==4)
2505 {
2506
2507 cCRUMB[(((cWILLYy+16)/8)*32)+(cWILLYx/8)]&=31;
2508 cCRUMB[(((cWILLYy+16)/8)*32)+(cWILLYx/8)]--;
2509 cCRUMB[(((cWILLYy+16)/8)*32)+(cWILLYx/8)]|=128;
2510
2511 if(cCRUMB[(((cWILLYy+16)/8)*32)+(cWILLYx/8)]==128)
2512 {
2513 cMAP[(((cWILLYy+16)/8)*32)+(cWILLYx/8)]=0;
2514 }
2515 else
2516 {
2517 }
2518
2519 }
2520
2521
2522 block1=GetBlock(cWILLYx+8,cWILLYy+16);
2523 if(block1==4)
2524 {
2525 cCRUMB[(((cWILLYy+16)/8)*32)+((cWILLYx+8)/8)]&=31;
2526 cCRUMB[(((cWILLYy+16)/8)*32)+((cWILLYx+8)/8)]--;
2527 cCRUMB[(((cWILLYy+16)/8)*32)+((cWILLYx+8)/8)]|=128;
2528
2529 if(cCRUMB[(((cWILLYy+16)/8)*32)+((cWILLYx+8)/8)]==128)
2530 {
2531 cMAP[(((cWILLYy+16)/8)*32)+((cWILLYx+8)/8)]=0;
2532 }
2533 else
2534 {
2535 }
2536
2537 }
2538
2539 }
2540 ///////////////////////////////////////////////////////////////
2541 // Do Crumb
2542 ///////////////////////////////////////////////////////////////
2543 void DoCrumb(void)
2544 {
2545 int x,y,dx,dy,doff;
2546 int cx,cy;
2547 WORD block2;
2548 BYTE data,data2;
2549
2550 for(y=0;y<16;y++)
2551 {
2552 for(x=0;x<32;x++)
2553 {
2554 data=cCRUMB[(y*32)+x];
2555
2556 if(((data&128)==128)||((data&64)==64))
2557 {
2558 for(dy=0;dy<(8-(data&31));dy++)
2559 {
2560 for(dx=0;dx<8;dx++)
2561 {
2562 PlotPixel((x*8)+dx,(y*8)+dy,cBGpaper);
2563 }
2564 }
2565
2566 dx=x*8;
2567 dy=y*8;
2568
2569 block2=(WORD)cCRUMBgfx;
2570 block2*=64;
2571 doff=8-(data&31);
2572
2573 for(cy=0;cy<(data&31);cy++)
2574 {
2575 for(cx=0;cx<8;cx++)
2576 {
2577 data2=GFXblocks[block2];
2578
2579 if(!data2)
2580 PlotPixel(dx+cx,(dy+doff)+cy,cBGpaper);
2581 else
2582 PlotPixel(dx+cx,(dy+doff)+cy,data2+(cCRUMBink*16));
2583
2584 block2++;
2585 }
2586 }
2587 if((data&128)==128)
2588 {
2589 cCRUMB[(y*32)+x]&=31;
2590 cCRUMB[(y*32)+x]|=64;
2591 }
2592 else
2593 {
2594 if((data&64)==64)
2595 {
2596 cCRUMB[(y*32)+x]&=31;
2597 }
2598 }
2599
2600 }
2601 else
2602 {
2603 }
2604 }
2605 }
2606 }
2607 ///////////////////////////////////////////////////////////////
2608 // Check Exit
2609 ///////////////////////////////////////////////////////////////
2610 void CheckExit(void)
2611 {
2612
2613
2614 if(cEXITm==1)
2615 {
2616 if(((cWILLYx+4)>cEXITx)&&((cWILLYy+8)>cEXITy))
2617 {
2618 if( ((cWILLYx+4)<(cEXITx+16))&&((cWILLYy+8)<(cEXITy+16)) )
2619 {
2620 GAMEm=3;
2621 }
2622 }
2623
2624
2625 if( ((cWILLYx+5)>cEXITx)&&((cWILLYy+8)>cEXITy) )
2626 {
2627 if(((cWILLYx+5)<(cEXITx+16))&&((cWILLYy+8)<(cEXITy+16)))
2628 {
2629 GAMEm=3;
2630 }
2631 }
2632
2633
2634 if( ((cWILLYx+4)>cEXITx)&&((cWILLYy+9)>cEXITy) )
2635 {
2636 if(((cWILLYx+4)<(cEXITx+16))&&((cWILLYy+9)<(cEXITy+16)))
2637 {
2638 GAMEm=3;
2639 }
2640 }
2641
2642 if(((cWILLYx+5)>cEXITx)&&((cWILLYy+9)>cEXITy))
2643 {
2644 if(((cWILLYx+5)<(cEXITx+16))&&((cWILLYy+9)<(cEXITy+16)))
2645 {
2646 GAMEm=3;
2647 }
2648 }
2649
2650 }
2651
2652 if(((LEVEL==19)||(LEVEL==39))&&(GAMEm==3))
2653 {
2654 if(CHEAT!=1)
2655 {
2656 GAMEm=5;
2657 LASTm=0;
2658 LASTc=0;
2659 LASTp=0;
2660 TEXTm=0;
2661 TEXTink=7;
2662 TEXTfade=0;
2663 }
2664 }
2665 }
2666 ///////////////////////////////////////////////////////////////
2667 // Check if on CONV
2668 ///////////////////////////////////////////////////////////////
2669 int CheckWillyConv(void)
2670 {
2671 int block1,block2;
2672
2673 block1=GetBlock(cWILLYx,cWILLYy+16);
2674 block2=GetBlock(cWILLYx+8,cWILLYy+16);
2675 if((block1==7)||(block2==7))
2676 {
2677 return(1);
2678 }
2679
2680 return(0);
2681 }
2682
2683 ///////////////////////////////////////////////////////////////
2684 // Do On Conv
2685 ///////////////////////////////////////////////////////////////
2686 void DoOnConv(int input)
2687 {
2688 switch(cCONVd)
2689 {
2690 case 0:
2691 DoConvLeft(input);
2692 break;
2693 case 1:
2694 DoConvRight(input);
2695 break;
2696 }
2697
2698 }
2699 ///////////////////////////////////////////////////////////////
2700 // On Convayor going Left
2701 //
2702 // 0=walking/check input
2703 // 1=jump up
2704 // 2=jump left
2705 //
2706 ///////////////////////////////////////////////////////////////
2707 void DoConvLeft(int input)
2708 {
2709 switch( cCONVm)
2710 {
2711 //------------------------------------------------------------------------------
2712 case 0:
2713 if(input==4)
2714 {
2715 cCONVm=2;
2716 cWILLYj=0;
2717 cWILLYfall=0;
2718 cWILLYjs=0;
2719 DoWillyLeftConv();
2720 DoWillyJumpConv();
2721 }
2722 else
2723 {
2724 if(input==5)
2725 {
2726 cCONVm=2;
2727 cWILLYj=0;
2728 cWILLYjs=0;
2729 DoWillyLeftConv();
2730 DoWillyJumpConv();
2731 cWILLYfall=0;
2732 }
2733 else
2734 {
2735 if(input==6)
2736 {
2737 cCONVm=2;
2738 cWILLYj=0;
2739 cWILLYjs=0;
2740 DoWillyLeftConv();
2741 DoWillyJumpConv();
2742 cWILLYfall=0;
2743 }
2744 else
2745 {
2746 cWILLYfall=0;
2747 cWILLYjs=0;
2748 if(CheckWillyConv()==0)
2749 {
2750 cWILLYm=0;
2751 }
2752 else
2753 {
2754 DoWillyLeftConv();
2755 if(CheckWillyConv()==0)
2756 cWILLYm=0;
2757 }
2758 }
2759 }
2760 }
2761 break;
2762 //------------------------------------------------------------------------------
2763 case 1:
2764 DoWillyJumpConv();
2765 break;
2766 //------------------------------------------------------------------------------
2767 case 2:
2768 DoWillyLeftConv();
2769 DoWillyJumpConv();
2770 break;
2771
2772 }
2773 }
2774
2775 ///////////////////////////////////////////////////////////////
2776 // On Convayor going Right
2777 //
2778 // 0=walking/check input
2779 // 1=jump up
2780 // 2=jump right
2781 //
2782 ///////////////////////////////////////////////////////////////
2783 void DoConvRight(int input)
2784 {
2785 switch( cCONVm)
2786 {
2787 //------------------------------------------------------------------------------
2788 case 0:
2789 if(input==4)
2790 {
2791 cCONVm=2;
2792 cWILLYj=0;
2793 cWILLYjs=0;
2794 cWILLYfall=0;
2795 DoWillyRightConv();
2796 DoWillyJumpConv();
2797 }
2798 else
2799 {
2800 if(input==5)
2801 {
2802 cCONVm=2;
2803 cWILLYj=0;
2804 DoWillyRightConv();
2805 DoWillyJumpConv();
2806 cWILLYfall=0;
2807 }
2808 else
2809 {
2810 if(input==6)
2811 {
2812 cCONVm=2;
2813 cWILLYj=0;
2814 cWILLYjs=0;
2815 DoWillyRightConv();
2816 DoWillyJumpConv();
2817 cWILLYfall=0;
2818 }
2819 else
2820 {
2821 cWILLYfall=0;
2822 if(CheckWillyConv()==0)
2823 {
2824 cWILLYm=0;
2825 }
2826 else
2827 {
2828 DoWillyRightConv();
2829 if(CheckWillyConv()==0)
2830 cWILLYm=0;
2831 }
2832 }
2833 }
2834 }
2835 break;
2836 //------------------------------------------------------------------------------
2837 case 1:
2838 DoWillyJumpConv();
2839 break;
2840 //------------------------------------------------------------------------------
2841 case 2:
2842 DoWillyRightConv();
2843 DoWillyJumpConv();
2844 break;
2845
2846 }
2847 }
2848 ///////////////////////////////////////////////////////////////
2849 // Do Willy Left
2850 ///////////////////////////////////////////////////////////////
2851 void DoWillyLeftConv(void)
2852 {
2853 int block1,block2,block3;
2854
2855 if(cWILLYd==0)
2856 {
2857 cWILLYd=1;
2858 }
2859 else
2860 {
2861 cWILLYx-=2;
2862
2863 block1=GetBlock(cWILLYx,cWILLYy);
2864 block2=GetBlock(cWILLYx,cWILLYy+8);
2865 block3=GetBlock(cWILLYx,cWILLYy+12);
2866 if((block1==3)||(block2==3)||(block3==3))
2867 {
2868 cWILLYx+=2;
2869 }
2870 }
2871 }
2872 ///////////////////////////////////////////////////////////////
2873 // Do Willy Right
2874 ///////////////////////////////////////////////////////////////
2875 void DoWillyRightConv(void)
2876 {
2877 int block1,block2,block3;
2878
2879 if(cWILLYd==1)
2880 {
2881 cWILLYd=0;
2882 }
2883 else
2884 {
2885 cWILLYx+=2;
2886
2887 block1=GetBlock(cWILLYx+8,cWILLYy);
2888 block2=GetBlock(cWILLYx+8,cWILLYy+8);
2889 block3=GetBlock(cWILLYx+8,cWILLYy+12);
2890 if((block1==3)||(block2==3)||(block3==3))
2891 {
2892 cWILLYx-=2;
2893 }
2894 }
2895 }
2896 ///////////////////////////////////////////////////////////////
2897 // Do Willy Jump
2898 ///////////////////////////////////////////////////////////////
2899 void DoWillyJumpConv(void)
2900 {
2901 int block1,block2;
2902
2903 if(cWILLYj<8)
2904 {
2905 cWILLYy-=cWILLYjp[cWILLYj];
2906
2907 block1=GetBlock(cWILLYx,cWILLYy);
2908 block2=GetBlock(cWILLYx+8,cWILLYy);
2909 if((block1==3)||(block2==3))
2910 {
2911 cWILLYm=4;
2912 cWILLYjs=0;
2913 DoWillyFall();
2914 }
2915 }
2916 else
2917 {
2918
2919 if(cWILLYj>11)
2920 {
2921 if((cWILLYy&7)==0)
2922 {
2923 block1=GetBlock(cWILLYx,cWILLYy+16);
2924 block2=GetBlock(cWILLYx+8,cWILLYy+16);
2925 if((block1!=0)||(block2!=0))
2926 {
2927 if((block1==7)||(block2==7))
2928 {
2929 cWILLYm=5;
2930 cCONVm=0;
2931 cWILLYy&=248;
2932 }
2933 else
2934 {
2935 cWILLYm=0;
2936 cWILLYy&=248;
2937 }
2938 }
2939 else
2940 {
2941 cWILLYy+=cWILLYjp[cWILLYj];
2942 }
2943 }
2944 else
2945 {
2946 cWILLYy+=cWILLYjp[cWILLYj];
2947 }
2948
2949 }
2950 else
2951 {
2952 cWILLYy+=cWILLYjp[cWILLYj];
2953 }
2954
2955
2956 if(cWILLYj>12)
2957 {
2958 cWILLYfall+=cWILLYjp[cWILLYj];
2959 }
2960 }
2961
2962 cWILLYj++;
2963 if(cWILLYj==18)
2964 {
2965 if(CheckWillyConv()==0)
2966 {
2967 cWILLYm=0;
2968 }
2969 else
2970 {
2971 cCONVm=0;
2972 }
2973 }
2974
2975 if(cWILLYj<10)
2976 {
2977 cWILLYjs++;
2978 }
2979
2980 if(cWILLYj>9)
2981 {
2982 cWILLYjs--;
2983 }
2984
2985 MIDASplaySample(wav,6,255,16384+(cWILLYjs*1500),64,MIDAS_PAN_MIDDLE);
2986
2987 if(cWILLYy>104)
2988 {
2989 //cWILLYy=104;
2990 cWILLYm=4;
2991 DoWillyFall();
2992 }
2993
2994 }
2995
2996
2997 ///////////////////////////////////////////////////////////////
2998 // Do Death
2999 ///////////////////////////////////////////////////////////////
3000 void DoDeath(void)
3001 {
3002 GAMEm=2;
3003 DEATHm=0;
3004 DEATHc=0;
3005
3006 MIDASstopModule(modon);
3007 modon=0;
3008
3009 MIDASplaySample(die,7,512,22050,64,MIDAS_PAN_MIDDLE);
3010
3011 }
3012
3013
3014
Manic Miner PC Linux version