API tools faq
paste
Advertisement
charleysdrpepper

GS2 Party Mechanics Recoded

charleysdrpepper
Oct 12th, 2016
110
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 22.78 KB | None | 0 0
raw download clone embed print report
  1. #define RGB16(r,g,b)  ((r)+(g<<5)+(b<<10))
  2. register int *r4 asm ("r4"); //One register for manual-use only. Usually used for addresses.
  3. int main() {
  4.     char x,y;  
  5.     unsigned short* Screen = (unsigned short*)0x6000000;
  6.     *(unsigned long*)0x4000000 = 0x403; // mode3, bg2 on
  7.  
  8.     // clear screen, and draw a blue back ground
  9.     for(x = 0; x<240;x++)   //loop through all x
  10.     {
  11.         for(y = 0; y<160; y++)  //loop through all y
  12.         {
  13.             Screen[x+y*240] = RGB16(0,0,31);  
  14.         }
  15.     }
  16.  
  17.     // draw a white HI on the background
  18.     for(x = 20; x<=60; x+=15)
  19.         for(y = 30; y<50; y++)  
  20.             Screen[x+y*240] = RGB16(31,31,31);  
  21.     for (x = 20; x < 35; x++)
  22.         Screen[x+40*240] = RGB16(31,31,31);  
  23.     ((int*)0x02002348)[8] = 888;
  24.     while(1){}  //loop forever
  25. }
  26.  
  27.  
  28. //#define aa         (char*)0x3
  29. #define curParty         (char*)0x02000458 //0x02000240 + 0x218
  30.  
  31. //PARTY MECHANICS!
  32. //NOTE:  Many of these function/variable names may be WIP, so suggestions recommended.
  33. //Public functions should be left alone since they're supposed to be 8 bytes/entry after compiled.
  34. //These functions do mov pc, r4 instead of bx r4... but both do the same things.
  35. int pub() {
  36.     r4=(int*)main; goto *r4;
  37. }
  38.  
  39. void init() { //080AD338
  40.     initPlayerData();
  41.     pub_bootMap(0);
  42. }
  43.  
  44. int getAvailableSummonsAddr(int team) { //080AD348
  45.     if (team == 0) {
  46.         return 0x0200024C;
  47.     } else {
  48.         return pub_getCharAddr(0x83);
  49.     }
  50. }
  51.  
  52. int getAvgLevel() { //080AD360
  53.     int partyAmt = getPartyAmt();
  54.     int avgLevel = 0;
  55.     if (partyAmt != 0) {
  56.         char* a = curParty;
  57.         int i = partyAmt;
  58.         do {
  59.             avgLevel += *(char*)(pub_getCharAddr(*a++) + 0xF);
  60.         } while (--i != 0);
  61.         avgLevel = pub_division(avgLevel, partyAmt);
  62.     }
  63.     return avgLevel;
  64. }
  65.  
  66. int getEnemyStatsAddr(int index) { //080AD360
  67.     index -= 8;
  68.     if ((unsigned int)index >= 0x3E8) { index = 0; }
  69.     return 0x080B9E7C + (index * 0x4C);
  70. }
  71.  
  72. void copyBytes(int addr1, int addr2, int size, int direction) { //080AD3A8
  73.     //Note: r4 is used in the original game, but don't need to use it...
  74.     if (direction != 0) {
  75.         while (0 < size--) {
  76.             *(char*)addr2++ = *(char*)addr1++;
  77.         }
  78.     } else {
  79.         while (0 < size--) {
  80.             *(char*)addr1++ = *(char*)addr2++;
  81.         }
  82.     }
  83. }
  84. //#define BASEHP    *(short*)(charAddr + 0x10)
  85. //#define BASEPP    *(short*)(charAddr + 0x12)
  86. //#define PSY   (int*)(charAddr + 0x58)
  87. //#define ITEM  (short*)(charAddr + 0xD8)
  88. //#define DJINN (int*)(charAddr + 0xF8)
  89. void calcStats(int charSlot) { //080AD3F8
  90.     int addr = pub_getFreeSpaceW(0x60);
  91.     int charAddr = pub_getCharAddr(charSlot);
  92.    
  93.     //Put all the data in a temp buffer.
  94.     *(int*)(addr + 0x00) = *(short*)(charAddr + 0x10); //Base HP
  95.     *(int*)(addr + 0x04) = *(short*)(charAddr + 0x12); //Base PP
  96.     *(int*)(addr + 0x08) = *(unsigned short*)(charAddr + 0x18); //Base Attack
  97.     *(int*)(addr + 0x0C) = *(unsigned short*)(charAddr + 0x1A); //Base Defense
  98.     *(int*)(addr + 0x10) = *(unsigned short*)(charAddr + 0x1C); //Base Agility
  99.     *(int*)(addr + 0x18) = *(char*)(charAddr + 0x1E); //Base Luck
  100.     *(int*)(addr + 0x1C) = *(char*)(charAddr + 0x1F) & 0xF; //Base Turns
  101.     *(int*)(addr + 0x20) = *(char*)(charAddr + 0x20); //Base HP Recovery
  102.     *(int*)(addr + 0x24) = *(char*)(charAddr + 0x21); //Base PP Recovery
  103.     int i = 3, eAddr1 = charAddr + 0x24, eAddr2 = addr + 0x28;
  104.     do {
  105.         *(int*)(eAddr2) = *(short*)(eAddr1); //Base ePower
  106.         *(int*)(eAddr2 + 0x04) = *(short*)(eAddr1 + 0x2); //Base eResist
  107.         eAddr1 += 4; eAddr2 += 8;
  108.     } while (--i >= 0);
  109.  
  110.     //HP/PP Validation
  111.     int statn = *(short*)(charAddr + 0x34) * *(short*)(charAddr + 0x14);
  112.     if (statn < 0) { statn += 0x3FFF; }
  113.     statn >>= 0xE; // The Current HP of the percent calculation.
  114.     int curStat = *(short*)(charAddr + 0x38);
  115.     if (((statn - curStat) <= 1) || ((curStat - statn) <= 1)) { //If HP is valid, then check PP.
  116.         statn = *(short*)(charAddr + 0x36) * *(short*)(charAddr + 0x16);
  117.         if (statn < 0) { statn += 0x3FFF; }
  118.         statn >>= 0xE; // The Current PP of the percent calculation.
  119.         curStat = *(short*)(charAddr + 0x3A);
  120.     }
  121.     //If HP or PP are invalid, reset both to full.
  122.     if (((statn - curStat) > 1) || ((curStat - statn) > 1)) {
  123.         *(short*)(charAddr + 0x14) = 0x4000;
  124.         *(short*)(charAddr + 0x16) = 0x4000;
  125.         *(short*)(charAddr + 0x38) = *(short*)(charAddr + 0x34);
  126.         *(short*)(charAddr + 0x3A) = *(short*)(charAddr + 0x36);
  127.     }
  128.  
  129.     //Curse-related
  130.     *(char*)(charAddr + 0x130) = *(char*)(charAddr + 0x130) & -4; //0xFC;
  131.     if ((*(char*)(charAddr + 0x130) & 4) != 0) {
  132.         *(char*)(charAddr + 0x130) |= 1;
  133.     }
  134.  
  135.     //Unknown purpose, but gives bonus turn.
  136.     if (*(char*)(charAddr + 0x144) != 0) {
  137.         *(int*)(addr + 0x1C) += 1;
  138.     }
  139.  
  140.     //Unleash Critical Rate
  141.     *(char*)(charAddr + 0x142) = 0;
  142.     if (*(char*)(charAddr + 0x129) != 0) { //Check class for PC, basically.
  143.         //int pcItemAddr = (charAddr + 0xD8);
  144.         //Item
  145.         int pcItemInd = 0;
  146.         do {
  147.             unsigned short item = *(unsigned short*)(charAddr + 0xD8 + (pcItemInd << 1));
  148.             if ((item & 0x0200) != 0) { //If item is equipped.
  149.                 int itemAddr = getItemAddr(item);
  150.                 int itemCursed = *(char*)(itemAddr +0x3) & 0x1;
  151.                 //*(int*)(addr + 0x58) = itemAddr;
  152.                 if (itemCursed != 0) {
  153.                     *(char*)(charAddr + 0x130) |= 3;
  154.                 }
  155.                 *(int*)(addr + 0x08) += *(short*)(itemAddr + 0x8); //Attack
  156.                 *(int*)(addr + 0x0C) += *(signed char*)(itemAddr + 0xA); //Defense
  157.                 int i = 0;
  158.                 do {
  159.                     *(int*)(addr + 0x48) = *(char*)(itemAddr + 0x18 + (i * 4));
  160.                     *(int*)(addr + 0x54) = *(signed char*)(itemAddr + 0x18 + (i * 4) + 1);
  161.                     switch (*(int*)(addr + 0x48)) {
  162.                     case 1:
  163.                         *(int*)(addr + 0x00) += *(int*)(addr + 0x54);
  164.                         break;
  165.                     case 2:
  166.                         *(int*)(addr + 0x20) += *(int*)(addr + 0x54);
  167.                         break;
  168.                     case 3:
  169.                         *(int*)(addr + 0x04) += *(int*)(addr + 0x54);
  170.                         break;
  171.                     case 4:
  172.                         *(int*)(addr + 0x24) += *(int*)(addr + 0x54);
  173.                         break;
  174.                     case 5:
  175.                         *(int*)(addr + 0x10) += *(int*)(addr + 0x54);
  176.                         break;
  177.                     case 6:
  178.                         *(int*)(addr + 0x18) += *(int*)(addr + 0x54);
  179.                         break;
  180.                     case 0xF:
  181.                         *(int*)(addr + 0x28) += *(int*)(addr + 0x54);
  182.                         break;
  183.                     case 0x10:
  184.                         *(int*)(addr + 0x30) += *(int*)(addr + 0x54);
  185.                         break;
  186.                     case 0x11:
  187.                         *(int*)(addr + 0x38) += *(int*)(addr + 0x54);
  188.                         break;
  189.                     case 0x12:
  190.                         *(int*)(addr + 0x40) += *(int*)(addr + 0x54);
  191.                         break;
  192.                     case 0x13:
  193.                         *(int*)(addr + 0x2C) += *(int*)(addr + 0x54);
  194.                         break;
  195.                     case 0x14:
  196.                         *(int*)(addr + 0x34) += *(int*)(addr + 0x54);
  197.                         break;
  198.                     case 0x15:
  199.                         *(int*)(addr + 0x3C) += *(int*)(addr + 0x54);
  200.                         break;
  201.                     case 0x16:
  202.                         *(int*)(addr + 0x44) += *(int*)(addr + 0x54);
  203.                         break;
  204.                     case 0x17:
  205.                         *(char*)(charAddr + 0x142) += *(int*)(addr + 0x54);
  206.                         break;
  207.                     case 0x19: //Curse is removable
  208.                         *(char*)(charAddr + 0x130) |= 8;
  209.                         break;
  210.                     case 0x1A:
  211.                         *(int*)(addr + 0x1C) += *(int*)(addr + 0x54);
  212.                         break;
  213.                     }
  214.                 } while (++i <= 3);
  215.             }
  216.         } while (++pcItemInd <= 0xE);
  217.  
  218.         //Curse-related
  219.         if ((*(char*)(charAddr + 0x130) & 8) != 0) {
  220.             *(char*)(charAddr + 0x130) = *(char*)(charAddr + 0x130) & -0xA; //0xF6;
  221.         }
  222.  
  223.         //Djinn
  224.         int element = 0; //Note: Original game used r4.
  225.         do {
  226.             int djinn = *(int*)(charAddr + 0x108 + element * 4);
  227.             int djinni = 0;
  228.             do {
  229.                 if ((djinn & (1 << djinni)) == 0) { continue; }
  230.                 int djinniAddr = getDjinniAddr(element, djinni);
  231.                 *(int*)(addr + 0x00) += *(signed char*)(djinniAddr + 0x4);
  232.                 *(int*)(addr + 0x04) += *(signed char*)(djinniAddr + 0x5);
  233.                 *(int*)(addr + 0x08) += *(signed char*)(djinniAddr + 0x6);
  234.                 *(int*)(addr + 0x0C) += *(signed char*)(djinniAddr + 0x7);
  235.                 *(int*)(addr + 0x10) += *(signed char*)(djinniAddr + 0x8);
  236.                 *(int*)(addr + 0x18) += *(signed char*)(djinniAddr + 0x9);
  237.             } while (++djinni <= 0x13);
  238.         } while (++element <= 3);
  239.         //int pcDjinnAddr = charAddr;
  240.         //getDjinniAddr();
  241.  
  242.         //Class
  243.         int classAddr = getClassAddr(*(char*)(charAddr + 0x129));
  244.         *(int*)(addr + 0x00) = pub_division(*(int*)(addr + 0x00) * *(char*)(classAddr + 0x8), 10);
  245.         *(int*)(addr + 0x04) = pub_division(*(int*)(addr + 0x04) * *(char*)(classAddr + 0x9), 10);
  246.         *(int*)(addr + 0x08) = pub_division(*(int*)(addr + 0x08) * *(char*)(classAddr + 0xA), 10);
  247.         *(int*)(addr + 0x0C) = pub_division(*(int*)(addr + 0x0C) * *(char*)(classAddr + 0xB), 10);
  248.         *(int*)(addr + 0x10) = pub_division(*(int*)(addr + 0x10) * *(char*)(classAddr + 0xC), 10);
  249.         *(int*)(addr + 0x18) = pub_division(*(int*)(addr + 0x18) * *(char*)(classAddr + 0xD), 10);
  250.  
  251.         //Item
  252.         pcItemInd = 0;
  253.         do {
  254.             unsigned short item = *(unsigned short*)(charAddr + 0xD8 + (pcItemInd << 1));
  255.             if ((item & 0x0200) != 0) { //If item is equipped.
  256.                 int itemAddr = getItemAddr(item);
  257.                 //*(int*)(addr + 0x58) = itemAddr;
  258.                
  259.                 int i = 0;
  260.                 do {
  261.                     *(int*)(addr + 0x48) = *(char*)(itemAddr + 0x18 + (i * 4));
  262.                     *(int*)(addr + 0x54) = *(signed char*)(itemAddr + 0x18 + (i * 4) + 1);
  263.                     switch (*(int*)(addr + 0x48)) {
  264.                     case 7:
  265.                         *(int*)(addr + 0x00) = pub_division(*(int*)(addr + 0x00) * *(int*)(addr + 0x54), 10);
  266.                         break;
  267.                     case 8:
  268.                         *(int*)(addr + 0x20) = pub_division(*(int*)(addr + 0x20) * *(int*)(addr + 0x54), 10);
  269.                         break;
  270.                     case 9:
  271.                         *(int*)(addr + 0x04) = pub_division(*(int*)(addr + 0x04) * *(int*)(addr + 0x54), 10);
  272.                         break;
  273.                     case 0xA:
  274.                         *(int*)(addr + 0x24) = pub_division(*(int*)(addr + 0x24) * *(int*)(addr + 0x54), 10);
  275.                         break;
  276.                     case 0xB:
  277.                         *(int*)(addr + 0x08) = pub_division(*(int*)(addr + 0x08) * *(int*)(addr + 0x54), 10);
  278.                         break;
  279.                     case 0xC:
  280.                         *(int*)(addr + 0x0C) = pub_division(*(int*)(addr + 0x0C) * *(int*)(addr + 0x54), 10);
  281.                         break;
  282.                     case 0xD:
  283.                         *(int*)(addr + 0x10) = pub_division(*(int*)(addr + 0x10) * *(int*)(addr + 0x54), 10);
  284.                         break;
  285.                     case 0xE:
  286.                         *(int*)(addr + 0x18) = pub_division(*(int*)(addr + 0x18) * *(int*)(addr + 0x54), 10);
  287.                         break;
  288.                     }
  289.                 } while (++i <= 3);
  290.             }
  291.         } while (++pcItemInd <= 0xE);
  292.     }
  293.     //Attack Effect Multiplier
  294.     int a = (*(signed char*)(charAddr + 0x133) + 8) * *(int*)(addr + 0x08);
  295.     if (a < 0) { a += 7; }
  296.     *(int*)(addr + 0x08) = a >> 3;
  297.  
  298.     //Defense Effect Multiplier
  299.     a = (*(signed char*)(charAddr + 0x135) + 8) * *(int*)(addr + 0x0C);
  300.     if (a < 0) { a += 7; }
  301.     *(int*)(addr + 0x0C) = a >> 3;
  302.  
  303.     //Agility Effect Multiplier
  304.     a = (*(signed char*)(charAddr + 0x147) + 8) * *(int*)(addr + 0x10);
  305.     if (a < 0) { a += 7; }
  306.     *(int*)(addr + 0x10) = a >> 3;
  307.  
  308.     //Summon Multipliers
  309.     i = 3; eAddr1 = charAddr + 0x12C; eAddr2 = addr + 0x28;
  310.     do {
  311.         a = *(signed char*)(eAddr1);
  312.         *(int*)(eAddr2) = (a * a + a) * 5;
  313.         eAddr1 += 1; eAddr2 += 8;
  314.     } while (--i >= 0);
  315.        
  316.     //Resistance Multiplier
  317.     i = 3; eAddr1 = charAddr + 0x137; eAddr2 = addr + 0x2C;
  318.     do {
  319.         a = *(signed char*)(eAddr1);
  320.         *(int*)(eAddr2) += a * 20;
  321.         eAddr1 += 0; eAddr2 += 8;
  322.     } while (--i >= 0);
  323.  
  324.     //PP Recovery
  325.     if (*(char*)(charAddr + 0x129) != 0) { //Check class for PC, basically.
  326.         int ppr = 0;
  327.         switch (*(unsigned short*)(charAddr + 0x14A)) {
  328.         case 0: case 4:
  329.             ppr = pub_getFlag(0x110);
  330.             break;
  331.         case 1: case 5:
  332.             ppr = pub_getFlag(0x112);
  333.             break;
  334.         case 2: case 6:
  335.             ppr = pub_getFlag(0x113);
  336.             break;
  337.         case 3: case 7:
  338.             ppr = pub_getFlag(0x111);
  339.             break;
  340.         }
  341.         if (ppr != 0) {
  342.             *(int*)(addr + 0x24) += 4;
  343.         }
  344.     }
  345.    
  346.     // Stat Min/Max
  347.     if (*(int*)(addr + 0x08) < 0) { *(int*)(addr + 0x08) = 0; }
  348.     if (*(int*)(addr + 0x08) > 999) { *(int*)(addr + 0x08) = 999; }
  349.     if (*(int*)(addr + 0x0C) < 0) { *(int*)(addr + 0x0C) = 0; }
  350.     if (*(int*)(addr + 0x0C) > 999) { *(int*)(addr + 0x0C) = 999; }
  351.     if (*(int*)(addr + 0x10) < 0) { *(int*)(addr + 0x10) = 0; }
  352.     if (*(int*)(addr + 0x10) > 999) { *(int*)(addr + 0x10) = 999; }
  353.     if (*(int*)(addr + 0x18) < 0) { *(int*)(addr + 0x18) = 0; }
  354.     if (*(int*)(addr + 0x18) > 99) { *(int*)(addr + 0x18) = 99; }
  355.    
  356.     if (*(char*)(charAddr + 0x129) == 0) {
  357.         if (*(int*)(addr + 0x1C) < 0) { *(int*)(addr + 0x1C) = 0; }
  358.         if (*(int*)(addr + 0x1C) > 4) { *(int*)(addr + 0x1C) = 4; }
  359.     } else {
  360.         if (*(int*)(addr + 0x1C) < 0) { *(int*)(addr + 0x1C) = 0; }
  361.         if (*(int*)(addr + 0x1C) > 2) { *(int*)(addr + 0x1C) = 2; }
  362.     }
  363.    
  364.     if (*(int*)(addr + 0x20) < 0) { *(int*)(addr + 0x20) = 0; }
  365.     if (*(int*)(addr + 0x20) > 10000) { *(int*)(addr + 0x20) = 10000; }
  366.     if (*(int*)(addr + 0x24) < 0) { *(int*)(addr + 0x24) = 0; }
  367.     if (*(int*)(addr + 0x24) > 200) { *(int*)(addr + 0x24) = 200; }
  368.    
  369.     i = 3, eAddr2 = addr + 0x28;
  370.     do {
  371.         if (*(int*)(eAddr2) < 0) { *(int*)(eAddr2) = 0; }
  372.         if (*(int*)(eAddr2) > 200) { *(int*)(eAddr2) = 200; }
  373.         if (*(int*)(eAddr2 + 4) < 0) { *(int*)(eAddr2 + 4) = 0; }
  374.         if (*(int*)(eAddr2 + 4) > 200) { *(int*)(eAddr2 + 4) = 200; }
  375.         eAddr2 += 8;
  376.     } while (--i >= 0);
  377.    
  378.     *(unsigned short*)(charAddr + 0x3C) = *(int*)(addr + 0x08); //Attack
  379.     *(unsigned short*)(charAddr + 0x3E) = *(int*)(addr + 0x0C); //Defense
  380.     *(unsigned short*)(charAddr + 0x40) = *(int*)(addr + 0x10); //Agility
  381.     *(char*)(charAddr + 0x42) = *(int*)(addr + 0x18); //Luck
  382.     *(char*)(charAddr + 0x43) = *(int*)(addr + 0x1C); //Turns
  383.     *(char*)(charAddr + 0x44) = *(int*)(addr + 0x20); //HP Recovery
  384.     *(char*)(charAddr + 0x45) = *(int*)(addr + 0x24); //PP Recovery
  385.     i = 3, eAddr1 = charAddr + 0x48, eAddr2 = addr + 0x28;
  386.     do {
  387.         *(short*)(eAddr1) = *(int*)(eAddr2); //ePower
  388.         *(short*)(eAddr1 + 0x2) = *(int*)(eAddr2 + 0x04); //eResist
  389.         eAddr1 += 4; eAddr2 += 8;
  390.     } while (--i >= 0);
  391.    
  392.     int hpmax = 0, ppmax = 0;
  393.     if (*(char*)(charAddr + 0x129) == 0) {
  394.         hpmax = 0x3FFF; ppmax = 9999;
  395.     } else {
  396.         hpmax = 1999; ppmax = 1999;
  397.     }
  398.    
  399.     int oldhp = *(short*)(charAddr + 0x34);
  400.     if (*(int*)(addr + 0x00) < 0) { *(int*)(addr + 0x00) = 0; }
  401.     if (*(int*)(addr + 0x00) > hpmax) { *(int*)(addr + 0x00) = hpmax; }
  402.     *(short*)(charAddr + 0x34) = *(int*)(addr + 0x00); //HP
  403.     if (*(short*)(charAddr + 0x34) != oldhp) {
  404.         int hp = *(short*)(charAddr + 0x34) * *(short*)(charAddr + 0x14);
  405.         if (hp < 0) { hp += 0x3FFF; }
  406.         hp >>= 0xE;
  407.         if (hp < 0) { hp = 0; }
  408.         if (hp > hpmax) { hp = hpmax; }
  409.         if ((*(short*)(charAddr + 0x38) != 0) && (hp == 0))  { hp = 1; }
  410.         *(short*)(charAddr + 0x38) = hp;
  411.     }
  412.    
  413.     int oldpp = *(short*)(charAddr + 0x36);
  414.     if (*(int*)(addr + 0x04) < 0) { *(int*)(addr + 0x04) = 0; }
  415.     if (*(int*)(addr + 0x04) > ppmax) { *(int*)(addr + 0x04) = ppmax; }
  416.     *(short*)(charAddr + 0x36) = *(int*)(addr + 0x04); //PP
  417.     if (*(short*)(charAddr + 0x36) != oldpp) {
  418.         int pp = *(short*)(charAddr + 0x36) * *(short*)(charAddr + 0x16);
  419.         if (pp < 0) { pp += 0x3FFF; }
  420.         pp >>= 0xE;
  421.         if (pp < 0) { pp = 0; }
  422.         if (pp > hpmax) { pp = ppmax; }
  423.         if ((*(short*)(charAddr + 0x3A) != 0) && (pp == 0))  { pp = 1; }
  424.         *(short*)(charAddr + 0x38) = pp;
  425.     }
  426.    
  427.     pub_setFreeSpace(addr);
  428. }
  429.  
  430. void boostEncountersCheck() { //080ADBEC
  431.     pub_clearFlag(0x167);
  432.     int partyAmt = getPartyAmt();
  433.     char* pcIndAddr = (char*)0x02000458;
  434.     while (partyAmt-- > 0) {
  435.         int charAddr = pub_getCharAddr(*pcIndAddr++);
  436.         int items = 0xE;
  437.         charAddr += 0xD8; // Only need to check items.
  438.         do {
  439.             int item = *(short*)charAddr;
  440.             if ((item & 0x0200) != 0) {
  441.                 int itemEffectAddr = getItemAddr(item) + 0x18;
  442.                 int itemEffects = 3;
  443.                 do {
  444.                     if (*(char*)itemEffectAddr == 0x1B) {
  445.                         pub_setFlag(0x167);
  446.                     }
  447.                 } while (--itemEffects >= 0);
  448.             }          
  449.         } while (--items >= 0);
  450.     }
  451. }
  452.  
  453. //Ship Hover stuff...
  454. int getPartyPPPercent() { //080ADC90
  455.     int partycurpp = 0, partymaxpp = 0;
  456.     int partyAmt = getPartyAmt();
  457.     char* pcIndAddr = (char*)0x02000458;
  458.     int percentage = 0;
  459.     int pcSlot = 0;
  460.     while (partyAmt-- > 0) {
  461.         int charAddr = pub_getCharAddr(*pcIndAddr++);
  462.         partycurpp += *(short*)(charAddr + 0x3A);
  463.         partymaxpp += *(short*)(charAddr + 0x36);
  464.     }
  465.     if (partymaxpp != 0)
  466.         percentage = pub_division(partycurpp << 0x10, partymaxpp);
  467.     return percentage; //0x10000 = 100%
  468. }
  469.  
  470. int decPartyPP() { //080ADCEC
  471.     int partyAmt = getPartyAmt();
  472.     char* pcIndAddr = (char*)0x02000458;
  473.     int percent = 0;
  474.     int pc = -1;
  475.     while (partyAmt-- > 0) {
  476.         int charAddr = pub_getCharAddr(*pcIndAddr);
  477.         int maxpp = *(short*)(charAddr + 0x36);
  478.         int perc = 0;
  479.         if (maxpp != 0)
  480.             perc = pub_division(*(short*)(charAddr + 0x3A), maxpp);
  481.         if (perc > percent) {
  482.             percent = perc;
  483.             pc = *pcIndAddr;
  484.         }
  485.         pcIndAddr++;
  486.     }
  487.     int amt = 0;
  488.     if (pc != -1)
  489.         amt = addPP(pc, -1);
  490.     return amt;
  491. }
  492.  
  493. int massDecPartyPP(int PP) { //080ADD5C
  494.     while (PP-- > 0) {
  495.         decPartyPP();
  496.     }
  497.     return getPartyPPPercent();
  498. }
  499.  
  500. int calcBuildDate() { //080ADD74 = Not sure if used for anything useful?
  501.     //Could this have been an unused RNG seed? Save version, or...?
  502.     int fAddr = pub_getFile(2);
  503.     int num = ((*(char*)fAddr++ - 0x30) * 10) + (*(char*)fAddr++ - 0x30); //Year
  504.     num = (num << 4) + ((*(char*)fAddr++ - 0x30) * 10) + (*(char*)fAddr++ - 0x30); //Month
  505.     num = (num << 6) + ((*(char*)fAddr++ - 0x30) * 10) + (*(char*)fAddr++ - 0x30); //Day
  506.     num |= 0x1000;
  507.     if (*(char*)0x03001238)
  508.         num |= 0x8000;
  509.     return (unsigned short)num;
  510. }
  511.  
  512. int initPlayerData() { //080ADDF0
  513.     //Clear Player Data, etc. - Switch to stmia later?
  514.     volatile int a = 0;
  515.     *(int*)0x040000D4 = &a;
  516.     *(int*)0x040000D8 = (int)0x02000240;
  517.     *(int*)0x040000DC = (int)0x850000B8;
  518.     *(int*)0x040000D4 = &a;
  519.     *(int*)0x040000D8 = (int)0x02001000;
  520.     *(int*)0x040000DC = (int)0x850007C8;
  521.     while (*(int*)0x040000DC & 0x80000000 != 0) {}
  522.     *(int*)0x040000D4 = &a;
  523.     *(int*)0x040000D8 = (int)0x02000040;
  524.     *(int*)0x040000DC = (int)0x85000080;
  525.     *(char*)0x02001004 = 0xFF;
  526.     *(int*)0x040000D4 = &a;
  527.     *(int*)0x040000D8 = (int)0x02000520;
  528.     *(int*)0x040000DC = (int)0x85000298;
  529.     initPartyData()
  530.    
  531.     //Actions/Keypad stuff
  532.     *(short*)0x04000470 = 0x0001;
  533.     *(short*)0x04000472 = 0x0002;
  534.     *(short*)0x04000474 = 0x0004;
  535.     *(short*)0x04000476 = 0x0008;
  536.     *(short*)0x04000478 = 0x0200;
  537.     *(short*)0x0400047A = 0x0100;
  538.     *(short*)0x0400047C = 0x0002; //B button to run.
  539.    
  540.     *(short*)0x04000480 = 0x0000; //L & R Psynergy Shortcuts
  541.     *(short*)0x04000482 = 0x0000;
  542.    
  543.     *(short*)0x04000454 = 0x0004; //Set Party Leader.
  544.     joinParty(4);
  545.     joinParty(5);
  546.     learnPsynergy(4, 0x95); //Felix: Retreat
  547.     learnPsynergy(4, 0x8C); //Felix: Move
  548.     learnPsynergy(6, 0x8D); //Sheba: Mind Read
  549.     learnPsynergy(7, 0x21); //Piers: Douse
  550.     learnPsynergy(0, 0x95); //Isaac: Retreat
  551.     learnPsynergy(0, 0x8C); //Isaac: Move
  552.     learnPsynergy(1, 0x8C); //Garet: Move
  553.     learnPsynergy(2, 0x8D); //Ivan: Mind Read
  554.     learnPsynergy(2, 0x90); //Ivan: Reveal
  555.     *(int*)0x02000250 = 200; //Coins
  556.     *(int*)0x020004CC = 0; //Coins from GS1 party.
  557.     *(short*)0x020004FC = 0; //Forge Item Reward
  558.     *(char*)0x020004B4 = 0; //???
  559.     *(char*)0x0200046C = 1; //Message speed
  560.     *(char*)0x0200046A = 1; //Speech
  561.     *(char*)0x0200046B = 1; //???
  562.     *(char*)0x02000465 = 1; //Window color
  563.     *(char*)0x02000466 = 1; //Window brightness
  564.     *(int*)0x02000240 = 0; //Build date (Set on save. Possibly affects whether you load to sanctum?)
  565.     *(int*)0x02000518 = calcBuildDate(); //Initial build date. (Unknown purpose.)
  566.     *(int*)0x0300117C = 0; //Frame number
  567.     *(char*)0x03001200 = 0; //Auto-sleep
  568.     *(int*)0x02000244 = 0; //Frame number on save.
  569.     *(char*)0x0200048A = *(char*)0x03001200;
  570.     *(char*)0x03001218 = 0; //Auto-sleep counter
  571.     *(short*)0x020036D0 = -1; //???
  572.     *(char*)0x020004C6 = *(short*)0x02003860 //???
  573.    
  574.      //Lemuria Spring - Item chance rates
  575.     *(char*)0x0200037D = *(char*)0x04;
  576.     *(char*)0x0200037E = *(char*)0x04;
  577.     *(char*)0x0200037F = *(char*)0x04;
  578.     *(char*)0x02000380 = *(char*)0x08;
  579.     *(char*)0x02000381 = *(char*)0x08;
  580.     *(char*)0x02000382 = *(char*)0x08;
  581.     *(char*)0x02000383 = *(char*)0x10;
  582.     *(char*)0x02000384 = *(char*)0x10;
  583.     *(char*)0x02000385 = *(char*)0x10;
  584.     *(char*)0x02000386 = *(char*)0x20;
  585.     *(char*)0x02000387 = *(char*)0x20;
  586.     *(char*)0x02000388 = *(char*)0x20;
  587.     *(char*)0x02000389 = *(char*)0x40;
  588.     *(char*)0x0200038A = *(char*)0x40;
  589.     *(char*)0x0200038B = *(char*)0x40;
  590.    
  591.     //??? - Random values of 0-4 set. (Unused?)
  592.     int entry = 0;
  593.     do {
  594.         int addr = 0x020021B8 + (entry * 0xC);
  595.         int cnt = 7;
  596.         do {
  597.             *(char*)addr++ = (pub_generateGRN() * 5) >> 0x10;
  598.         } while (--cnt >= 0);
  599.     } while (++entry <= 0x1F);
  600.    
  601.     //??? - 080AE092 - 4 entries of 5 bytes. I'm lazy, so transferring as 32-bits.
  602.     //Todo: Fix it.
  603.     *(int*)0x02002338 = *(int*)0x080B1F2C;
  604.     *(int*)0x0200233C = *(int*)0x080B1F30;
  605.     *(int*)0x02002340 = *(int*)0x080B1F34;
  606.     *(int*)0x02002344 = *(int*)0x080B1F38;
  607.     *(int*)0x02002348 = *(int*)0x080B1F3C;
  608. }
  609. void teamJenna() { //080AE0DC
  610.     *(int*)0x02000454 = 5;
  611. }
  612. void teamFelix() { //080AE0F0
  613.     *(int*)0x02000454 = 4;
  614.     joinParty(4);
  615.     leaveParty(5);
  616.     leaveParty(6);
  617. }
  618. void joinPiersDjinn() { //080AE118
  619.     //Game does this via a loop, but I find that unnecessary.
  620.     //Djinni: Spring
  621.     pub_setFlag(0x4D);
  622.     joinDjinni(7, 1, 9);
  623.     setDjinni(7, 1, 9);
  624.     //Djinni: Shade
  625.     pub_setFlag(0x4E);
  626.     joinDjinni(7, 1, 10);
  627.     setDjinni(7, 1, 10);
  628.    
  629.     sortDjinn(0);
  630.    
  631.     int amt = getPartyAmt();
  632.     char* pcIndAddr = (char*)0x02000458;
  633.     while (amt-- >= 0) {
  634.         calcStats(*pcIndAddr++);
  635.     }
  636. }
  637. void maxCureParty(int curePoisonHaunt) { //080AE16C
  638.     int amt = getPartyAmt();
  639.     char* pcIndAddr = (char*)0x02000458;
  640.     while (amt-- > 0) {
  641.         int charAddr = pub_getCharAddr(*a++);
  642.         *(short*)(charAddr + 0x38) = *(short*)(charAddr + 0x34)
  643.         *(short*)(charAddr + 0x3A) = *(short*)(charAddr + 0x36)
  644.         //080AE198 = Game seems to calculate the percents. I'll take the shortcut and do 100%.
  645.         //Probably should be 0% if max HP/PP was 0, but I'll skip that...
  646.         *(short*)(charAddr + 0x14) = 0x4000;
  647.         *(short*)(charAddr + 0x16) = 0x4000;
  648.         if (curePoisonHaunt == 1) {
  649.             *(char*)(charAddr + 0x131) = 0;
  650.             *(char*)(charAddr + 0x140) = 0;
  651.         }
  652.     }
  653. }
  654. void sortDjinn(int unused) { //080AE358
  655. }
  656. int addPP(int pc, int value) {
  657.     return 0;
  658. }
  659. int getItemAddr(int item) {
  660.     return 0;
  661. }
  662. void learnPsynergy(int pc, int psynergy) { //080AF6F4
  663. }
  664. void initPartyData() { //080AF7AC //PC names, etc.
  665. }
  666. void joinParty(int pc) {
  667. }
  668. void leaveParty(int pc) {
  669. }
  670. int getPartyAmt() { //080AFDBC
  671.     return 0;//*aa; //*(int*)0x02001234;
  672. }
  673. int getClassAddr(int classInd) {
  674.     return 0;
  675. }
  676. int getDjinniAddr(int element, int djinni) {
  677.     return 0;
  678. }
  679. void joinDjinni(int pc, int element, int djinni) {
  680. }
  681. void setDjinni(int pc, int element, int djinni) {
  682. }
  683. int getParty3() {
  684.     return *(int*)0x02001234;
  685. }
  686.  
  687. //Call out functions... (Should be okay to modify.)
  688. int pub_division(int numerator, int denominator) {
  689.     r4=(int*)0x08002055; goto *r4;
  690. }
  691. int pub_getFile(int fileID) {
  692.     r4=(int*)0x08013301; goto *r4;
  693. }
  694. int pub_getFreeSpaceW(int size) { //Check 02 RAM first, then 03 RAM, if failed, return 0.
  695.     r4=(int*)0x08014DAD; goto *r4;
  696. }
  697. int pub_setFreeSpace(int address) {
  698.     r4=(int*)0x08013165; goto *r4;
  699. }
  700. int pub_generateGRN() {
  701.     r4=(int*)0x08014879; goto *r4;
  702. }
  703. int pub_getCharAddr(int charSlot) {
  704.     r4=(int*)0x08016CA5; goto *r4;
  705. }
  706. int pub_getFlag(int flagInd) {
  707.     r4=(int*)0x08016CE5; goto *r4;
  708. }
  709. int pub_setFlag(int flagInd) {
  710.     r4=(int*)0x08016CFD; goto *r4;
  711. }
  712. int pub_clearFlag(int flagInd) {
  713.     r4=(int*)0x08016D19; goto *r4;
  714. }
  715. int pub_bootMap(int type) { //type is only for debug mode.
  716.     r4=(int*)0x080C8009; goto *r4;
  717. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!