Split contest funcs from script_pokemon_util

2020-08-13 17:42:12 -04:00
parent 4911849723
commit 3779422489
21 changed files with 744 additions and 764 deletions
@@ -6,10 +6,12 @@
 #include "contest.h"
 #include "contest_util.h"
 #include "contest_link.h"
+#include "contest_painting.h"
 #include "data.h"
 #include "decompress.h"
 #include "dma3.h"
 #include "event_data.h"
+#include "event_object_movement.h"
 #include "field_specials.h"
 #include "gpu_regs.h"
 #include "graphics.h"
@@ -27,6 +29,7 @@
 #include "save.h"
 #include "scanline_effect.h"
 #include "script.h"
+#include "script_menu.h"
 #include "sound.h"
 #include "string_util.h"
 #include "strings.h"
@@ -36,6 +39,7 @@
 #include "tv.h"
 #include "util.h"
 #include "window.h"
+#include "constants/event_objects.h"
 #include "constants/field_specials.h"
 #include "constants/game_stat.h"
 #include "constants/rgb.h"
@@ -160,6 +164,13 @@ static void Task_LinkContest_CalculateTurnOrderRS(u8);
 static void Task_LinkContest_Disconnect(u8);
 static void Task_LinkContest_WaitDisconnect(u8);
 static void SpriteCB_Confetti(struct Sprite *sprite);
+static void Task_ShowContestEntryMonPic(u8 taskId);
+static void Task_LinkContestWaitForConnection(u8 taskId);
+
+extern const u16 gObjectEventPalette8[];
+extern const u16 gObjectEventPalette17[];
+extern const u16 gObjectEventPalette33[];
+extern const u16 gObjectEventPalette34[];

 static const u16 sUnknown_0858D6B0[] = INCBIN_U16("graphics/unknown/unknown_58D6B0.gbapal");
 static const u8 sUnknown_0858D6D0[] = INCBIN_U8("graphics/unknown/unknown_58D6D0.4bpp");
@@ -2530,3 +2541,479 @@ static void Task_LinkContest_WaitDisconnect(u8 taskId)
        EnableBothScriptContexts();
    }
 }
