ZoriaRPG

HP Change Display, v0.10

Aug 19th, 2020
1,324
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. ///////////////////////////
  2. // RPG-esque HP Display  //
  3. // v0.10                 //
  4. // 20th August, 2020     //
  5. // For ZC 2.55 Alpha 80+ //
  6. // By: ZoriaRPG          //
  7. ///////////////////////////
  8.  
  9. namespace hphealth
  10. {
  11.     const int TEMPLIFESPAN_SPRITE = 1;
  12.     enum colourtype { cNONE, cWHITE, cGREY, cBLUE, cRED = 0x81 };
  13.    
  14.     const int OLDHP_INDX = 19;
  15.     const int ORIGHP_INDX = 25; //lanmola
  16.     const int OLDHP_DIFF = 20;
  17.     const int SPAWN_CLK = 21;
  18.     const int DRAW_CLK = 22;
  19.     const int INITIALISED = 23;
  20.     const int SPAWNCLKDUR = 60;
  21.     const int HPCLOCKDUR = 10;
  22.     const int CREATEDSPR = 24;
  23.  
  24.     const int DMG_COLOUR = cRED;
  25.     const int DMG_OUTLINE = cWHITE;
  26.     const int HEAL_OUTLINE = cWHITE;
  27.     const int HEAL_COLOUR = cBLUE;
  28.  
  29.     const int DRAW_LAYER = 6;
  30.     const int XOFS = -4;
  31.     const int YOFS = -4;
  32.     const int DUMMY_SPRITE_ID = 255;
  33.     const int DUMMY_SPRITE_OTILE = 214240;
  34.     const int DUMMY_SPRITE_FRAMES = 1;
  35.     const int DUMMY_SPRITE_SPD = 16;
  36.     const int DUMMY_AMOUNT = 30;
  37.    
  38.     void init_dummy_sprite()
  39.     {
  40.         spritedata sd = Game->LoadSpriteData(DUMMY_SPRITE_ID);
  41.         sd->Tile = DUMMY_SPRITE_OTILE;
  42.         sd->Frames = DUMMY_SPRITE_FRAMES;
  43.         sd->Speed = DUMMY_SPRITE_SPD;
  44.     }
  45.        
  46.        
  47.  
  48.     global script test
  49.     {
  50.         void run()
  51.         {
  52.             init_dummy_sprite();
  53.             while(1)
  54.             {
  55.                 for ( int q = Screen->NumNPCs(); q > 0; --q )
  56.                 {
  57.                     npc n = Screen->LoadNPC(q);
  58.                     init_enemy_hp(n);
  59.                     do_npc_hp_clock(n);
  60.                     update_npc_hp(n);
  61.                     draw_npc_hp_change(n);
  62.                 }
  63.                
  64.                 init_hero_hp();
  65.                 do_hero_hp_clock();
  66.                 update_hero_hp();
  67.                 draw_hero_hp_change();
  68.                 Waitdraw();
  69.                
  70.                 Waitframe();
  71.             }
  72.         }
  73.     }
  74.  
  75.  
  76.     void do_npc_hp_clock(npc n)
  77.     {
  78.         ++n->Misc[SPAWN_CLK];
  79.     }
  80.  
  81.     void init_enemy_hp(npc n)
  82.     {
  83.        
  84.         unless ( n->Misc[INITIALISED] )
  85.         {
  86.             if ( n->Family == NPCT_LANMOLA )
  87.             {
  88.                 if ( n->Core )
  89.                 {
  90.                    
  91.                    
  92.                     npcdata nd = Game->LoadNPCData(n->ID);
  93.                     n->Misc[OLDHP_INDX] = nd->HP*nd->Attributes[0]+1; //the spawned enemy has +1
  94.                     n->Misc[INITIALISED] = 1;
  95.                     n->Misc[ORIGHP_INDX] = nd->HP*nd->Attributes[0]-(nd->HP-1);  //the engine shuffles HP, and we use this to avoid displaying that shuffle.
  96.                    
  97.                 }
  98.                
  99.             }
  100.             else if ( n->Family == NPCT_MOLDORM )
  101.             {
  102.                 if ( n->Core )
  103.                 {
  104.                    
  105.                     //find a child
  106.                     printf("molorm UID: %f\n", n->UID);
  107.                     npc child = NULL;
  108.                     for ( int w = Screen->NumNPCs(); w > 0; --w )
  109.                     {
  110.                         child = Screen->LoadNPC(w);
  111.                         if ( child->ParentUID == n->UID ) break;
  112.                     }
  113.                     printf("child uid is %d\n", child->UID);
  114.                     printf("child parentuid is %d\n", child->ParentUID);
  115.                     printf("child id is %d\n", child->ID);
  116.                    
  117.                     if ( child->ParentUID )
  118.                     {
  119.                             n->Misc[INITIALISED] = 1;
  120.                             npcdata nd = Game->LoadNPCData(child->ID); //the core has an ID of 0
  121.                             n->Misc[OLDHP_INDX] = nd->HP*nd->Attributes[0]+1; //the spawned enemy has +1
  122.                             n->Misc[ORIGHP_INDX] = nd->HP-1;  //the engine shuffles HP, and we use this to avoid displaying that shuffle.
  123.                     }
  124.                 }
  125.                 //else printf("Moldorm ParentUID: %d\n", n->ParentUID);
  126.                
  127.                 //printf("n->ID: %d\n",n->ID);
  128.                
  129.             }
  130.            
  131.             else
  132.             {
  133.                 n->Misc[OLDHP_INDX] = n->HP;
  134.                 n->Misc[INITIALISED] = 1;
  135.             }
  136.         }
  137.     }
  138.    
  139.     // Gets the total amount of HP from a lanmola core
  140.     // If used on a semnent, not a core, it returns the UID of the core as a NEGATIVE value.
  141.     int get_lanmola_hp(npc n)
  142.     {
  143.         int totalhp;
  144.                
  145.         if ( n->Core )
  146.         {
  147.             totalhp = n->HP;
  148.             int count;
  149.             // Find its children
  150.             for ( int w = Screen->NumNPCs(); w > 0; --w )
  151.             {
  152.                 npc child = Screen->LoadNPC(w);
  153.                 if ( child->ParentUID == n->UID ) // It is a child of this core
  154.                 {
  155.                     ++count;
  156.                     totalhp += child->HP;
  157.                 }
  158.             }
  159.             return totalhp;
  160.         }
  161.         else
  162.         {
  163.             int uid = n->ParentUID * -1;
  164.             return uid;
  165.         }
  166.        
  167.     }
  168.    
  169.     // Gets the total amount of HP from a moldorm core
  170.     // If used on a semnent, not a core, it returns the UID of the core as a NEGATIVE value.
  171.     int get_moldorm_hp(npc n)
  172.     {
  173.         int totalhp;
  174.                
  175.         if ( n->Core )
  176.         {
  177.             totalhp = n->HP;
  178.             int count;
  179.             // Find its children
  180.             for ( int w = Screen->NumNPCs(); w > 0; --w )
  181.             {
  182.                 npc child = Screen->LoadNPC(w);
  183.                 if ( child->ParentUID == n->UID ) // It is a child of this core
  184.                 {
  185.                     ++count;
  186.                     totalhp += child->HP;
  187.                 }
  188.             }
  189.             return totalhp;
  190.         }
  191.         else
  192.         {
  193.             int uid = n->ParentUID * -1;
  194.             return uid;
  195.         }
  196.        
  197.     }
  198.    
  199.     void update_npc_hp(npc n)
  200.     {
  201.  
  202.        
  203.         if ( n->Family != NPCT_GLEEOK && n->Misc[DRAW_CLK] == 0 && n->HitBy[2] && n->HP != n->Misc[OLDHP_INDX] )
  204.         {
  205.            
  206.             n->Misc[OLDHP_DIFF] = n->HP - n->Misc[OLDHP_INDX];
  207.             n->Misc[DRAW_CLK] = HPCLOCKDUR;
  208.            
  209.         }
  210.         else if ( (n->Family == NPCT_GLEEOK && n->Core) && n->HP != n->Misc[OLDHP_INDX] && n->Misc[DRAW_CLK] == 0 )
  211.         {
  212.             n->Misc[OLDHP_DIFF] = n->HP - n->Misc[OLDHP_INDX];
  213.             n->Misc[DRAW_CLK] = HPCLOCKDUR;
  214.         }
  215.  
  216.         else if ( n->Family == NPCT_LANMOLA && n->Core && n->Misc[DRAW_CLK] == 0 ) ////&& n->HP != n->Misc[OLDHP_INDX]
  217.         {
  218.            
  219.             int totalhp;
  220.                
  221.            
  222.             {
  223.                 totalhp = n->HP;
  224.                 int count;
  225.                 //find its chilren
  226.                 for ( int w = Screen->NumNPCs(); w > 0; --w )
  227.                 {
  228.                     npc child = Screen->LoadNPC(w);
  229.                     if ( child->ParentUID == n->UID ) //it is a child of this core
  230.                     {
  231.                         ++count;
  232.                         totalhp += child->HP;
  233.                     }
  234.                 }
  235.                 if ( totalhp != n->Misc[OLDHP_INDX] )
  236.                 {
  237.                     int dif = totalhp - n->Misc[OLDHP_INDX];
  238.                     if ( dif != (n->Misc[ORIGHP_INDX]*-1) ) //quirk of lanmola spawn
  239.                     {
  240.                         n->Misc[OLDHP_DIFF] = dif;
  241.                         n->Misc[DRAW_CLK] = HPCLOCKDUR;
  242.                     }
  243.                 }
  244.             }
  245.         }
  246.         else if ( n->Family == NPCT_MOLDORM && n->Core && n->Misc[DRAW_CLK] == 0 ) ////&& n->HP != n->Misc[OLDHP_INDX]
  247.         {
  248.             int totalhp;
  249.                
  250.            
  251.             {
  252.                 totalhp = n->HP;
  253.                 int count;
  254.                 //find its chilren
  255.                 for ( int w = Screen->NumNPCs(); w > 0; --w )
  256.                 {
  257.                     npc child = Screen->LoadNPC(w);
  258.                     if ( child->ParentUID == n->UID ) //it is a child of this core
  259.                     {
  260.                         ++count;
  261.                         totalhp += child->HP;
  262.                     }
  263.                 }
  264.                 int dif = totalhp - n->Misc[OLDHP_INDX];
  265.                 int shuffle = n->Misc[ORIGHP_INDX] * -1;
  266.                
  267.                
  268.                 //if ( (dif != shuffle ) && (( totalhp < n->Misc[OLDHP_INDX] ) || (n->Misc[SPAWN_CLK] > 100 && ( totalhp != n->Misc[OLDHP_INDX] ))) ) //cannot show positive HP ue to the engine shuffling it
  269.                 if ( ( totalhp < n->Misc[OLDHP_INDX] ) )//|| (n->Misc[SPAWN_CLK] > 100 && ( totalhp != n->Misc[OLDHP_INDX] )) ) //cannot show positive HP ue to the engine shuffling it
  270.                 {
  271.                     n->Misc[OLDHP_DIFF] = dif;
  272.                     n->Misc[DRAW_CLK] = HPCLOCKDUR;
  273.                 }
  274.             }
  275.         }
  276.        
  277.     }
  278.    
  279.     lweapon script damagedisplay
  280.     {
  281.         void run()
  282.         {
  283.             int buffer[8];
  284.             int buffer2[8];
  285.             itoa(buffer,this->Misc[DUMMY_AMOUNT]);
  286.             if ( this->Misc[DUMMY_AMOUNT] > 0 )
  287.             {
  288.                 buffer2[0] = '+';
  289.             }
  290.             strcat(buffer2, buffer);
  291.             bool flip = 1;
  292.             int clk;
  293.             int origx = this->X;
  294.             while(1)
  295.             {
  296.                 Screen->DrawString
  297.                 (
  298.                     DRAW_LAYER,
  299.                     this->X,
  300.                     this->Y,
  301.                     FONT_Z3SMALL,
  302.                     ((this->Misc[DUMMY_AMOUNT]<0) ? DMG_COLOUR : HEAL_COLOUR),
  303.                     -1,
  304.                     0,
  305.                     buffer2,
  306.                     128,
  307.                     SHD_OUTLINED8,
  308.                     ((this->Misc[DUMMY_AMOUNT]<0) ? DMG_OUTLINE : HEAL_OUTLINE)
  309.                 );
  310.                 this->Y = Clamp((this->Y - 0.25), 0,SCREEN_H-8);
  311.                 //if ( (clk%2) )
  312.                 //{
  313.                 //  if ( flip )
  314.                 //  {
  315.                 //      this->X += 2;
  316.                 //      flip = 0;
  317.                 //  }
  318.                 //  else this->X -= 2;
  319.                 //}
  320.                 //else this->X = origx;
  321.                 ++clk;
  322.                 Waitframe();
  323.             }
  324.         }
  325.     }
  326.  
  327.     void draw_npc_hp_change(npc n)
  328.     {
  329.         if (  n->Misc[SPAWN_CLK] < SPAWNCLKDUR ) return;
  330.         if ( n->Family == NPCT_LANMOLA && n->Misc[OLDHP_DIFF] > 0 ) return; //Lanmolas juggle HP so don't show imbalances being offset.
  331.         if ( --n->Misc[DRAW_CLK] > 0 && n->Misc[OLDHP_DIFF] )
  332.         {
  333.            
  334.             if ( TEMPLIFESPAN_SPRITE )
  335.             {
  336.                 int tmpx, tmpy;
  337.                 unless ( n->Misc[CREATEDSPR] )
  338.                 {
  339.                     int prntuid = n->ParentUID;
  340.                     npc prnt = NULL;
  341.                     if (n->Family == NPCT_MOLDORM )
  342.                     {
  343.                         //find the core
  344.                         prnt = Screen->LoadNPCByUID(n->ParentUID);
  345.                         tmpx = prnt->X;
  346.                         tmpy = prnt->Y;
  347.                     }
  348.                     if ( n->Family == NPCT_LANMOLA && prnt->isValid() )
  349.                     {
  350.                         if ( n->Core )
  351.                         {
  352.                             prnt = n;
  353.                         }
  354.                         else prnt = Screen->LoadNPCByUID(n->ParentUID);
  355.                         tmpx = prnt->X;
  356.                         tmpy = prnt->Y;
  357.                     }
  358.                     else if ( n->Family == NPCT_GLEEOK )
  359.                     {
  360.                         prnt = Screen->LoadNPCByUID(n->ParentUID);
  361.                         tmpx = prnt->X-12;
  362.                         tmpy = prnt->Y-4;
  363.                     }
  364.                     else
  365.                     {
  366.                         tmpx = n->X;
  367.                         tmpy = n->Y;
  368.                     }
  369.                    
  370.                     lweapon dummy = Screen->CreateLWeapon(LW_SPARKLE);
  371.                     dummy->X = Clamp(tmpx + XOFS,0,SCREEN_W-8);
  372.                     dummy->Y = Clamp(tmpy + YOFS,0,SCREEN_H-8);
  373.                     dummy->UseSprite(DUMMY_SPRITE_ID);
  374.                     dummy->HitYOffset = -32768;
  375.                     dummy->Misc[DUMMY_AMOUNT] = n->Misc[OLDHP_DIFF];
  376.                     dummy->Script = Game->GetLWeaponScript("damagedisplay");
  377.                     n->Misc[CREATEDSPR] = 1;
  378.                 }
  379.             }
  380.             else
  381.             {
  382.                 int buffer[8];
  383.                 int buffer2[8];
  384.                 itoa(buffer,n->Misc[OLDHP_DIFF]);
  385.                 if ( n->Misc[OLDHP_DIFF] > 0 )
  386.                 {
  387.                     buffer2[0] = '+';
  388.                 }
  389.                 strcat(buffer2, buffer);
  390.                 Screen->DrawString
  391.                 (
  392.                     DRAW_LAYER,
  393.                     n->X + XOFS,
  394.                     n->Y + YOFS,
  395.                     FONT_Z3SMALL,
  396.                     ((n->Misc[OLDHP_DIFF]<0) ? DMG_COLOUR : HEAL_COLOUR),
  397.                     -1,
  398.                     0,
  399.                     buffer2,
  400.                     128,
  401.                     SHD_OUTLINED8,
  402.                     ((n->Misc[OLDHP_DIFF]<0) ? DMG_OUTLINE : HEAL_OUTLINE)
  403.                 );
  404.             }
  405.         }
  406.         else
  407.         {
  408.             if ( n->Family == NPCT_LANMOLA )
  409.             {
  410.                 n->Misc[DRAW_CLK] = 0;
  411.                 n->Misc[OLDHP_INDX] = get_lanmola_hp(n);
  412.                 n->Misc[CREATEDSPR] = 0;
  413.             }
  414.             else if ( n->Family == NPCT_MOLDORM )
  415.             {
  416.                 n->Misc[DRAW_CLK] = 0;
  417.                 n->Misc[OLDHP_INDX] = get_moldorm_hp(n);
  418.                 n->Misc[CREATEDSPR] = 0;
  419.             }
  420.             else
  421.             {
  422.                 n->Misc[DRAW_CLK] = 0;
  423.                 n->Misc[OLDHP_INDX] = n->HP;
  424.                 n->Misc[CREATEDSPR] = 0;
  425.             }
  426.         }
  427.     }
  428.     void do_hero_hp_clock()
  429.     {
  430.         ++Hero->Misc[SPAWN_CLK];
  431.     }
  432.  
  433.     void init_hero_hp()
  434.     {
  435.         unless ( Hero->Misc[INITIALISED] )
  436.         {
  437.             Hero->Misc[OLDHP_INDX] = Hero->HP;
  438.             Hero->Misc[INITIALISED] = 1;
  439.         }
  440.     }
  441.     void update_hero_hp()
  442.     {
  443.        
  444.         if ( Hero->Misc[DRAW_CLK] == 0 && Hero->HP != Hero->Misc[OLDHP_INDX] )
  445.         {
  446.             Hero->Misc[OLDHP_DIFF] = Hero->HP - Hero->Misc[OLDHP_INDX];
  447.             Hero->Misc[DRAW_CLK] = HPCLOCKDUR;
  448.         }
  449.     }
  450.  
  451.     void draw_hero_hp_change()
  452.     {
  453.         if ( --Hero->Misc[DRAW_CLK] > 0 && Hero->Misc[OLDHP_DIFF] )
  454.         {
  455.            
  456.             int buffer[8];
  457.             int buffer2[8];
  458.            
  459.             itoa(buffer,Hero->Misc[OLDHP_DIFF]);
  460.             if ( Hero->Misc[OLDHP_DIFF] > 0 )
  461.             {
  462.                 buffer2[0] = '+';
  463.             }
  464.             strcat(buffer2, buffer);
  465.            
  466.             Screen->DrawString
  467.             (
  468.                 DRAW_LAYER,
  469.                 Hero->X + XOFS,
  470.                 Hero->Y + YOFS,
  471.                 FONT_Z3SMALL,
  472.                 ((Hero->Misc[OLDHP_DIFF]<0) ? DMG_COLOUR : HEAL_COLOUR),
  473.                 -1,
  474.                 0,
  475.                 buffer2,
  476.                 128,
  477.                 SHD_OUTLINED8,
  478.                 ((Hero->Misc[OLDHP_DIFF]<0) ? DMG_OUTLINE : HEAL_OUTLINE)
  479.             );
  480.         }
  481.         else
  482.         {
  483.             Hero->Misc[DRAW_CLK] = 0;
  484.             Hero->Misc[OLDHP_INDX] = Hero->HP;
  485.         }
  486.     }
  487. }
RAW Paste Data