API tools faq
paste
blurose

[HGSS] SwitchInAbilityCheck c function

blurose
Jan 14th, 2022 (edited)
360
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 25.99 KB | None | 0 0
raw download clone embed print report
  1. enum
  2. {
  3.     SWITCH_IN_CHECK_WEATHER = 0,
  4.     SWITCH_IN_CHECK_TRACE,
  5.     SWITCH_IN_CHECK_WEATHER_ABILITY,
  6.     SWITCH_IN_CHECK_INTIMIDATE,
  7.     SWITCH_IN_CHECK_DOWNLOAD,
  8.     SWITCH_IN_CHECK_ANTICIPATION,
  9.     SWITCH_IN_CHECK_FOREWARN,
  10.     SWITCH_IN_CHECK_FRISK,
  11.     SWITCH_IN_CHECK_SLOW_START,
  12.     SWITCH_IN_CHECK_MOLD_BREAKER,
  13.     SWITCH_IN_CHECK_PRESSURE,
  14.     SWITCH_IN_CHECK_FORECAST,
  15.     SWITCH_IN_CHECK_AMULET_COIN,
  16.     SWITCH_IN_CHECK_ABILITY_HEAL_STATUS,
  17.     SWITCH_IN_CHECK_HEAL_STATUS,
  18.     SWITCH_IN_CHECK_UNNERVE,
  19.     SWITCH_IN_CHECK_END,
  20. };
  21.  
  22. enum
  23. {
  24.     SWITCH_IN_CHECK_LOOP = 0,
  25.     SWITCH_IN_CHECK_MOVE_SCRIPT,
  26.     SWITCH_IN_CHECK_CHECK_END,
  27. };
  28.  
  29. int SwitchInAbilityCheck(void *bw, struct BattleStruct *sp)
  30. {   int i;
  31.     int scriptnum = 0;
  32.     int ret = SWITCH_IN_CHECK_LOOP;
  33.     int client_no;
  34.     int client_set_max;
  35.  
  36.     client_set_max = BattleWorkClientSetMaxGet(bw);
  37.  
  38.     // 022531A8
  39.     do
  40.     {
  41.         switch(sp->switch_in_check_seq_no)
  42.         {
  43.         case SWITCH_IN_CHECK_WEATHER: // 022531DE
  44.             if (sp->weather_check_flag == 0)
  45.             {
  46.                 switch (BattleWorkWeatherGet(bw))
  47.                 {
  48.                 case WEATHER_SYS_RAIN:
  49.                 case WEATHER_SYS_HEAVY_RAIN:
  50.                 case WEATHER_SYS_THUNDER:
  51.                     scriptnum = SUB_SEQ_OVERWORLD_RAIN;
  52.                     ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  53.                     break;
  54.                 case WEATHER_SYS_SNOW:
  55.                 case WEATHER_SYS_SNOWSTORM:
  56.                 case WEATHER_SYS_BLIZZARD:
  57.                     scriptnum = SUB_SEQ_OVERWORLD_HAIL;
  58.                     ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  59.                     break;
  60.                 case WEATHER_SYS_SANDSTORM:
  61.                     scriptnum = SUB_SEQ_OVERWORLD_SANDSTORM;
  62.                     ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  63.                     break;
  64.                 case WEATHER_SYS_MIST1:
  65.                 case WEATHER_SYS_MIST2:
  66.                     scriptnum = SUB_SEQ_OVERWORLD_FOG;
  67.                     ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  68.                     break;
  69.                 case WEATHER_SYS_HIGH_SUN:
  70.                     scriptnum = SUB_SEQ_OVERWORLD_DROUGHT;
  71.                     ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  72.                     break;
  73.                 case WEATHER_SYS_TRICK_ROOM:
  74.                     scriptnum = SUB_SEQ_OVERWORLD_TRICK_ROOM;
  75.                     ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  76.                     break;
  77.                 default:
  78.                     break;
  79.                 }
  80.                 if (ret == SWITCH_IN_CHECK_MOVE_SCRIPT)
  81.                 {
  82.                     sp->weather_check_flag = 1;
  83.                 }
  84.             }
  85.             sp->switch_in_check_seq_no++;
  86.             break;
  87.         // 02253274
  88.         case SWITCH_IN_CHECK_TRACE:
  89.             {
  90.                 int def1,def2;
  91.                
  92.                 for (i = 0; i < client_set_max; i++){
  93.                     client_no = sp->turn_order[i];
  94.                     def1 = BattleWorkEnemyClientGet(bw, client_no, BATTLER_POSITION_SIDE_RIGHT);
  95.                     def2 = BattleWorkEnemyClientGet(bw, client_no, BATTLER_POSITION_SIDE_LEFT);
  96.                    
  97.                     sp->defence_client_work = TraceClientGet(bw,sp,def1,def2);
  98.  
  99.                     if ((sp->battlemon[client_no].trace_flag == 0)
  100.                      && (sp->defence_client_work != 0xFF)
  101.                      && (sp->battlemon[client_no].hp)
  102.                      && (sp->battlemon[client_no].item != ITEM_GRISEOUS_ORB)
  103.                      && (sp->battlemon[sp->defence_client_work].hp)
  104.                      && (GetBattlerAbility(sp, client_no) == ABILITY_TRACE))
  105.                     {
  106.                         sp->battlemon[client_no].trace_flag = 1;
  107.                         sp->client_work = client_no;
  108.                         scriptnum = SUB_SEQ_HANDLE_TRACE;
  109.                         ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  110.                         break;
  111.                     }
  112.                 }
  113.             }
  114.             if (i == client_set_max){
  115.                 sp->switch_in_check_seq_no++;
  116.             }
  117.             break;
  118.         // 02253338
  119.         case SWITCH_IN_CHECK_WEATHER_ABILITY:
  120.             for (i = 0; i < client_set_max; i++)
  121.             {
  122.                 client_no = sp->turn_order[i];
  123.                 if ((sp->battlemon[client_no].appear_check_flag == 0)
  124.                  && (sp->battlemon[client_no].hp))
  125.                 {
  126.                     switch(GetBattlerAbility(sp, client_no)){
  127.                     case ABILITY_DRIZZLE:
  128.                         sp->battlemon[client_no].appear_check_flag = 1;
  129.                         if ((sp->field_condition & WEATHER_RAIN_PERMANENT) == 0)
  130.                         {
  131.                             scriptnum = SUB_SEQ_HANDLE_DRIZZLE;
  132.                             ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  133.                         }
  134.                         break;
  135.                     case ABILITY_SAND_STREAM:
  136.                         sp->battlemon[client_no].appear_check_flag = 1;
  137.                         if ((sp->field_condition & WEATHER_SANDSTORM_PERMANENT) == 0)
  138.                         {
  139.                             scriptnum = SUB_SEQ_HANDLE_SAND_STREAM;
  140.                             ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  141.                         }
  142.                         break;
  143.                     case ABILITY_DROUGHT:
  144.                         sp->battlemon[client_no].appear_check_flag = 1;
  145.                         if ((sp->field_condition & WEATHER_SUNNY_PERMANENT) == 0)
  146.                         {
  147.                             scriptnum = SUB_SEQ_HANDLE_DROUGHT;
  148.                             ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  149.                         }
  150.                         break;
  151.                     case ABILITY_SNOW_WARNING:
  152.                         sp->battlemon[client_no].appear_check_flag = 1;
  153.                         if ((sp->field_condition & WEATHER_HAIL_PERMANENT) == 0)
  154.                         {
  155.                             scriptnum = SUB_SEQ_HANDLE_SNOW_WARNING;
  156.                             ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  157.                         }
  158.                         break;
  159.                     }
  160.                 }
  161.                 if (ret == SWITCH_IN_CHECK_MOVE_SCRIPT)
  162.                 {
  163.                     sp->client_work = client_no;
  164.                     break;
  165.                 }
  166.             }
  167.             if (i == client_set_max)
  168.             {
  169.                 sp->switch_in_check_seq_no++;
  170.             }
  171.             break;
  172.         // 02253448
  173.         case SWITCH_IN_CHECK_INTIMIDATE:
  174.             for (i = 0; i < client_set_max; i++)
  175.             {
  176.                 client_no = sp->turn_order[i];
  177.                 if ((sp->battlemon[client_no].intimidate_flag == 0)
  178.                  && (sp->battlemon[client_no].hp)
  179.                  && (GetBattlerAbility(sp, client_no) == ABILITY_INTIMIDATE))
  180.                 {
  181.                     sp->battlemon[client_no].intimidate_flag = 1;
  182.                     sp->client_work = client_no;
  183.                     scriptnum = SUB_SEQ_HANDLE_INTIMIDATE;
  184.                     ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  185.                     break;
  186.                 }
  187.             }
  188.             if (i == client_set_max){
  189.                 sp->switch_in_check_seq_no++;
  190.             }
  191.             break;
  192.         // 022534BE
  193.         case SWITCH_IN_CHECK_DOWNLOAD:
  194.             for (i = 0; i < client_set_max; i++)
  195.             {
  196.                 client_no = sp->turn_order[i];
  197.                 if ((sp->battlemon[client_no].download_flag == 0)
  198.                  && (sp->battlemon[client_no].hp)
  199.                  && (GetBattlerAbility(sp, client_no) == ABILITY_DOWNLOAD))
  200.                 {
  201.                     {
  202.                         int num;
  203.                         int def = 0, spdef = 0;
  204.  
  205.                         for(num = 0; num < client_set_max; num++)
  206.                         {
  207.                             if ((IsClientEnemy(bw, client_no) != IsClientEnemy(bw, num))
  208.                              && ((sp->battlemon[num].condition2 & STATUS2_FLAG_SUBSTITUTE) == 0)
  209.                              && (sp->battlemon[num].hp))
  210.                             {
  211.                                 def += sp->battlemon[num].def * StatBoostModifiers[sp->battlemon[num].states[STAT_DEFENSE]][0] / StatBoostModifiers[sp->battlemon[num].states[STAT_DEFENSE]][1];
  212.                                 spdef += sp->battlemon[num].spdef * StatBoostModifiers[sp->battlemon[num].states[STAT_SPDEF]][0] / StatBoostModifiers[sp->battlemon[num].states[STAT_SPDEF]][1];
  213.                             }
  214.                         }
  215.                        
  216.                         sp->battlemon[client_no].download_flag = 1;
  217.                        
  218.                         if ((def + spdef) != 0)
  219.                         {
  220.                             if (def >= spdef)
  221.                             {
  222.                                 sp->addeffect_param = ADD_STAGE_SP_ATK_UP;
  223.                             }
  224.                             else
  225.                             {
  226.                                 sp->addeffect_param = ADD_STAGE_ATTACK_UP;
  227.                             }
  228.                             sp->addeffect_type = ADD_STATUS_ABILITY;
  229.                             sp->state_client = client_no;
  230.                             scriptnum = SUB_SEQ_STAT_STAGE_CHANGE;
  231.                             ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  232.                             break;
  233.                         }
  234.                     }
  235.                 }
  236.             }
  237.             if (i == client_set_max)
  238.             {
  239.                 sp->switch_in_check_seq_no++;
  240.             }
  241.             break;
  242.         // 02253624
  243.         case SWITCH_IN_CHECK_ANTICIPATION:
  244.             for (i = 0; i < client_set_max; i++)
  245.             {
  246.                 client_no = sp->turn_order[i];
  247.                 if ((sp->battlemon[client_no].anticipation_flag == 0)
  248.                  && (sp->battlemon[client_no].hp)
  249.                  && (GetBattlerAbility(sp, client_no) == ABILITY_ANTICIPATION))
  250.                 {
  251.                     sp->battlemon[client_no].anticipation_flag = 1;
  252.                     {
  253.                         int num, pos;
  254.                         u16 movenum;
  255.                         u32 flag;
  256.  
  257.                         for (num = 0; num < client_set_max; num++)
  258.                         {
  259.                             if ((IsClientEnemy(bw, client_no) != IsClientEnemy(bw, num)) && (sp->battlemon[num].hp))
  260.                             {
  261.                                 for (pos = 0; pos < 4; pos++)
  262.                                 {
  263.                                     movenum=sp->battlemon[num].move[pos];
  264.                                     if (movenum)
  265.                                     {
  266.                                         flag = 0;
  267.                                         sp->damage = TypeCalc(bw, sp, movenum, 0, num, client_no, sp->damage, &flag);
  268.                                         if (((flag & MOVE_STATUS_FLAG_NOT_EFFECTIVE) == 0)
  269.                                          && (AnticipateMoveEffectListCheck(sp, movenum) == FALSE) // move effects that deal fixed damage don't activate anticipation--see psywave, dragon rage, etc.
  270.                                          && ((flag & MOVE_STATUS_FLAG_SUPER_EFFECTIVE)
  271.                                           || ((sp->old_moveTbl[movenum].effect == 38) // one-hit ko
  272.                                            && (sp->battlemon[client_no].level<=sp->battlemon[num].level))))
  273.                                         {
  274.                                             ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  275.                                             break;
  276.                                         }
  277.                                     }
  278.                                 }
  279.                                 if (ret == SWITCH_IN_CHECK_MOVE_SCRIPT){
  280.                                     break;
  281.                                 }
  282.                             }
  283.                         }
  284.                         if (ret == SWITCH_IN_CHECK_MOVE_SCRIPT)
  285.                         {
  286.                             sp->client_work = client_no;
  287.                             scriptnum = SUB_SEQ_HANDLE_ANTICIPATION;
  288.                         }
  289.                         break;
  290.                     }
  291.                 }
  292.             }
  293.             if (i == client_set_max){
  294.                 sp->switch_in_check_seq_no++;
  295.             }
  296.             break;
  297.         // 02253764
  298.         case SWITCH_IN_CHECK_FOREWARN:
  299.             for (i = 0; i < client_set_max; i++)
  300.             {
  301.                 client_no = sp->turn_order[i];
  302.                 if ((sp->battlemon[client_no].forewarn_flag == 0)
  303.                  && (sp->battlemon[client_no].hp)
  304.                  && (GetBattlerAbility(sp, client_no) == ABILITY_FOREWARN))
  305.                 {
  306.                     sp->battlemon[client_no].forewarn_flag = 1;
  307.                     {
  308.                         int num,pos;
  309.                         u16 movenum;
  310.                         u32 basepower = 0, basepower_temp = 0;
  311.                         int hp;
  312.  
  313.                         for (num = 0; num < client_set_max; num++)
  314.                         {
  315.                             if((IsClientEnemy(bw, client_no) != IsClientEnemy(bw, num)) && (sp->battlemon[num].hp))
  316.                             {
  317.                                 hp += sp->battlemon[num].hp;
  318.                                 for(pos = 0; pos < 4; pos++)
  319.                                 {
  320.                                     movenum = sp->battlemon[num].move[pos];
  321.                                     basepower = sp->old_moveTbl[movenum].power;
  322.                                     switch (basepower) // basically handle 1 base power moves
  323.                                     {
  324.                                     case 1:
  325.                                         switch(sp->old_moveTbl[movenum].effect)
  326.                                         {
  327.                                         case 38: // one-hit ko
  328.                                             if ((basepower_temp < 150)
  329.                                              || ((basepower_temp == 150) && (BattleRand(bw) & 1)))
  330.                                             {
  331.                                                 basepower_temp = 150;
  332.                                                 sp->waza_work = movenum;
  333.                                             }
  334.                                             break;
  335.                                         // counter, mirror coat, metal burst
  336.                                         case 89:
  337.                                         case 144:
  338.                                         case 227:
  339.                                             if ((basepower_temp < 120)
  340.                                              || ((basepower_temp == 120) && (BattleRand(bw) & 1)))
  341.                                             {
  342.                                                 basepower_temp = 120;
  343.                                                 sp->waza_work = movenum;
  344.                                             }
  345.                                             break;
  346.                                         default:
  347.                                             if ((basepower_temp < 80)
  348.                                              || ((basepower_temp == 80) && (BattleRand(bw) & 1)))
  349.                                             {
  350.                                                 basepower_temp = 80;
  351.                                                 sp->waza_work = movenum;
  352.                                             }
  353.                                             break;
  354.                                         }
  355.                                         break;
  356.                                     default:
  357.                                         if ((basepower_temp < basepower)
  358.                                          || ((basepower_temp == basepower) && (BattleRand(bw) & 1)))
  359.                                         {
  360.                                             basepower_temp = basepower;
  361.                                             sp->waza_work = movenum;
  362.                                         }
  363.                                         break;
  364.                                     }
  365.                                 }
  366.                             }
  367.                         }
  368.  
  369.                         if (basepower_temp)
  370.                         {
  371.                             sp->client_work = client_no;
  372.                             scriptnum = SUB_SEQ_HANDLE_FOREWARN;
  373.                             ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  374.                         }
  375.                         else if (hp)
  376.                         {
  377.                             num = ChooseRandomTarget(bw, sp, client_no);
  378.                             pos = CountBattlerMoves(bw, sp, num);
  379.                             sp->waza_work = sp->battlemon[num].move[ BattleRand(bw) % pos ];
  380.                             sp->client_work = client_no;
  381.                             scriptnum = SUB_SEQ_HANDLE_FOREWARN;
  382.                             ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  383.                         }
  384.                         break;
  385.                     }
  386.                 }
  387.             }
  388.             if(i == client_set_max){
  389.                 sp->switch_in_check_seq_no++;
  390.             }
  391.             break;
  392.         // 02253974
  393.         case SWITCH_IN_CHECK_FRISK:
  394.             for (i = 0; i < client_set_max; i++)
  395.             {
  396.                 client_no = sp->turn_order[i];
  397.                 if ((sp->battlemon[client_no].frisk_flag == 0)
  398.                  && (sp->battlemon[client_no].hp)
  399.                  && (GetBattlerAbility(sp, client_no) == ABILITY_FRISK))
  400.                 {
  401.                     sp->battlemon[client_no].frisk_flag=1;
  402.                     if(BattleTypeGet(bw) & BATTLE_TYPE_DOUBLE)
  403.                     {
  404.                         {
  405.                             int def[2];
  406.  
  407.                             def[0] = BattleWorkEnemyClientGet(bw, client_no, BATTLER_POSITION_SIDE_RIGHT);
  408.                             def[1] = BattleWorkEnemyClientGet(bw, client_no, BATTLER_POSITION_SIDE_LEFT);
  409.  
  410.                             if ((sp->battlemon[def[0]].hp) && (sp->battlemon[def[0]].item)
  411.                              && (sp->battlemon[def[1]].hp) && (sp->battlemon[def[1]].item)) // if both mons are alive, check one randomly
  412.                             {
  413.                                 sp->item_work = sp->battlemon[def[ BattleRand(bw) & 1 ]].item;
  414.                                 ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  415.                             }
  416.                             else if ((sp->battlemon[def[0]].hp) && (sp->battlemon[def[0]].item))
  417.                             {
  418.                                 sp->item_work = sp->battlemon[def[0]].item;
  419.                                 ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  420.                             }
  421.                             else if ((sp->battlemon[def[1]].hp) && (sp->battlemon[def[1]].item))
  422.                             {
  423.                                 sp->item_work = sp->battlemon[def[1]].item;
  424.                                 ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  425.                             }
  426.                         }
  427.                     }
  428.                     else
  429.                     {
  430.                         if ((sp->battlemon[ client_no^1 ].hp) && (sp->battlemon[client_no^1].item)) // xor 1 will always result in opponent in single battle
  431.                         {
  432.                             sp->item_work = sp->battlemon[ client_no^1 ].item;
  433.                             ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  434.                         }
  435.                     }
  436.                 }
  437.                 if(ret == SWITCH_IN_CHECK_MOVE_SCRIPT)
  438.                 {
  439.                     sp->client_work = client_no;
  440.                     scriptnum = SUB_SEQ_HANDLE_FRISK;
  441.                     break;
  442.                 }
  443.             }
  444.             if(i == client_set_max)
  445.             {
  446.                 sp->switch_in_check_seq_no++;
  447.             }
  448.             break;
  449.         // 02253ACC
  450.         case SWITCH_IN_CHECK_SLOW_START:
  451.             for (i = 0; i < client_set_max; i++)
  452.             {
  453.                 client_no = sp->turn_order[i];
  454.                 if ((sp->battlemon[client_no].slow_start_flag == 0)
  455.                  && (sp->battlemon[client_no].hp)
  456.                  && (GetBattlerAbility(sp, client_no) == ABILITY_SLOW_START)
  457.                  && (sp->total_turn <= sp->battlemon[client_no].moveeffect.slow_start_count))
  458.                 {
  459.                     sp->battlemon[client_no].slow_start_flag = 1;
  460.                     sp->client_work = client_no;
  461.                     scriptnum = SUB_SEQ_HANDLE_SLOW_START;
  462.                     ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  463.                     break;
  464.                 }
  465.                
  466.                 // check slow start end as well
  467.                 if ((sp->battlemon[client_no].slow_start_end_flag == 0)
  468.                  && (sp->battlemon[client_no].hp)
  469.                  && (GetBattlerAbility(sp, client_no) == ABILITY_SLOW_START)
  470.                  && ((sp->total_turn-sp->battlemon[client_no].moveeffect.slow_start_count) == 5))
  471.                 {
  472.                     sp->battlemon[client_no].slow_start_end_flag = 1;
  473.                     sp->client_work = client_no;
  474.                     scriptnum = SUB_SEQ_HANDLE_SLOW_START_END;
  475.                     ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  476.                     break;
  477.                 }
  478.             }
  479.             if(i == client_set_max)
  480.             {
  481.                 sp->switch_in_check_seq_no++;
  482.             }
  483.             break;
  484.         // 02253BA4
  485.         case SWITCH_IN_CHECK_MOLD_BREAKER:
  486.             for (i = 0; i < client_set_max; i++)
  487.             {
  488.                 client_no = sp->turn_order[i];
  489.                 if ((sp->battlemon[client_no].mold_breaker_flag == 0)
  490.                  && (sp->battlemon[client_no].hp)
  491.                  && (GetBattlerAbility(sp, client_no) == ABILITY_MOLD_BREAKER))
  492.                 {
  493.                     sp->battlemon[client_no].mold_breaker_flag = 1;
  494.                     sp->client_work = client_no;
  495.                     scriptnum = SUB_SEQ_HANDLE_MOLD_BREAKER;
  496.                     ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  497.                     break;
  498.                 }
  499.             }
  500.             if (i == client_set_max)
  501.             {
  502.                 sp->switch_in_check_seq_no++;
  503.             }
  504.             break;
  505.         // 02253C18
  506.         case SWITCH_IN_CHECK_PRESSURE:
  507.             for(i = 0; i < client_set_max; i++)
  508.             {
  509.                 client_no = sp->turn_order[i];
  510.                 if ((sp->battlemon[client_no].pressure_flag == 0)
  511.                  && (sp->battlemon[client_no].hp)
  512.                  && (GetBattlerAbility(sp, client_no) == ABILITY_PRESSURE))
  513.                 {
  514.                     sp->battlemon[client_no].pressure_flag = 1;
  515.                     sp->client_work = client_no;
  516.                     scriptnum = SUB_SEQ_HANDLE_PRESSURE;
  517.                     ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  518.                     break;
  519.                 }
  520.             }
  521.             if(i == client_set_max){
  522.                 sp->switch_in_check_seq_no++;
  523.             }
  524.             break;
  525.         // 02253CA6
  526.         case SWITCH_IN_CHECK_FORECAST:
  527.             if(BattleFormChangeCheck(bw, sp, &scriptnum) == TRUE)
  528.             {
  529.                 ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  530.             }
  531.             else
  532.             {
  533.                 sp->switch_in_check_seq_no++;
  534.             }
  535.             break;
  536.         // 02253CC2
  537.         case SWITCH_IN_CHECK_AMULET_COIN:
  538.             for (i = 0; i < client_set_max; i++)
  539.             {
  540.                 client_no=sp->turn_order[i];
  541.                 if (BattleItemDataGet(sp, sp->battlemon[client_no].item, 1) == HOLD_EFFECT_DOUBLE_MONEY_GAIN)
  542.                 {
  543.                     sp->money_multiplier = 2;
  544.                 }
  545.             }
  546.             sp->switch_in_check_seq_no++;
  547.             break;
  548.         // 02253CFC
  549.         case SWITCH_IN_CHECK_ABILITY_HEAL_STATUS:
  550.             for (i = 0; i < client_set_max; i++)
  551.             {
  552.                 client_no = sp->turn_order[i];
  553.                 if (AbilityStatusRecoverCheck(bw, sp, client_no, 1) == TRUE)
  554.                 {
  555.                     scriptnum = SUB_SEQ_HANDLE_STATUS_HEAL_ABILITIES;
  556.                     ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  557.                     break;
  558.                 }
  559.             }
  560.             if (i == client_set_max)
  561.             {
  562.                 sp->switch_in_check_seq_no++;
  563.             }
  564.             break;
  565.         // 02253D38
  566.         case SWITCH_IN_CHECK_HEAL_STATUS:
  567.             for (i = 0; i < client_set_max; i++)
  568.             {
  569.                 client_no = sp->turn_order[i];
  570.                 if(HeldItemHealCheck(bw, sp, client_no, &scriptnum) == TRUE)
  571.                 {
  572.                     sp->client_work = client_no;
  573.                     ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  574.                     break;
  575.                 }
  576.             }
  577.             if(i == client_set_max)
  578.             {
  579.                 sp->switch_in_check_seq_no++;
  580.             }
  581.             break;
  582.         case SWITCH_IN_CHECK_UNNERVE:
  583.             for(i = 0; i < client_set_max; i++)
  584.             {
  585.                 client_no = sp->turn_order[i];
  586.                 if ((sp->battlemon[client_no].unnerve_flag == 0)
  587.                  && (sp->battlemon[client_no].hp)
  588.                  && (GetBattlerAbility(sp, client_no) == ABILITY_UNNERVE))
  589.                 {
  590.                     sp->battlemon[client_no].unnerve_flag = 1;
  591.                     sp->client_work = client_no;
  592.                     scriptnum = SUB_SEQ_HANDLE_UNNERVE_MESSAGE;
  593.                     ret = SWITCH_IN_CHECK_MOVE_SCRIPT;
  594.                     break;
  595.                 }
  596.             }
  597.             if(i == client_set_max){
  598.                 sp->switch_in_check_seq_no++;
  599.             }
  600.             break;
  601.         // 02253D78
  602.         case SWITCH_IN_CHECK_END:
  603.             sp->switch_in_check_seq_no = 0;
  604.             ret = SWITCH_IN_CHECK_CHECK_END;
  605.             break;
  606.         }
  607.     } while (ret == SWITCH_IN_CHECK_LOOP);
  608.  
  609.     return scriptnum;
  610. }
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!