+
+void SetContestTrainerGfxIds(void)
+{
+    gSaveBlock1Ptr->vars[VAR_OBJ_GFX_ID_0 - VARS_START] = gContestMons[0].trainerGfxId;
+    gSaveBlock1Ptr->vars[VAR_OBJ_GFX_ID_1 - VARS_START] = gContestMons[1].trainerGfxId;
+    gSaveBlock1Ptr->vars[VAR_OBJ_GFX_ID_2 - VARS_START] = gContestMons[2].trainerGfxId;
+}
+
+// Unused
+void sub_80F8814(void)
+{
+    u16 var1;
+    u8 var0 = gSpecialVar_0x8005;
+    switch (var0)
+    {
+    case 0:
+        var1 = 3;
+        break;
+    case 1:
+        var1 = 4;
+        break;
+    case 2:
+        var1 = 5;
+        break;
+    default:
+        var1 = 100;
+        break;
+    }
+
+    gSpecialVar_0x8004 = var1;
+}
+
+void BufferContestTrainerAndMonNames(void)
+{
+    BufferContestantTrainerName();
+    BufferContestantMonNickname();
+    BufferContestantMonSpecies();
+}
+
+// Unused
+void DoesContestCategoryHaveWinner(void)
+{
+    int contestWinner;
+    switch (gSpecialVar_ContestCategory)
+    {
+    case CONTEST_CATEGORY_COOL:
+        contestWinner = 8;
+        break;
+    case CONTEST_CATEGORY_BEAUTY:
+        contestWinner = 9;
+        break;
+    case CONTEST_CATEGORY_CUTE:
+        contestWinner = 10;
+        break;
+    case CONTEST_CATEGORY_SMART:
+        contestWinner = 11;
+        break;
+    case CONTEST_CATEGORY_TOUGH:
+    default:
+        contestWinner = 12;
+        break;
+    }
+
+    if (gSaveBlock1Ptr->contestWinners[contestWinner].species == SPECIES_NONE)
+        gSpecialVar_0x8004 = FALSE;
+    else
+        gSpecialVar_0x8004 = TRUE;
+}
+
+void SaveMuseumContestPainting(void)
+{
+    sub_80DEDA8(0xFF);
+}
+
+void ShouldReadyContestArtist(void)
+{
+    if (gContestFinalStandings[gContestPlayerMonIndex] == 0
+     && gSpecialVar_ContestRank == CONTEST_RANK_MASTER
+     && gContestMonTotalPoints[gContestPlayerMonIndex] >= 800)
+    {
+        gSpecialVar_0x8004 = TRUE;
+    }
+    else
+    {
+        gSpecialVar_0x8004 = FALSE;
+    }
+}
+
+u8 CountPlayerContestPaintings(void)
+{
+    int i;
+    u8 count = 0;
+
+    for (i = 0; i < 5; i++)
+    {
+        if (gSaveBlock1Ptr->contestWinners[8 + i].species)
+            count++;
+    }
+
+    return count;
+}
+
+// Unused
+void sub_80F8970(void)
+{
+    s16 conditions[CONTESTANT_COUNT];
+    int i, j;
+    s16 condition;
+    s8 var0;
+    u8 var2;
+    u8 r8;
+    u8 r7;
+
+    for (i = 0; i < CONTESTANT_COUNT; i++)
+        conditions[i] = gContestMonRound1Points[i];
+
+    for (i = 0; i < CONTESTANT_COUNT - 1; i++)
+    {
+        for (j = CONTESTANT_COUNT - 1; j > i; j--)
+        {
+            if (conditions[j - 1] < conditions[j])
+            {
+                int temp;
+                SWAP(conditions[j], conditions[j - 1], temp)
+            }
+        }
+    }
+
+    condition = conditions[gSpecialVar_0x8006];
+    var0 = 0;
+    r8 = 0;
+    for (i = 0; i < CONTESTANT_COUNT; i++)
+    {
+        if (conditions[i] == condition)
+        {
+            var0++;
+            if (i == gSpecialVar_0x8006)
+                r8 = var0;
+        }
+    }
+
+    for (i = 0; i < CONTESTANT_COUNT; i++)
+    {
+        if (conditions[i] == condition)
+            break;
+    }
+
+    r7 = i;
+    var2 = r8;
+    for (i = 0; i < CONTESTANT_COUNT; i++)
+    {
+        if (condition == gContestMonRound1Points[i])
+        {
+            if (var2 == 1)
+                break;
+            var2--;
+        }
+    }
+
+    StringCopy(gStringVar1, gContestMons[i].nickname);
+    StringCopy(gStringVar2, gContestMons[i].trainerName);
+    sub_81DB5AC(gStringVar2);
+
+    if (var0 == 1)
+        gSpecialVar_0x8006 = r7;
+    else if (r8 == var0)
+        gSpecialVar_0x8006 = r7;
+    else
+        gSpecialVar_0x8006 = r7 + 4;
+}
+
+static void ExitContestWinnerPainting(void)
+{
+    SetMainCallback2(CB2_ReturnToFieldContinueScriptPlayMapMusic);
+}
+
+void ShowContestWinnerPainting(void)
+{
+    SetMainCallback2(CB2_ContestPainting);
+    gMain.savedCallback = ExitContestWinnerPainting;
+}
+
+void SetLinkContestPlayerGfx(void)
+{
+    int i;
+
+    if (gLinkContestFlags & LINK_CONTEST_FLAG_IS_LINK)
+    {
+        for (i = 0; i < gNumLinkContestPlayers; i++)
+        {
+            int version = (u8)gLinkPlayers[i].version;
+            if (version == VERSION_RUBY || version == VERSION_SAPPHIRE)
+            {
+                if (gLinkPlayers[i].gender == MALE)
+                    gContestMons[i].trainerGfxId = OBJ_EVENT_GFX_LINK_RS_BRENDAN;
+                else
+                    gContestMons[i].trainerGfxId = OBJ_EVENT_GFX_LINK_RS_MAY;
+            }
+        }
+
+        VarSet(VAR_OBJ_GFX_ID_0, gContestMons[0].trainerGfxId);
+        VarSet(VAR_OBJ_GFX_ID_1, gContestMons[1].trainerGfxId);
+        VarSet(VAR_OBJ_GFX_ID_2, gContestMons[2].trainerGfxId);
+        VarSet(VAR_OBJ_GFX_ID_3, gContestMons[3].trainerGfxId);
+    }
+}
+
+void LoadLinkContestPlayerPalettes(void)
+{
+    int i;
+    u8 objectEventId;
+    int version;
+    struct Sprite *sprite;
+    static const u8 sContestantLocalIds[CONTESTANT_COUNT] = { 3, 4, 5, 14 };
+
+    gReservedSpritePaletteCount = 12;
+    if (gLinkContestFlags & LINK_CONTEST_FLAG_IS_LINK)
+    {
+        for (i = 0; i < gNumLinkContestPlayers; i++)
+        {
+            objectEventId = GetObjectEventIdByLocalIdAndMap(sContestantLocalIds[i], gSaveBlock1Ptr->location.mapNum, gSaveBlock1Ptr->location.mapGroup);
+            sprite = &gSprites[gObjectEvents[objectEventId].spriteId];
+            sprite->oam.paletteNum = 6 + i;
+            version = (u8)gLinkPlayers[i].version;
+            if (version == VERSION_RUBY || version == VERSION_SAPPHIRE)
+            {
+                if (gLinkPlayers[i].gender == MALE)
+                    LoadPalette(gObjectEventPalette33, 0x160 + i * 0x10, 0x20);
+                else
+                    LoadPalette(gObjectEventPalette34, 0x160 + i * 0x10, 0x20);
+            }
+            else
+            {
+                if (gLinkPlayers[i].gender == MALE)
+                    LoadPalette(gObjectEventPalette8, 0x160 + i * 0x10, 0x20);
+                else
+                    LoadPalette(gObjectEventPalette17, 0x160 + i * 0x10, 0x20);
+            }
+        }
+    }
+}
+
+bool8 GiveMonArtistRibbon(void)
+{
+    u8 hasArtistRibbon;
+
+    hasArtistRibbon = GetMonData(&gPlayerParty[gContestMonPartyIndex], MON_DATA_ARTIST_RIBBON);
+    if (!hasArtistRibbon 
+        && gContestFinalStandings[gContestPlayerMonIndex] == 0 
+        && gSpecialVar_ContestRank == CONTEST_RANK_MASTER
+        && gContestMonTotalPoints[gContestPlayerMonIndex] >= 800)
+    {
+        hasArtistRibbon = 1;
+        SetMonData(&gPlayerParty[gContestMonPartyIndex], MON_DATA_ARTIST_RIBBON, &hasArtistRibbon);
+        if (GetRibbonCount(&gPlayerParty[gContestMonPartyIndex]) > NUM_CUTIES_RIBBONS)
+            TryPutSpotTheCutiesOnAir(&gPlayerParty[gContestMonPartyIndex], MON_DATA_ARTIST_RIBBON);
+
+        return TRUE;
+    }
+    else
+    {
+        return FALSE;
+    }
+}
+
+bool8 IsContestDebugActive(void)
+{
+    return FALSE; // gUnknown_0203856C in pokeruby
+}
+
+void ShowContestEntryMonPic(void)
+{
+    const struct CompressedSpritePalette *palette;
+    u32 personality, otId;
+    u16 species;
+    u8 spriteId;
+    u8 taskId;
+    u8 left, top;
+
+    if (FindTaskIdByFunc(Task_ShowContestEntryMonPic) == 0xFF)
+    {
+        AllocateMonSpritesGfx();
+        left = 10;
+        top = 3;
+        species = gContestMons[gSpecialVar_0x8006].species;
+        personality = gContestMons[gSpecialVar_0x8006].personality;
+        otId = gContestMons[gSpecialVar_0x8006].otId;
+        taskId = CreateTask(Task_ShowContestEntryMonPic, 0x50);
+        gTasks[taskId].data[0] = 0;
+        gTasks[taskId].data[1] = species;
+        if (gSpecialVar_0x8006 == gContestPlayerMonIndex)
+            HandleLoadSpecialPokePic_2(&gMonFrontPicTable[species], gMonSpritesGfxPtr->sprites[1], species, personality);
+        else
+            HandleLoadSpecialPokePic_DontHandleDeoxys(&gMonFrontPicTable[species], gMonSpritesGfxPtr->sprites[1], species, personality);
+
+        palette = GetMonSpritePalStructFromOtIdPersonality(species, otId, personality);
+        LoadCompressedSpritePalette(palette);
+        SetMultiuseSpriteTemplateToPokemon(species, 1);
+        gMultiuseSpriteTemplate.paletteTag = palette->tag;
+        spriteId = CreateSprite(&gMultiuseSpriteTemplate, (left + 1) * 8 + 32, (top * 8) + 40, 0);
+
+        if (gLinkContestFlags & LINK_CONTEST_FLAG_IS_LINK)
+        {
+            if (!(gLinkContestFlags & LINK_CONTEST_FLAG_HAS_RS_PLAYER))
+                DoMonFrontSpriteAnimation(&gSprites[spriteId], species, FALSE, 0);
+        }
+        else
+        {
+            DoMonFrontSpriteAnimation(&gSprites[spriteId], species, FALSE, 0);
+        }
+
+        gTasks[taskId].data[2] = spriteId;
+        gTasks[taskId].data[3] = left;
+        gTasks[taskId].data[4] = top;
+        gSprites[spriteId].callback = SpriteCallbackDummy;
+        gSprites[spriteId].oam.priority = 0;
+    }
+}
+
+void HideContestEntryMonPic(void)
+{
+    u8 taskId = FindTaskIdByFunc(Task_ShowContestEntryMonPic);
+    if (taskId != 0xFF)
+    {
+        gTasks[taskId].data[0]++;
+        FreeMonSpritesGfx();
+    }
+}
+
+static void Task_ShowContestEntryMonPic(u8 taskId)
+{
+    struct Task *task = &gTasks[taskId];
+    struct Sprite *sprite;
+
+    switch(task->data[0])
+    {
+    case 0:
+        task->data[0]++;
+        break;
+    case 1:
+        task->data[5] = CreateWindowFromRect(10, 3, 8, 8);
+        SetStandardWindowBorderStyle(task->data[5], 1);
+        task->data[0]++;
+        break;
+    case 2:
+        break;
+    case 3:
+        sprite = &gSprites[task->data[2]];
+        FreeSpritePaletteByTag(GetSpritePaletteTagByPaletteNum(sprite->oam.paletteNum));
+
+        if(sprite->oam.affineMode)
+            FreeOamMatrix(sprite->oam.matrixNum);
+
+        DestroySprite(sprite);
+        task->data[0]++;
+        break;
+    case 4:
+        ClearToTransparentAndRemoveWindow(gTasks[taskId].data[5]);
+        DestroyTask(taskId);
+        break;
+    }
+}
+
+void GetContestMultiplayerId(void)
+{
+    if ((gLinkContestFlags & LINK_CONTEST_FLAG_IS_LINK) 
+        && gNumLinkContestPlayers == CONTESTANT_COUNT 
+        && !(gLinkContestFlags & LINK_CONTEST_FLAG_IS_WIRELESS))
+        gSpecialVar_Result = GetMultiplayerId();
+    else
+        gSpecialVar_Result = MAX_LINK_PLAYERS;
+}
+
+void GenerateContestRand(void)
+{
+    u16 random;
+    u16 *result;
+
+    if (gLinkContestFlags & LINK_CONTEST_FLAG_IS_LINK)
+    {
+        gContestRngValue = ISO_RANDOMIZE1(gContestRngValue);
+        random = gContestRngValue >> 16;
+        result = &gSpecialVar_Result;
+    }
+    else
+    {
+        result = &gSpecialVar_Result;
+        random = Random();
+    }
+    *result = random % *result;
+}
+
+u16 GetContestRand(void)
+{
+    gContestRngValue = ISO_RANDOMIZE1(gContestRngValue);
+    return gContestRngValue >> 16;
+}
+
+bool8 LinkContestWaitForConnection(void)
+{
+    if (gLinkContestFlags & LINK_CONTEST_FLAG_IS_WIRELESS)
+    {
+        CreateTask(Task_LinkContestWaitForConnection, 5);
+        return TRUE;
+    }
+    else
+    {
+        return FALSE;
+    }
+}
+
+static void Task_LinkContestWaitForConnection(u8 taskId)
+{
+    switch (gTasks[taskId].data[0])
+    {
+    case 0:
+        if (IsLinkTaskFinished())
+        {
+            SetLinkStandbyCallback();
+            gTasks[taskId].data[0]++;
+        }
+        break;
+    case 1:
+        gTasks[taskId].data[0]++;
+        break;
+    default:
+        if (IsLinkTaskFinished() == 1)
+        {
+            EnableBothScriptContexts();
+            DestroyTask(taskId);
+        }
+        break;
+    }
+}
+
+void LinkContestTryShowWirelessIndicator(void)
+{
+    if (gLinkContestFlags & LINK_CONTEST_FLAG_IS_WIRELESS)
+    {
+        if (gReceivedRemoteLinkPlayers)
+        {
+            LoadWirelessStatusIndicatorSpriteGfx();
+            CreateWirelessStatusIndicatorSprite(8, 8);
+        }
+    }
+}
+
+void LinkContestTryHideWirelessIndicator(void)
+{
+    if (gLinkContestFlags & LINK_CONTEST_FLAG_IS_WIRELESS)
+    {
+        if (gReceivedRemoteLinkPlayers)
+            DestroyWirelessStatusIndicatorSprite();
+    }
+}
+
+bool8 IsContestWithRSPlayer(void)
+{
+    if (gLinkContestFlags & LINK_CONTEST_FLAG_HAS_RS_PLAYER)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void ClearLinkContestFlags(void)
+{
+    gLinkContestFlags = 0;
+}
+
+bool8 IsWirelessContest(void)
+{
+    if (gLinkContestFlags & LINK_CONTEST_FLAG_IS_WIRELESS)
+        return TRUE;
+    else
+        return FALSE;
+}