API tools faq
paste
ZoriaRPG

Game Over Menu v1.4 [2.55]

ZoriaRPG
Oct 26th, 2018
527
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 18.90 KB | None | 0 0
raw download clone embed print report
  1. ///////////////////////////////////////
  2. /// Custom Game Over and F6 Screens ///
  3. /// v1.4 for ZC 2.55                ///
  4. /// 24th October, 2018              ///
  5. /// By: ZoriaRPG                    ///
  6. ///////////////////////////////////////
  7.  
  8. //v1.4 : Added CONTINUE option to both screens. The user can enable or disable this.
  9.  
  10.  
  11. import "std.zh"
  12.  
  13. typedef const int define;
  14. typedef const int config;
  15.  
  16. define ON = 1;
  17. define OFF = 0;
  18. define YES = 1;
  19. define NO = 0;
  20.  
  21. script typedef ffc namespace;
  22.  
  23. namespace script F6
  24. {
  25. define SELECTION_SAVE = 1;
  26. define SELECTION_RETRY = 2;
  27. define SELECTION_CANCEL = 3;
  28.  
  29. config ALLOW_F6_CONTINUE = YES;
  30.    
  31. config F6MIDI = -3;
  32.    
  33.     void run(){}
  34.     const int FREEZE = 504; //Freeze Combo
  35.     void freeze(int state)
  36.     {
  37.         ffc f = Screen->LoadFFC(32);
  38.         if ( state ) f->Data = FREEZE;
  39.         else f->Data = 0;
  40.     }
  41.        
  42.     //if ( F6.press() ) { F6.optiona(); }
  43.     bool press()
  44.     {
  45.         TraceS("User pressed F6"); TraceNL();
  46.         if ( Input->ReadKey[46+6] ) return true;
  47.         return false;
  48.     }
  49.     void draw(ALLOW_F6_CONTINUE) { gameover.draw(true, ALLOW_F6_CONTINUE); }
  50.     int choice(ALLOW_F6_CONTINUE) { return gameover.get_choice(ALLOW_F6_CONTINUE); }
  51.    
  52.     void options()
  53.     {
  54.         Game->DisableActiveSubscreen = true;
  55.         freeze(ON);
  56.         int oldmidi = Game->GetMIDI();
  57.         Game->PlayMIDI(F6MIDI);
  58.         while(menu(CONTINUE_HP, YES, CONTINUE_MP, YES))
  59.         {
  60.             draw();
  61.             Waitdraw();
  62.             Waitframe();
  63.         }
  64.         Game->PlayMIDI(oldmidi);
  65.         freeze(OFF);
  66.        
  67.         Link->PressStart = false; Link->InputStart = false;
  68.        
  69.     }
  70.     //for HP, 0 will preserve Link's HP before continuing. For MAGIC, use -1 to do this.
  71.     bool menu(int cont_hp, bool hp_is_percent, int cont_mp, bool mp_is_percent)
  72.     {
  73.         int sel = choice();
  74.         switch(sel)
  75.         {
  76.             case SELECTION_SAVE:
  77.             {
  78.                 Game->Save(); return false;
  79.             }
  80.             case SELECTION_RETRY:
  81.             {
  82.                 freeze(OFF);
  83.                 Game->End(); return false;
  84.             }
  85.             case SELECTION_CONTINUE:
  86.             {
  87.                 freeze(OFF);
  88.                 return continue(int cont_hp, bool hp_is_percent, int cont_mp, bool mp_is_percent);
  89.             }
  90.             case SELECTION_CANCEL:
  91.             {
  92.                 return false;
  93.             }
  94.         }
  95.         return true;
  96.     }
  97.     bool continue(int hp, bool percent, int mp, bool percent)
  98.     {
  99.         //int entrancedmap = Game->LastEntranceDMap;
  100.         //Replace with WarpEx()
  101.         //Link->Warp(Game->GetCurDMap(), Game->DMapContinue[Game->GetCurDMap()]);
  102.         Link->Warp(Game->LastEntranceDMap Game->LastEntranceScreen);
  103.         if ( hp > 0 ) Link->HP = ( Cond(percent, Link->MaxHP*(hp/100), hp) );
  104.         if ( mp > -1 ) Link->MP = ( Cond(percent, Link->MaxMP*(mp/100), hp) );
  105.         Link->Dir = DIR_DOWN;
  106.         Link->Action = NONE;
  107.         return false;
  108.     }
  109.    
  110. }
  111.  
  112. namespace script gameover
  113. {
  114.  
  115. config ALLOW_DEATH_CONTINUE = YES;
  116.  
  117.     // Sounds and MIDIs
  118. config SFX_WINKOUT          = 38; //Sound to play during wink-out animation.
  119. config SFX_LINKDEATH            = 28; //Sound to play when Link dies.
  120. config SFX_GAMEOVERSCREEN_CURSOR    = 6;  //Sound to play when the player moves the game over cursor.
  121. config SFX_GAMEOVERSCREEN_SELECTION     = 44; //Sound to play when the user selects a game over menu option.
  122. config MIDI_GAMEOVER            = -4; //MIDI to play on Game Over screen.
  123.     //Defaults: -3 is the internal Game Over, -2 is Level 9, -1 is Overworld
  124.  
  125. // Sprites (Weapons/Misc)
  126. config SPR_DEATH        = 88; //Sprite of Link Spinning
  127. config SPR_DEATH_WINKOUT    = 89; //Sprite of wink-out
  128. // Sprite Timing
  129. config END_DEATH_SPIN       = 40; //Frames to display death spin animation.
  130. config END_WINKOUT      = 10; //Frames to display wink-out animation.
  131.  
  132. // Other Graphics and Colours
  133. config TILE_SAVECURSOR      = 20;
  134. config TILE_SAVECURSOR_CSET     = 1;    //CSet for minitile cursor.
  135. config BLACK            = 0x0F; //Black in the current palette
  136. config RED          = 0x93; //Red in the current palette
  137. config WHITE            = 0x01; //White in the current palette
  138.  
  139. // Menu Object Positions and Settings
  140. config DONT_SAVE_X      = 102; //X position of the RETRY string.
  141. config SAVE_X           = 102; //X position of the SAVE string.
  142. config DONT_SAVE_Y      = 68;  //Y position of the RETRY string.
  143. config CANCEL_Y         = 68+14;  //Y position of the CANCEL string.
  144. config CONTINUE_Y       = 68+28;  //Y position of the CONTINUE string.
  145. config SAVE_Y           = 54;  //X position of the SAVE string.
  146. config CURSOR_OFFSET        = 26;  //X offset of the cursor from the text.
  147.  
  148. //Global Variables and Arrays
  149.  
  150. //Indices for values[]
  151. define MENU_SEL_STATE       = 0; //The current selected menu option.
  152. define MENU_SEL_POS_X       = 1; //Stores where to draw menu selector.
  153. define MENU_SEL_POS_Y       = 2; //Stores where to draw menu selector.
  154. define DEATH_LX         = 3; //Cache of Link's last X position before death.
  155. define DEATH_LY         = 4; //Cache of Link's last Y position before death.
  156. define DEATHFRAME       = 5; //Timer for death animations.
  157. define QUIT             = 6; //The game 'QUIT' type, SAVE or RETRY
  158.  
  159. //gameover.QUIT Types
  160. define quitSAVE         = 1;
  161. define quitRETRY        = 2;
  162. define quitCONTINUE         = 4;
  163.  
  164. //Menu Selection types
  165. define SELECTION_SAVE       = 1;
  166. define SELECTION_RETRY      = 2;
  167. define SELECTION_CANCEL     = 3;
  168. define SELECTION_CONTINUE   = 4;
  169.  
  170.     int values[8] = {1,SAVE_Y,DONT_SAVE_Y, 0,0};
  171.     void run(){}
  172.     bool check()
  173.     {
  174.         if ( Link->HP < 1 )
  175.         {
  176.             Link->HP = 1;
  177.             Link->Invisible = true;
  178.             Link->CollDetection = false;
  179.             values[DEATH_LX] = Link->X;
  180.             values[DEATH_LY] = Link->Y;
  181.             return true;
  182.         }
  183.         return false;
  184.     }
  185.     void clean_up()
  186.     {
  187.         int q;
  188.         if ( Screen->NumNPCs() )
  189.         {
  190.             for ( q = Screen->NumNPCs(); q > 0; --q )
  191.             {
  192.                 npc n = Screen->LoadNPC(q); Remove(n);
  193.             }
  194.         }
  195.         if ( Screen->NumLWeapons() )
  196.         {
  197.             for ( q = Screen->NumLWeapons(); q > 0; --q )
  198.             { lweapon n = Screen->LoadLWeapon(q); Remove(n); }
  199.         }
  200.         if ( Screen->NumEWeapons() )
  201.         {
  202.             for ( q = Screen->NumEWeapons(); q > 0; --q )
  203.             { eweapon n = Screen->LoadEWeapon(q); Remove(n); }
  204.         }
  205.         if ( Screen->NumItems() )
  206.         {
  207.             for ( q = Screen->NumItems(); q > 0; --q )
  208.             { item n = Screen->LoadItem(q); Remove(n); }
  209.         }
  210.         //clear all ffcs
  211.         for ( q = 1; q < 33; ++q )
  212.         {
  213.             ffc f = Screen->LoadFFC(q);
  214.             f->Data = 0; f->Script = 0;
  215.         }
  216.     }
  217.     void draw(bool cancel, bool continue)
  218.     {
  219.         //Draw black background with Rectangle()
  220.         Screen->Rectangle(5,0,0,256,256,BLACK,100, 0,0,0,true,128);
  221.         if ( !cancel )
  222.         {
  223.             if ( !continue )
  224.             {
  225.                 switch ( values[MENU_SEL_STATE] )
  226.                 {
  227.                     case SELECTION_SAVE:
  228.                     {
  229.                         //int ss1[]="Drawing cursor and text.";
  230.                         //TraceS(ss1);
  231.                         Screen->FastTile(6,SAVE_X-CURSOR_OFFSET, SAVE_Y, TILE_SAVECURSOR, TILE_SAVECURSOR_CSET,128);
  232.                         //draw strings, red for selected
  233.                         Screen->DrawString(6,SAVE_X,SAVE_Y,0,RED, -1,0,"SAVE",128);
  234.                         Screen->DrawString(6,DONT_SAVE_X,DONT_SAVE_Y,0,WHITE, -1,0,"RETRY",128);
  235.                         break;
  236.                     }
  237.                     case SELECTION_RETRY:
  238.                     {
  239.                         //Draw cursor
  240.                         Screen->FastTile(6,DONT_SAVE_X-CURSOR_OFFSET, DONT_SAVE_Y, TILE_SAVECURSOR, TILE_SAVECURSOR_CSET,128);
  241.                         //draw strings, red for selected
  242.                         Screen->DrawString(6,SAVE_X,SAVE_Y,0,WHITE, -1,0,"SAVE",128);
  243.                         Screen->DrawString(6,DONT_SAVE_X,DONT_SAVE_Y,0,RED, -1,0,"RETRY",128);
  244.                         break
  245.                     }
  246.                     default: break;
  247.                 }
  248.             }
  249.             else
  250.             {
  251.                 switch ( values[MENU_SEL_STATE] )
  252.                 {
  253.                     case SELECTION_SAVE:
  254.                     {
  255.                         //int ss1[]="Drawing cursor and text.";
  256.                         //TraceS(ss1);
  257.                         Screen->FastTile(6,SAVE_X-CURSOR_OFFSET, SAVE_Y, TILE_SAVECURSOR, TILE_SAVECURSOR_CSET,128);
  258.                         //draw strings, red for selected
  259.                         Screen->DrawString(6,SAVE_X,SAVE_Y,0,RED, -1,0,"SAVE",128);
  260.                         Screen->DrawString(6,DONT_SAVE_X,DONT_SAVE_Y,0,WHITE, -1,0,"CONTINUE",128);
  261.                         Screen->DrawString(6,DONT_SAVE_X,CANCEL_Y,0,WHITE, -1,0,"RETRY",128);
  262.                         break;
  263.                     }
  264.                     case SELECTION_CONTINUE:
  265.                     {
  266.                         //int ss1[]="Drawing cursor and text.";
  267.                         //TraceS(ss1);
  268.                         Screen->FastTile(6,SAVE_X-CURSOR_OFFSET, DONT_SAVE_Y, TILE_SAVECURSOR, TILE_SAVECURSOR_CSET,128);
  269.                         //draw strings, red for selected
  270.                         Screen->DrawString(6,SAVE_X,SAVE_Y,0,RED, -1,0,"SAVE",128);
  271.                         Screen->DrawString(6,DONT_SAVE_X,DONT_SAVE_Y,0,WHITE, -1,0,"CONTINUE",128);
  272.                         Screen->DrawString(6,DONT_SAVE_X,CANCEL_Y,0,WHITE, -1,0,"RETRY",128);
  273.                         break;
  274.                     }
  275.                     case SELECTION_RETRY:
  276.                     {
  277.                         //Draw cursor
  278.                         Screen->FastTile(6,DONT_SAVE_X-CURSOR_OFFSET, CANCEL_Y, TILE_SAVECURSOR, TILE_SAVECURSOR_CSET,128);
  279.                         //draw strings, red for selected
  280.                         Screen->DrawString(6,SAVE_X,SAVE_Y,0,WHITE, -1,0,"SAVE",128);
  281.                         Screen->DrawString(6,DONT_SAVE_X,DONT_SAVE_Y,0,WHITE, -1,0,"CONTINUE",128);
  282.                         Screen->DrawString(6,DONT_SAVE_X,CANCEL_Y,0,RED, -1,0,"RETRY",128);
  283.                         break
  284.                     }
  285.                     default: break;
  286.                 }
  287.            
  288.            
  289.            
  290.             }
  291.         }
  292.         else
  293.         {
  294.             if ( !continue )
  295.             {
  296.                 switch(values[MENU_SEL_STATE])
  297.                 {
  298.                    
  299.                    
  300.                     case SELECTION_SAVE:
  301.                     {
  302.                         //int ss1[]="Drawing cursor and text.";
  303.                         //TraceS(ss1);
  304.                         Screen->FastTile(6,SAVE_X-CURSOR_OFFSET, SAVE_Y, TILE_SAVECURSOR, TILE_SAVECURSOR_CSET,128);
  305.                         //draw strings, red for selected
  306.                         Screen->DrawString(6,SAVE_X,SAVE_Y,0,RED, -1,0,"SAVE",128);
  307.                         Screen->DrawString(6,DONT_SAVE_X,DONT_SAVE_Y,0,WHITE, -1,0,"RETRY",128);
  308.                         Screen->DrawString(6,DONT_SAVE_X,CANCEL_Y,0,WHITE, -1,0,"CANCEL",128);
  309.                         break;
  310.                     }
  311.                     case SELECTION_RETRY:
  312.                     {
  313.                         //Draw cursor
  314.                         Screen->FastTile(6,DONT_SAVE_X-CURSOR_OFFSET, DONT_SAVE_Y, TILE_SAVECURSOR, TILE_SAVECURSOR_CSET,128);
  315.                         //draw strings, red for selected
  316.                         Screen->DrawString(6,SAVE_X,SAVE_Y,0,WHITE, -1,0,"SAVE",128);
  317.                         Screen->DrawString(6,DONT_SAVE_X,DONT_SAVE_Y,0,RED, -1,0,"RETRY",128);
  318.                         Screen->DrawString(6,DONT_SAVE_X,CANCEL_Y,0,WHITE, -1,0,"CANCEL",128);
  319.                         break;
  320.                     }
  321.                     case SELECTION_CANCEL:
  322.                     {
  323.                         //Draw cursor
  324.                         Screen->FastTile(6,DONT_SAVE_X-CURSOR_OFFSET, CANCEL_Y, TILE_SAVECURSOR, TILE_SAVECURSOR_CSET,128);
  325.                         //draw strings, red for selected
  326.                         Screen->DrawString(6,SAVE_X,SAVE_Y,0,WHITE, -1,0,"SAVE",128);
  327.                         Screen->DrawString(6,DONT_SAVE_X,DONT_SAVE_Y,0,WHITE, -1,0,"RETRY",128);
  328.                         Screen->DrawString(6,DONT_SAVE_X,CANCEL_Y,0,RED, -1,0,"CANCEL",128);
  329.                         break;
  330.                     }
  331.                     default: break;
  332.                    
  333.                 }
  334.             }
  335.             else //allow F6 continue
  336.             {
  337.                 switch(values[MENU_SEL_STATE])
  338.                 {
  339.                    
  340.                     //I'm reusing the positional defines for cancel and continue, and transposing them
  341.                     //to reorder the list. -Z
  342.                    
  343.                     //I should rename these to LIST_1_Y, LIST_2_Y, and so forth.
  344.                     case SELECTION_SAVE:
  345.                     {
  346.                         //int ss1[]="Drawing cursor and text.";
  347.                         //TraceS(ss1);
  348.                         Screen->FastTile(6,SAVE_X-CURSOR_OFFSET, SAVE_Y, TILE_SAVECURSOR, TILE_SAVECURSOR_CSET,128);
  349.                         //draw strings, red for selected
  350.                         Screen->DrawString(6,SAVE_X,SAVE_Y,0,RED, -1,0,"SAVE",128);
  351.                         Screen->DrawString(6,DONT_SAVE_X,DONT_SAVE_Y,0,WHITE, -1,0,"RETRY",128);
  352.                         Screen->DrawString(6,DONT_SAVE_X,CONTINUE_Y,0,WHITE, -1,0,"CANCEL",128);
  353.                         Screen->DrawString(6,DONT_SAVE_X,CANCEL_Y,0,WHITE, -1,0,"CONTINUE",128);
  354.                         break;
  355.                     }
  356.                     case SELECTION_RETRY:
  357.                     {
  358.                         //Draw cursor
  359.                         Screen->FastTile(6,DONT_SAVE_X-CURSOR_OFFSET, DONT_SAVE_Y, TILE_SAVECURSOR, TILE_SAVECURSOR_CSET,128);
  360.                         //draw strings, red for selected
  361.                         Screen->DrawString(6,SAVE_X,SAVE_Y,0,WHITE, -1,0,"SAVE",128);
  362.                         Screen->DrawString(6,DONT_SAVE_X,DONT_SAVE_Y,0,RED, -1,0,"RETRY",128);
  363.                         Screen->DrawString(6,DONT_SAVE_X,CONTINUE_Y,0,WHITE, -1,0,"CANCEL",128);
  364.                         Screen->DrawString(6,DONT_SAVE_X,CANCEL_Y,0,WHITE, -1,0,"CONTINUE",128);
  365.                         break;
  366.                     }
  367.                     case SELECTION_CANCEL:
  368.                     {
  369.                         //Draw cursor
  370.                         Screen->FastTile(6,DONT_SAVE_X-CURSOR_OFFSET, CANCEL_Y, TILE_SAVECURSOR, TILE_SAVECURSOR_CSET,128);
  371.                         //draw strings, red for selected
  372.                         Screen->DrawString(6,SAVE_X,SAVE_Y,0,WHITE, -1,0,"SAVE",128);
  373.                         Screen->DrawString(6,DONT_SAVE_X,DONT_SAVE_Y,0,WHITE, -1,0,"RETRY",128);
  374.                         Screen->DrawString(6,DONT_SAVE_X,CONTINUE_Y,0,RED, -1,0,"CANCEL",128);
  375.                         Screen->DrawString(6,DONT_SAVE_X,CANCEL_Y,0,WHITE, -1,0,"CONTINUE",128);
  376.                         break;
  377.                     }
  378.                     case SELECTION_CONTINUE:
  379.                     {
  380.                         //Draw cursor
  381.                         Screen->FastTile(6,DONT_SAVE_X-CURSOR_OFFSET, CONTINUE_Y, TILE_SAVECURSOR, TILE_SAVECURSOR_CSET,128);
  382.                         //draw strings, red for selected
  383.                         Screen->DrawString(6,SAVE_X,SAVE_Y,0,WHITE, -1,0,"SAVE",128);
  384.                         Screen->DrawString(6,DONT_SAVE_X,DONT_SAVE_Y,0,WHITE, -1,0,"RETRY",128);
  385.                         Screen->DrawString(6,DONT_SAVE_X,CONTINUE_Y,0,WHITE, -1,0,"CANCEL",128);
  386.                         Screen->DrawString(6,DONT_SAVE_X,CANCEL_Y,0,RED, -1,0,"CONTINUE",128);
  387.                         break;
  388.                     }
  389.                     default: break;
  390.                    
  391.                 }
  392.             }
  393.            
  394.         }
  395.     }
  396.     bool choice(bool continue)
  397.     {
  398.         if ( !continue )
  399.         {
  400.             if ( Link->PressDown ) // || Link->PressUp )
  401.             {
  402.                 switch(values[MENU_SEL_STATE])
  403.                 {
  404.                     case SELECTION_SAVE: //save
  405.                         ++values[MENU_SEL_STATE]; break;
  406.                     case SELECTION_RETRY: //retry
  407.                         --values[MENU_SEL_STATE]; break;
  408.                 }
  409.                 Game->PlaySound(SFX_GAMEOVERSCREEN_CURSOR);
  410.                 return true;
  411.             }
  412.             if ( Link->Up )
  413.             {
  414.                 switch(values[MENU_SEL_STATE])
  415.                 {
  416.                     case SELECTION_SAVE: //save
  417.                         --values[MENU_SEL_STATE]; return true;;
  418.                     case SELECTION_RETRY: //retry
  419.                         ++values[MENU_SEL_STATE]; return true;;
  420.                 }
  421.                 Game->PlaySound(SFX_GAMEOVERSCREEN_CURSOR);
  422.                 return true;
  423.             }
  424.         }
  425.         else //save, continue, retry
  426.         {
  427.             if ( Link->PressDown ) // || Link->PressUp )
  428.             {
  429.                 switch(values[MENU_SEL_STATE])
  430.                 {
  431.                     case SELECTION_SAVE: //save
  432.                         values[MENU_SEL_STATE] = SELECTION_CONTINUE; break;
  433.                     case SELECTION_CONTINUE: //save
  434.                         values[MENU_SEL_STATE] = SELECTION_RETRY; break;
  435.                     case SELECTION_RETRY: //retry
  436.                         values[MENU_SEL_STATE] = SELECTION_SAVE; break;
  437.                 }
  438.                 Game->PlaySound(SFX_GAMEOVERSCREEN_CURSOR);
  439.                 return true;
  440.             }
  441.             if ( Link->PressUp )
  442.             {
  443.                 switch(values[MENU_SEL_STATE])
  444.                 {
  445.                     case SELECTION_SAVE: //save
  446.                         values[MENU_SEL_STATE] = SELECTION_RETRY; break;
  447.                     case SELECTION_CONTINUE: //save
  448.                         values[MENU_SEL_STATE] = SELECTION_SAVE; break;
  449.                     case SELECTION_RETRY: //retry
  450.                         values[MENU_SEL_STATE] = SELECTION_CONTINUE; break;
  451.                 }
  452.                 Game->PlaySound(SFX_GAMEOVERSCREEN_CURSOR);
  453.                 return true;
  454.             }
  455.         }
  456.         if ( Link->PressStart )
  457.         {
  458.             Game->PlaySound(SFX_GAMEOVERSCREEN_SELECTION);
  459.             if ( values[MENU_SEL_STATE] ) values[QUIT] = quitSAVE;
  460.             else values[QUIT] = quitRETRY; //no save
  461.             return false;
  462.         }
  463.         return true;
  464.     }
  465.    
  466.    
  467.     int get_choice(bool continue)
  468.     {
  469.         if ( !continue )
  470.         {
  471.             if ( Link->PressDown )
  472.             {
  473.                 Game->PlaySound(SFX_GAMEOVERSCREEN_CURSOR);
  474.                 switch(values[MENU_SEL_STATE])
  475.                 {
  476.                     case SELECTION_SAVE: //save
  477.                         ++values[MENU_SEL_STATE]; break;
  478.                     case SELECTION_RETRY: //retry
  479.                         ++values[MENU_SEL_STATE]; break;
  480.                     case SELECTION_CANCEL: //3
  481.                         values[MENU_SEL_STATE] = 1; break;
  482.                     default: //cance;
  483.                         values[MENU_SEL_STATE] = 0; break;
  484.                 }
  485.             }
  486.             if ( Link->PressUp )
  487.             {
  488.                 Game->PlaySound(SFX_GAMEOVERSCREEN_CURSOR);
  489.                 switch(values[MENU_SEL_STATE])
  490.                 {
  491.                     case 1: //save
  492.                         values[MENU_SEL_STATE] = 3; break;
  493.                     case 2: //retry
  494.                         --values[MENU_SEL_STATE] ; break;
  495.                     case SELECTION_CANCEL: //3
  496.                         --values[MENU_SEL_STATE] ; break;
  497.                     default: //cance;
  498.                         values[MENU_SEL_STATE] = 0; break;
  499.                 }
  500.             }      
  501.         }
  502.         else //allow continue
  503.         {
  504.             if ( Link->PressDown )
  505.             {
  506.                 Game->PlaySound(SFX_GAMEOVERSCREEN_CURSOR);
  507.                 switch(values[MENU_SEL_STATE])
  508.                 {
  509.                     case SELECTION_SAVE: //save
  510.                         ++values[MENU_SEL_STATE]; break;
  511.                     case SELECTION_RETRY: //retry
  512.                         ++values[MENU_SEL_STATE]; break;
  513.                     case SELECTION_CANCEL: //3
  514.                         ++values[MENU_SEL_STATE] = 1; break;
  515.                     case SELECTION_CONTINUE: //3
  516.                         values[MENU_SEL_STATE] = 1; break;
  517.                     default: //cance;
  518.                         values[MENU_SEL_STATE] = 0; break;
  519.                 }
  520.             }
  521.             if ( Link->PressUp )
  522.             {
  523.                 Game->PlaySound(SFX_GAMEOVERSCREEN_CURSOR);
  524.                 switch(values[MENU_SEL_STATE])
  525.                 {
  526.                     case 1: //save
  527.                         values[MENU_SEL_STATE] = 4; break;
  528.                     case 2: //retry
  529.                         --values[MENU_SEL_STATE]; break;
  530.                     case SELECTION_CANCEL: //3
  531.                         --values[MENU_SEL_STATE]; break;
  532.                     case SELECTION_CONTINUE: //3
  533.                         --values[MENU_SEL_STATE]; break;
  534.                     default: //cance;
  535.                         values[MENU_SEL_STATE] = 0; break;
  536.                 }
  537.             }  
  538.         }
  539.         if ( Link->PressStart )
  540.         {
  541.             Game->PlaySound(SFX_GAMEOVERSCREEN_SELECTION);
  542.             int ret = values[MENU_SEL_STATE];
  543.             values[MENU_SEL_STATE] = 1;
  544.             return ret;
  545.         }
  546.     }
  547.     void animation()
  548.     {
  549.     if ( values[DEATHFRAME] == 0 ) Game->PlaySound(SFX_LINKDEATH);
  550.         lweapon death = Screen->CreateLWeapon(LW_SPARKLE);
  551.        
  552.         death->UseSprite(SPR_DEATH);
  553.         death->X = values[DEATH_LX];
  554.         death->Y = values[DEATH_LY];
  555.  
  556.         while ( values[DEATHFRAME] < END_DEATH_SPIN )
  557.         {
  558.             ++values[DEATHFRAME];
  559.             //spin Link around by drawing his tiles, then make the wink out.
  560.             NoAction(); Waitdraw(); Waitframe();
  561.         }
  562.         Remove(death);
  563.         Game->PlaySound(SFX_WINKOUT);
  564.         lweapon death2 = Screen->CreateLWeapon(LW_SPARKLE);
  565.         death2->UseSprite(SPR_DEATH_WINKOUT);
  566.         death2->X = values[DEATH_LX];
  567.         death2->Y = values[DEATH_LY];
  568.         while ( values[DEATHFRAME] < END_DEATH_SPIN+END_WINKOUT )
  569.         {
  570.             ++values[DEATHFRAME];
  571.             //wink-out
  572.             NoAction();  Waitdraw(); Waitframe();
  573.         }
  574.         Remove(death2);
  575.     }
  576. }
  577.  
  578.  
  579. //Global Active Script
  580. global script noF6
  581. {
  582.     void run()
  583.     {
  584.         while(true)
  585.         {
  586.             //Normal pre-waitdraw functions go here.
  587.        
  588.             //UpdateGhostZH1();
  589.            
  590.             //Put any health refull code above this!
  591.             //Run the check to see if Link is dying...
  592.             if ( F6.press() ) { Game->DisableActiveSubscreen = false; F6.options(); }
  593.             if ( gameover.check() ) break; //LAST before Waitdraw()
  594.             Waitdraw();
  595.            
  596.             //Normal post-waitdraw functions go here.
  597.            
  598.             //UpdateGhostZH2();
  599.            
  600.             Waitframe();
  601.         }
  602.         while(!gameover.values[gameover.QUIT])
  603.         {
  604.             //gameover.values[gameover.DEATH_LX] = Link->X;
  605.             //gameover.values[gameover.DEATH_LY] = Link->Y;
  606.             //Set game music to a silent MIDI.
  607.  
  608.             Link->HP = Link->MaxHP;
  609.             Link->Invisible = true;
  610.             Link->CollDetection = false;
  611.             //Clean up screen objects
  612.             gameover.clean_up();
  613.             //Do Link Death animation
  614.             gameover.animation();
  615.            
  616.             bool menu = true;
  617.             Game->PlayMIDI(gameover.MIDI_GAMEOVER);//Play game over midi.
  618.             Game->DisableActiveSubscreen = true;   
  619.            
  620.             while(menu) //menu loop
  621.             {
  622.                 //    GAME OVER SCREEN
  623.                 gameover.draw(false);
  624.                 menu = gameover.choice(gameover.ALLOW_DEATH_CONTINUE);
  625.                 Waitdraw();
  626.                 Waitframe();
  627.             }
  628.             Waitdraw(); Waitframe();
  629.         }
  630.         switch(gameover.values[gameover.QUIT])
  631.         {
  632.             case gameover.quitSAVE:
  633.             {
  634.                 ++Game->NumDeaths;
  635.                 Game->Save();
  636.                 Game->End();
  637.                 break;
  638.             }
  639.             case quitRETRY:
  640.             {
  641.                 Game->End(); //Retry
  642.                 break;
  643.             }
  644.             case quitCONTINUE:
  645.             {
  646.                 F6.continue(F6.CONTINUE_HP, YES, F6.CONTINUE_MP, YES);
  647.                 break;
  648.             }
  649.             default: break;
  650.         }
  651.     }
  652. }
  653.  
  654. global script OnExit
  655. {
  656.     void run()
  657.     {
  658.         Link->Invisible = false;
  659.     }
  660. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!