Confusing Cook Error - Verse Changes Seem To Resolve It

Development Programming & Scripting
, ,
1

@Rebel_FNC and I have been having an issue (that we have now also posted in the Bug Reports area as well) where we get a cook timeout error when trying to launch a session. The strange part about this is that when I comment out the passing of one class from a Verse file to another, it resolves- but this isn’t really a solution as there is a lot more scripting to do for this project to be able to be completed.

Has anyone experienced this at all? Is there anything I need to avoid in the script to stop this from happening? This is a really big project for us and at the moment it is dead in the water because we can’t launch without disabling key features.

@Conan_Reis tagging you to see if you have some wisdom here?

2

These are the scripts for this project so far, if it helps anyone to see:

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

mayhem_game_setup_manager := class(creative_device):

@editable
PlayerManager: mayhem_game_player_manager = mayhem_game_player_manager{}

@editable
Gameboards: []mayhem_gameboard_manager = array{}

@editable
ItemShop: mayhem_item_shop = mayhem_item_shop{}

@editable
PetManager: mayhem_pet_manager = mayhem_pet_manager{}

@editable
TileAssets: tile_assets = tile_assets{}

@editable
GameplayAssets: gameplay_assets = gameplay_assets{}

@editable
GameplayDevices: gameplay_devices = gameplay_devices{}

@editable
DebugOptions: debug_options = debug_options{}

@editable
SelectionTimer: timer_device = timer_device{}

@editable
SelectionTime: float = 60.0

@editable
GameProperties: game_properties = game_properties{}

@editable
SelectionEndCinematic: cinematic_sequence_device = cinematic_sequence_device{}

@editable
SelectionTeleporter: teleporter_device = teleporter_device{}

var VotingButtons: []button_device = array{}
var SelectedGameboard: mayhem_gameboard_manager = mayhem_gameboard_manager{}
var AllPlayers: []player = array{}
var GameboardView: []cinematic_sequence_device = array{}

OnBegin<override>()<suspends>:void=
    Sleep(0.0)
    GameSetup()

    if (DebugOptions.AutostartEnabled?):
        SelectionStart()

GameSetup(): void =
    set AllPlayers = GetPlayspace().GetPlayers()
    SelectionTimer.SuccessEvent.Subscribe(SelectionEnd)
    PlayerManager.GameSetup(AllPlayers)

    for (Gameboard : Gameboards):
        set VotingButtons += array{Gameboard.SelectBoard}
        for (Teleporter : Gameboard.StartingAreaTeleporters):
            Teleporter.Disable()

    for (Index -> Button : VotingButtons):
        Button.InteractedWithEvent.Subscribe(gameboard_vote_handler{VerseDevice := Self, Index := Index}.HandleGameboardVote)

    if (set SelectedGameboard = Gameboards[0]):
        set SelectedGameboard.IsChosen = true
        SelectGameboard()
        Print("Default Gameboard Set.")

    PetManager.InitPets(Self)

    ItemShop.ItemShopSetup(Self)

SelectionStart(): void =
    SelectionTimer.SetMaxDuration(SelectionTime)
    SelectionTimer.Start()

SelectGameboard(): void =
        Print("Gameboard Selected:  {SelectedGameboard.Name}")
        for (Gameboard : Gameboards, Gameboard <> SelectedGameboard):
            set Gameboard.IsChosen = false
        set SelectedGameboard.IsChosen = true

SelectionEnd(MaybeAgent: ?agent): void =
    spawn:
        SelectionEndSequence()

SelectionEndSequence()<suspends>: void =
    SelectionEndCinematic.Play()
    SetGameboard()
    Sleep(3.0)

    PlayerManager.BoardSetup(Self)

    for (Index -> Player : AllPlayers):
        SelectionTeleporter.Activate(Player)
        if (CurrentCam := SelectedGameboard.GameboardViewSEQ[Index]):
            CurrentCam.Play(Player)
            if (GamePlayer := PlayerManager.GamePlayerMap[Player]):
                set GamePlayer.GameboardCam = CurrentCam

                if (CurrentItemShopCam := GameplayDevices.ItemShopCams[Index]):
                    set GamePlayer.ItemShopCam = CurrentItemShopCam
                    
                if (CurrentPetStoreCam := GameplayDevices.PetStoreCams[Index]):
                    set GamePlayer.PetStoreCam = CurrentPetStoreCam
                    

    PlayerManager.StartBoardgame()

SetGameboard(): void =
    Print("Setting Gameboard... ")
    GameplayDevices.InitGameplayDevices(AllPlayers)
    for (Teleporter : SelectedGameboard.StartingAreaTeleporters):
        Teleporter.Enable()

    CreateGameboard()

CreateGameboard(): void =
    Print("Creating Gameboard... ")
    for (Path : SelectedGameboard.TilePaths):
        for (Tile : Path.GameTiles):
            Tile.InitGameTile(Self)
            Tile.SpawnTileAssets()

gameplay_devices := class:

var AllPlayers: []player = array{}

@editable
HUDMessage: hud_message_device = hud_message_device{}

@editable
ItemShopTeleporter: teleporter_device = teleporter_device{}

@editable
PetStoreTeleporter: teleporter_device = teleporter_device{}

@editable
ReturnFromShop: trigger_device = trigger_device{}

@editable
ReturnFromPetStore: trigger_device = trigger_device{}

@editable
EndGameNormal: end_game_device = end_game_device{}

@editable
EndGameTie: end_game_device = end_game_device{}

@editable
GoldCashier: conditional_button_device = conditional_button_device{}

@editable
ItemShopCams: []cinematic_sequence_device = array{}

@editable
PetStoreCams: []cinematic_sequence_device = array{}

MakeMessage<localizes>(Text : string) : message = "{Text}"

InitGameplayDevices(Players: []player): void =
    set AllPlayers = Players

ShowHUDMessageAll(String: string): void =
    HUDMessage.SetText(MakeMessage(String))
    for (Player : AllPlayers):
        HUDMessage.Show(Player)

ShowHUDMessagePrivate(Agent: agent, String: string): void =
    HUDMessage.SetText(MakeMessage(String))
    HUDMessage.Show(Agent)

debug_options := class:

@editable
AutostartEnabled: logic = true

@editable
MinigamesEnabled: logic = true

tile_assets := class:

@editable
NormalTileAsset: creative_prop_asset = DefaultCreativePropAsset

@editable
BadTileAsset: creative_prop_asset = DefaultCreativePropAsset

@editable
SwitchTileAsset: creative_prop_asset = DefaultCreativePropAsset

@editable
ShopTileAsset: creative_prop_asset = DefaultCreativePropAsset

@editable
PetTileAsset: creative_prop_asset = DefaultCreativePropAsset

@editable
SpecialTileAsset: creative_prop_asset = DefaultCreativePropAsset

@editable
TileBaseAsset: creative_prop_asset = DefaultCreativePropAsset

gameplay_assets := class:

@editable
SoldOutAsset: creative_prop_asset = DefaultCreativePropAsset

gameboard_vote_handler := class():

VerseDevice: mayhem_game_setup_manager
Index: int

HandleGameboardVote(Agent: agent): void =
    block:

game_properties := class:

@editable
TotalTurns: int = 10

var CurrentTurn: int = 1

using { /Fortnite.com/Devices }
using { /Fortnite.com/Characters }
using { /Verse.org/Simulation }
using { /Verse.org/Random }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }

mayhem_game_player_manager := class(creative_device):

@editable
TestButton: button_device = button_device{}

@editable
Economy: economy = economy{}

@editable
Dice: []dice = array{}

@editable
Prompts: prompts = prompts{}

var GamePlayerMap: [agent]game_player = map{}
var AllGamePlayers: []game_player = array{}
var AllPlayers: []player = array{}
var Gameboard: mayhem_gameboard_manager = mayhem_gameboard_manager{}
var NextGamePlayerIndex: int = 0
var GameplayDevices: gameplay_devices = gameplay_devices{}
var DebugOptions: debug_options = debug_options{}
var GameProperties: game_properties = game_properties{}

var TurnOrderMap: [agent]int = map{}

SignalEvent: event() = event(){}

MakeMessage<localizes>(Text : string) : message = "{Text}"

OnBegin<override>()<suspends>:void=
    PregameSetup()

GameSetup(Players: []player): void =
    set AllPlayers = Players
    Prompts.TurnPrompt.RespondingButtonEvent.Subscribe(TurnPromptButtonPress)
    Prompts.DicePrompt.RespondingButtonEvent.Subscribe(DicePromptButtonPress)
    Prompts.ItemPrompt.RespondingButtonEvent.Subscribe(ItemPromptButtonPress)
    Prompts.StarTilePrompt.RespondingButtonEvent.Subscribe(StarPromptButtonPress)
    Prompts.SwitchTilePrompt.RespondingButtonEvent.Subscribe(SwitchPromptButtonPress)
    Prompts.ShopTilePrompt.RespondingButtonEvent.Subscribe(ShopPromptButtonPress)
    Prompts.PetTilePrompt.RespondingButtonEvent.Subscribe(PetPromptButtonPress)
    TestButton.InteractedWithEvent.Subscribe(HandleTestButton)
    Economy.StarGoldCheck.ActivatedEvent.Subscribe(StarGoldActivated)
    for (Index -> Player : AllPlayers):
        if (set GamePlayerMap[Player] = game_player{MaybeAgent := option{Player}}):
            if (GamePlayer := GamePlayerMap[Player]):
                set AllGamePlayers += array{GamePlayer}
                Print("Player {Index} Set Up")

BoardSetup(GameManager: mayhem_game_setup_manager): void =
    set Gameboard = GameManager.SelectedGameboard
    set GameplayDevices = GameManager.GameplayDevices
    set DebugOptions = GameManager.DebugOptions
    set GameProperties = GameManager.GameProperties
    GameplayDevices.ReturnFromShop.TriggeredEvent.Subscribe(ReturnFromItemShop)       
    GameplayDevices.ReturnFromPetStore.TriggeredEvent.Subscribe(ReturnFromPetStore)       

PregameSetup(): void =
    for (Die : Dice):
        Die.DiceSetup(Self)
    

HandleTestButton(Agent: agent): void =
    spawn:
        StartBoardgame()

StartBoardgame()<suspends>: void =
    Gameboard.GameboardIntro()
    set GameProperties.CurrentTurn = 1
    GameplayDevices.ShowHUDMessageAll("Board Game Starting!")
    MoveStar()
    Sleep(5.0)
    for (GamePlayer : GamePlayerMap):
        if (Player := GamePlayer.MaybeAgent?):
            for (Index := 0..4):
                Economy.GoldGranter.GrantItem(Player)
                GamePlayer.UpdateGoldEarned(operation_type.Add)

    NextPlayerTurn()

MoveStar(): void =
    Gameboard.SetStarLocation(Prompts)
    if (Economy.StarMover.TeleportTo[Gameboard.CurrentStarLocation.Translation, IdentityRotation()]):
        Print("Star Moved")

ChooseTurnOrder(): void =
    block:

NextPlayerTurn(): void =
    Print("Checking for next GamePlayer... ")
    if (Agent := AllGamePlayers[NextGamePlayerIndex].MaybeAgent?):
        Print("GamePlayer found!  Starting turn... ")
        if (NextGamePlayerIndex = 0):
            Print("Current Turn:  {GameProperties.CurrentTurn}")
        StartTurn(Agent)
        set NextGamePlayerIndex += 1

    else:
        Print("No GamePlayer found, checking next... ")
        set NextGamePlayerIndex += 1
        CheckForMinigame()

StartTurn(Agent: agent): void =
    Prompts.TurnPrompt.Show(Agent)

RollDice(Agent: agent, CurrentDice: []int): void =
    Print("Rolling Dice... ")
    if (GamePlayer := GamePlayerMap[Agent]):
        Print("Current GamePlayer Bonus:  {GamePlayer.RollBonus}")
        DiceSideSelection := GetRandomInt(0, 5)
        if (Pet := GamePlayer.MaybePet?):
            PetBonus := Pet.Dice.GetDiceBonus()
            Print("Pet Dice Bonus:  {PetBonus}")
            set GamePlayer.RollBonus += PetBonus
            if (RollDiceNumber := CurrentDice[DiceSideSelection]):
                Print("Roll: {RollDiceNumber} + {GamePlayer.RollBonus}")
                GameplayDevices.ShowHUDMessageAll("Roll:  {RollDiceNumber}, Bonus: {GamePlayer.RollBonus}")
                set GamePlayer.TilesToMove = RollDiceNumber + GamePlayer.RollBonus
                set GamePlayer.RollBonus = 0
            
        spawn:
            MovePlayer(Agent)

RollDiceResult(DiceNumbers: []int): int =
    SideResult := GetRandomInt(0, 5)
    if (RollResult := DiceNumbers[SideResult]):
        Print("Roll Result:  {RollResult}")

        return RollResult

    return 0

MovePlayer(Agent: agent)<suspends>: void =
    Print("MovePlayer started... ")
    if (GamePlayer := GamePlayerMap[Agent]):
        if (GamePlayer.IsFirstTurn?):
            if (Teleporter := Gameboard.TilePaths[0].GameTiles[0].Teleporter):
                Teleporter.Teleport(Agent)
                set GamePlayer.IsFirstTurn = false

        Sleep(1.0)
    
        Print("GamePlayer declared.")
        if (GamePlayer.TilesToMove > 0):
            Print("GamePlayer has {GamePlayer.TilesToMove} tiles to move.")
            CurrentPathIndex := GamePlayer.CurrentLocation(0)
            CurrentTileIndex := GamePlayer.CurrentLocation(1)
            if (CurrentTileIndex >= Gameboard.TilePaths[CurrentPathIndex].GameTiles.Length-1):   
                Print("GamePlayer is on last tile of path.")
                if:
                    NewPath := Gameboard.TilePaths[CurrentPathIndex].ExitProperties.ExitPath
                    NewIndex := Gameboard.TilePaths[CurrentPathIndex].ExitProperties.ExitIndex

                then:
                    GamePlayer.UpdateCurrentLocation(Agent, NewPath, NewIndex)

            else:
                Print("GamePlayer is not on last tile of path.")
                Path := GamePlayer.CurrentLocation(0)
                NewIndex := CurrentTileIndex + 1
                GamePlayer.UpdateCurrentLocation(Agent, Path, NewIndex)

            NewLocation := GamePlayer.GetCurrentLocation()
            if:
                NewTile := Gameboard.TilePaths[NewLocation(0)].GameTiles[NewLocation(1)]
                NewTileType := NewTile.Type
                TargetTeleporter := NewTile.Teleporter

            then:
                Print("New Tile Found... ...Teleporting.")
                TargetTeleporter.Teleport(Agent)
                if (Prompt := NewTile.TilePrompt?):
                    Print("Prompt Showing... ...Awaiting Response.")
                    Prompt.Show(Agent)
                    case (NewTile.Type):
                        tile_type.Star =>
                            Prompt.RespondingButtonEvent.Await()                

                        tile_type.Switch =>
                            Prompt.RespondingButtonEvent.Await()                

                        tile_type.Shop =>
                            Print("Landed On Shop Tile, Awaiting Next Action...")
                            race:
                                block:
                                    GameplayDevices.ReturnFromShop.TriggeredEvent.Await()
                                    Print("ReturnFromShop Triggered.")

                                block:
                                    SignalEvent.Await()

                        tile_type.Pet =>
                            Print("Landed On Pet Tile, Awaiting Next Action...")
                            race:
                                block:
                                    GameplayDevices.ReturnFromPetStore.TriggeredEvent.Await()
                                    Print("ReturnFromPetStore Triggered.")

                                block:
                                    SignalEvent.Await()           

                        _ =>

        
                    MovePlayer(Agent)
                    return

                else if (not NewTile.Type = tile_type.Switch or not NewTile.Type = tile_type.Shop):
                    Print("Decrementing Tiles To Move.")
                    set GamePlayer.TilesToMove -= 1
                    GamePlayer.UpdateTilesTraveled()
                if (GamePlayer.TilesToMove > 0):
                    Print("More tiles to move.  Running MovePlayer again.")
                    MovePlayer(Agent)

                else:
                    Print("No more tiles to move.  Landing on tile.")
                    LandedOnTile(Agent, NewTile.Type)
                    CheckForMinigame()
            else:
                Print("Failed")

        else:
            CheckForMinigame()

LandedOnTile(Agent: agent, Type: tile_type): void =
    case (Type):
        tile_type.Normal =>
            Print("Landed on Normal Tile.")
            if:
                GamePlayer := GamePlayerMap[Agent]
                Pet := GamePlayer.MaybePet?
                Pet.GoldBonus > 0

            then:
                GoldRewardAmount := Economy.GoldRewardAmount + Pet.GoldBonus
                GoldReward(Agent, GoldRewardAmount)

            else:
                GoldReward(Agent, Economy.GoldRewardAmount)

        tile_type.Bad =>
            Print("Landed on Bad Tile.")
            GoldPenalty(Agent, Economy.GoldRewardAmount)

        _ =>

CheckForMinigame(): void =
    if (NextGamePlayerIndex >= AllGamePlayers.Length):
        set NextGamePlayerIndex = 0
        StartMinigame()

    else:
        NextPlayerTurn()

StartMinigame(): void =
    if (DebugOptions.MinigamesEnabled?):
        block:

    else:
        spawn:
            MinigamePlaceholder()

MinigamePlaceholder()<suspends>: void =
    Sleep(3.0)
    GameplayDevices.ShowHUDMessageAll("Minigame Starting...")
    Sleep(5.0)
    GameplayDevices.ShowHUDMessageAll("Minigame Ending...")
    Sleep(5.0)
    if (GameProperties.CurrentTurn < GameProperties.TotalTurns):
        set GameProperties.CurrentTurn += 1
        NextPlayerTurn()

    else:
        EndingAwards()

GoldReward(Agent: agent, Amount: int): void =
    for (Index := 1..Amount):
        Economy.GoldGranter.GrantItem(Agent)
        if (GamePlayer := GamePlayerMap[Agent]):
            GamePlayer.UpdateGoldEarned(operation_type.Add)

GoldPenalty(Agent: agent, Amount: int): void =
    for (Index := 1..Amount):
        Economy.GoldRemover.Remove(Agent)
        if (GamePlayer := GamePlayerMap[Agent]):
            GamePlayer.UpdateGoldEarned(operation_type.Subtract)

TurnPromptButtonPress(Agent: agent, ButtonPressed: int): void =
    case (ButtonPressed):
        0 =>
            Prompts.DicePrompt.Show(Agent)

        1 =>
            Prompts.ItemPrompt.Show(Agent)

        _ =>

DicePromptButtonPress(Agent: agent, ButtonPressed: int): void =
    case (ButtonPressed):
        0 =>
            if (SelectedDice := GamePlayerMap[Agent].NormalDice):
                RollDice(Agent, SelectedDice)
                for (Index : SelectedDice):
                    Print("{Index}")
                
        1 =>
            if (SelectedDice := GamePlayerMap[Agent].SpecialDice):
                RollDice(Agent, SelectedDice)
                for (Index : SelectedDice):
                    Print("{Index}")

        _ =>
            Prompts.TurnPrompt.Show(Agent)

ItemPromptButtonPress(Agent: agent, ButtonPressed: int): void =
    case (ButtonPressed):

        _ =>
            Prompts.TurnPrompt.Show(Agent)


StarPromptButtonPress(Agent: agent, ButtonPressed: int): void =
    case (ButtonPressed):
        0 =>
            Print("StarPrompt Button 1 Selected.")
            Economy.StarGoldCheck.Activate(Agent)

        _ =>
            PromptCancelled()

SwitchPromptButtonPress(Agent: agent, ButtonPressed: int): void =
    case (ButtonPressed):
        0 =>
            Print("SwitchPrompt Button 1 Selected.")
            if:
                GamePlayer := GamePlayerMap[Agent]
                PathIndex := GamePlayer.CurrentLocation(0)
                TileIndex := GamePlayer.CurrentLocation(1)
                SwitchPathIndex := Gameboard.TilePaths[PathIndex].GameTiles[TileIndex].SwitchPathIndex
                SwitchTileIndex := Gameboard.TilePaths[SwitchPathIndex].ExitProperties.ExitIndex

            then:
                GamePlayer.UpdateCurrentLocation(Agent, SwitchPathIndex, -1)

        _ =>
            Print("SwitchPrompt Button 2 Selected.")
            PromptCancelled()

ShopPromptButtonPress(Agent: agent, ButtonPressed: int): void =
    case (ButtonPressed):
        0 =>
            SendToItemShop(Agent)

        _ =>
            PromptCancelled()

PetPromptButtonPress(Agent: agent, ButtonPressed: int): void =
    case (ButtonPressed):
        0 =>
            SendToPetStore(Agent)

        _ =>
            PromptCancelled()

PromptCancelled(): void =
    SignalEvent.Signal()
    Print("Cancelled Event Signaled.")

StarGoldActivated(Agent: agent): void =
    Economy.StarScoreAward.Activate(Agent)
    MoveStar()

SendToItemShop(Agent: agent): void =
    Print("Sending GamePlayer to Item Shop... ")
    GameplayDevices.ItemShopTeleporter.Teleport(Agent)
    if (CurrentGamePlayer := GamePlayerMap[Agent]):
        for (GamePlayer : GamePlayerMap):
            GamePlayer.GameboardCam.Stop(Agent)
            if (GamePlayer <> CurrentGamePlayer):
                if (CurrentAgent := GamePlayer.MaybeAgent?):
                    GamePlayer.ItemShopCam.Play(Agent)

SendToPetStore(Agent: agent): void =
    Print("Sending GamePlayer to Pet Store... ")
    GameplayDevices.PetStoreTeleporter.Teleport(Agent)
    if (CurrentGamePlayer := GamePlayerMap[Agent]):
        for (GamePlayer : GamePlayerMap):
            GamePlayer.GameboardCam.Stop(Agent)
            if (GamePlayer <> CurrentGamePlayer):
                if (CurrentAgent := GamePlayer.MaybeAgent?):
                    GamePlayer.PetStoreCam.Play(Agent)

ReturnFromItemShop(MaybeAgent: ?agent): void =
    Print("Returning From Item Shop... ")
    if:
        Agent := MaybeAgent?
        GamePlayer := GamePlayerMap[Agent]
    
    then:
        if (Teleporter := Gameboard.TilePaths[GamePlayer.CurrentLocation(0)].GameTiles[GamePlayer.CurrentLocation(1)].Teleporter):
            Print("Teleporter Found.")
            for (CurrentGamePlayer : GamePlayerMap):
                if (CurrentAgent := CurrentGamePlayer.MaybeAgent?):
                    CurrentGamePlayer.ItemShopCam.Stop(CurrentAgent)
                    CurrentGamePlayer.GameboardCam.Play(CurrentAgent)

            Teleporter.Teleport(Agent)

ReturnFromPetStore(MaybeAgent: ?agent): void =
    Print("Returning From Pet Store... ")
    if:
        Agent := MaybeAgent?
        GamePlayer := GamePlayerMap[Agent]
    
    then:
        if (Teleporter := Gameboard.TilePaths[GamePlayer.CurrentLocation(0)].GameTiles[GamePlayer.CurrentLocation(1)].Teleporter):
            Print("Teleporter Found.")
            for (CurrentGamePlayer : GamePlayerMap):
                if (CurrentAgent := CurrentGamePlayer.MaybeAgent?):
                    CurrentGamePlayer.PetStoreCam.Stop(CurrentAgent)
                    CurrentGamePlayer.GameboardCam.Play(CurrentAgent)

            Teleporter.Teleport(Agent)

EndingAwards(): void =
    CalculateWinner()

CalculateWinner(): void =
    var Winners: []game_player = array{}
    var WinnerScore: int = 0
    for (GamePlayer : GamePlayerMap):
        if (Agent := GamePlayer.MaybeAgent?):
            GamePlayerScore := Economy.StarScoreAward.GetCurrentScore(Agent)
            if (GamePlayerScore > WinnerScore):
                set Winners = array{GamePlayer}
                set WinnerScore = GamePlayerScore
            
            else if (GamePlayerScore = WinnerScore):
                set Winners += array{GamePlayer}

    if (Winners.Length > 1):
        var WinnerGold: int = 0
        for (GamePlayer : Winners):
            if (GamePlayer.CurrentGold > WinnerGold):
                set WinnerGold = GamePlayer.CurrentGold
                set Winners = array{GamePlayer}

            else if (GamePlayer.CurrentGold = WinnerGold):
                set Winners += array{GamePlayer}

    if (GamePlayer := Winners[0]):
        if (Agent := GamePlayer.MaybeAgent?):
            if (Winners.Length > 1):
                EndGame(Agent, true)

            else:
                EndGame(Agent, false)

EndGame(Agent: agent, IsTie: logic): void =
    if (not IsTie?):
        GameplayDevices.EndGameNormal.Activate(Agent)

    else:
        GameplayDevices.EndGameTie.Activate(Agent)

game_player := class:

var MaybeAgent: ?agent = false

var GameboardCam: cinematic_sequence_device = cinematic_sequence_device{}
var ItemShopCam: cinematic_sequence_device = cinematic_sequence_device{}
var PetStoreCam: cinematic_sequence_device = cinematic_sequence_device{}

var NormalDice: []int = array{1, 2, 3, 4, 5, 6}
var SpecialDice: []int = array{1, 2, 3, 4, 5, 6}

var IsFirstTurn: logic = true
var TilesToMove: int = 0
var RollBonus: int = 0
var CurrentLocation: tuple(int, int) = (0, 0)

var StarsCollected: int = 0
var TilesTraveled: int = 0
var MinigamesWon: int = 0
var GoldSpent: int = 0
var GoldEarned: int = 0
var CurrentGold: int = 0

var MaybePet: ?mayhem_pet = false
var PetMesh: mayhem_pet_mesh = mayhem_pet_mesh{}

SetPet(Pet: mayhem_pet): void =
    ClearPet()
    set MaybePet = option{Pet}
    for (Mesh : Pet.PetMeshes, Mesh.IsInUse = false):
        set PetMesh = Mesh
        set PetMesh.IsInUse = true
        spawn {UpdatePetPosition()}
        return

ClearPet(): void =
    PetMesh.Clear()
    set MaybePet = false
    set PetMesh.IsInUse = false

UpdatePetPosition()<suspends>: void =
    loop:
        Sleep(0.0)
        if:
            Agent := MaybeAgent?
            FortChar := Agent.GetFortCharacter[]

        then:
            Location := FortChar.GetTransform()
            if:
                PetMesh.Mover.IsValid[]

            then:
                PetMesh.Mover.MoveTo(Location.Translation, Location.Rotation, 0.1)

SetSpecialDice(Dice: dice): void =
    set SpecialDice = Dice.DiceSides.GetSideValues()
    for (Index : SpecialDice):
        Print("{Index}")

UpdateCurrentLocation(Agent: agent, NewPath: int, NewIndex: int): void =
    Print("New Path Index:  {NewPath}, New Tile Index: {NewIndex}.")
    set CurrentLocation = (NewPath, NewIndex)

GetCurrentLocation(): tuple(int, int) =
    return CurrentLocation

UpdateTilesTraveled(): void =
    set TilesTraveled += 1
    Print("Player has traveled {TilesTraveled} tiles.")

UpdateGoldEarned(Operation: operation_type): void =
    case (Operation):
        operation_type.Add =>
            set GoldEarned += 1
            set CurrentGold += 1
            Print("Player has earned {GoldEarned} gold total.")
            Print("Player has {CurrentGold} gold currently.")

        operation_type.Subtract =>
            if (CurrentGold > 0):
                set CurrentGold -= 1
                Print("Player has {CurrentGold} gold currently.")

UpdateStarsCollected(NewStars: int): void =
    set StarsCollected += NewStars
    Print("Player has collected {StarsCollected} stars total.")

economy := class:

@editable
GoldGranter: item_granter_device = item_granter_device{}

@editable
GoldRewardAmount: int = 3

@editable
GoldRemover: item_remover_device = item_remover_device{}

@editable
GoldPenaltyAmount: int = 3

@editable
StarGoldCheck: conditional_button_device = conditional_button_device{}

@editable
StarScoreAward: score_manager_device = score_manager_device{}

@editable
StarMover: creative_prop = creative_prop{}

dice := class:

@editable
Color: string = " "

@editable
Button: button_device = button_device{}

@editable
DiceSides: dice_side = dice_side{}

@editable
Prompt: popup_dialog_device = popup_dialog_device{}

var VerseDevice: mayhem_game_player_manager = mayhem_game_player_manager{}

DiceSetup(MainDevice: mayhem_game_player_manager): void =
    Button.InteractedWithEvent.Subscribe(ShowPrompt)
    Prompt.RespondingButtonEvent.Subscribe(HandleButtonPress)
    set VerseDevice = MainDevice
    Print("{Color} Dice set up.")

ShowPrompt(Agent: agent): void =
    Prompt.Show(Agent)

HandleButtonPress(Agent: agent, ButtonPressed: int): void =
    case (ButtonPressed):
        0 =>
            SelectDice(Agent)

        _ =>
        
SelectDice(Agent: agent): void =
    if (GamePlayer := VerseDevice.GamePlayerMap[Agent]):
        GamePlayer.SetSpecialDice(Self)
        Print("Selected {Color} Dice.")

dice_side := class:

@editable
Side_0: int = 1

@editable
Side_1: int = 2

@editable
Side_2: int = 3

@editable
Side_3: int = 4

@editable
Side_4: int = 5

@editable
Side_5: int = 6

GetSideValues(): []int =
    Sides := array{Side_0, Side_1, Side_2, Side_3, Side_4, Side_5}

    return Sides

prompts := class:

@editable
TurnPrompt: popup_dialog_device = popup_dialog_device{}

@editable
DicePrompt: popup_dialog_device = popup_dialog_device{}

@editable
ItemPrompt: popup_dialog_device = popup_dialog_device{}

@editable
StarTilePrompt: popup_dialog_device = popup_dialog_device{}

@editable
SwitchTilePrompt: popup_dialog_device = popup_dialog_device{}

@editable
ShopTilePrompt: popup_dialog_device = popup_dialog_device{}

@editable
PetTilePrompt: popup_dialog_device = popup_dialog_device{}

operation_type := enum:

Add
Subtract

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /Verse.org/Random }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }

mayhem_gameboard_manager := class(creative_device):

@editable
Name: string = "Gameboard"

@editable
SelectBoard: button_device = button_device{}

@editable
StartingAreaTeleporters: []teleporter_device = array{}

@editable
TilePaths: []tile_path = array{}

@editable
GameboardViewSEQ: []cinematic_sequence_device = array{}

var IsChosen: logic = false
var CurrentStarLocation: transform = transform{}

OnBegin<override>()<suspends>:void=
    block:

GameboardIntro(): void =
    block:

SetStarLocation(Prompts: prompts): void =
    var NormalTiles: []game_tile = array{}
    for (Path : TilePaths):
        for (Tile : Path.GameTiles, Tile.Type = tile_type.Normal, Tile.PossibleStarTile = true):
            set NormalTiles += array{Tile}

    StarTileSelection := GetRandomInt(0, NormalTiles.Length-1)
    if (SelectedTile := NormalTiles[StarTileSelection]):
        var StarTiles: []game_tile = array{}
        set SelectedTile.Type = tile_type.Star
        set SelectedTile.PossibleStarTile = false
        set SelectedTile.TilePrompt = option{Prompts.StarTilePrompt}
        if (SelectedTile.TilePosition.IsValid[]):
            set CurrentStarLocation = SelectedTile.TilePosition.GetTransform()
            for (Path : TilePaths):
                for (Tile : Path.GameTiles, Tile.Type = tile_type.Star):
                    set StarTiles += array{Tile}
                    for (StarTile : StarTiles, SelectedTile <> StarTile):
                        set StarTile.Type = tile_type.Normal
                        set StarTile.PossibleStarTile = true

game_tile := class:

@editable
Teleporter: teleporter_device = teleporter_device{}

@editable
TilePosition: creative_prop = creative_prop{}

@editable
var Type: tile_type = tile_type.Normal

@editable
var PossibleStarTile: logic = false

@editable
var SwitchPathIndex: int = 0

var GameManager: mayhem_game_setup_manager = mayhem_game_setup_manager{}
var TilePrompt: ?popup_dialog_device = false

InitGameTile(Manager: mayhem_game_setup_manager): void =
    set GameManager = Manager
    case (Type):
        tile_type.Switch =>
            set TilePrompt = option{GameManager.PlayerManager.Prompts.SwitchTilePrompt}

        tile_type.Star =>
            set TilePrompt = option{GameManager.PlayerManager.Prompts.StarTilePrompt}

        tile_type.Shop =>
            set TilePrompt = option{GameManager.PlayerManager.Prompts.ShopTilePrompt}

        tile_type.Pet =>
            set TilePrompt = option{GameManager.PlayerManager.Prompts.PetTilePrompt}

        _ =>

SpawnTileAssets(): void =
    if (TilePosition.IsValid[]):
        case (Type):
            tile_type.Normal =>
                SpawnProp(GameManager.TileAssets.NormalTileAsset, TilePosition.GetTransform())

            tile_type.Bad =>
                SpawnProp(GameManager.TileAssets.BadTileAsset, TilePosition.GetTransform())

            tile_type.Switch =>
                SpawnProp(GameManager.TileAssets.SwitchTileAsset, TilePosition.GetTransform())

            tile_type.Shop =>
                SpawnProp(GameManager.TileAssets.ShopTileAsset, TilePosition.GetTransform())

            tile_type.Pet =>
                SpawnProp(GameManager.TileAssets.PetTileAsset, TilePosition.GetTransform())

            tile_type.Special =>
                SpawnProp(GameManager.TileAssets.SpecialTileAsset, TilePosition.GetTransform())

            _ =>

tile_path := class:

@editable
GameTiles: []game_tile = array{}

@editable
ExitProperties: exit_properties = exit_properties{}

star := class:

@editable
StarMover: creative_prop = creative_prop{}

exit_properties := struct:

@editable
ExitPath: int = 0

@editable
ExitIndex: int = 0

tile_type := enum:

Start
Normal
Bad
Star
Switch
Shop
Pet
Special

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }

mayhem_item_shop := class(creative_device):

@editable
LeaveShopButton: button_device = button_device{}

@editable
Items: []mayhem_item = array{}

var PlayerManager: mayhem_game_player_manager = mayhem_game_player_manager{}
var GameplayDevices: gameplay_devices = gameplay_devices{}
var GameplayAssets: gameplay_assets = gameplay_assets{}

ItemShopSetup(GameManager: mayhem_game_setup_manager): void =
    set GameplayDevices = GameManager.GameplayDevices
    set GameplayAssets = GameManager.GameplayAssets
    set PlayerManager = GameManager.PlayerManager
    LeaveShopButton.InteractedWithEvent.Subscribe(LeaveItemShop)
    for (Item : Items):
        Item.InitItem(Self)

LeaveItemShop(Agent: agent): void =
    Print("Item Shop Exit Button pressed.")
    GameplayDevices.ReturnFromShop.Trigger(Agent)

mayhem_item := class:

@editable
Name: string = "Item"

@editable
Price: int = 10

@editable
Devices: mayhem_shop_devices = mayhem_shop_devices{}

var PropHoldingArea: transform = transform{}
var ItemLocation: transform = transform{}
var VerseDevice: mayhem_item_shop = mayhem_item_shop{}

InitItem(MainDevice: mayhem_item_shop): void =
    set VerseDevice = MainDevice
    Devices.Trigger.TriggeredEvent.Subscribe(ItemSelected)
    Devices.Billboard.SetText(VerseDevice.GameplayDevices.MakeMessage("{Price}"))
    set ItemLocation = Devices.Placer.GetTransform()
    Print("{Name} initialized.")

ItemSelected(MaybeAgent: ?agent): void =
    if (Agent := MaybeAgent?):
        Devices.Remover.Remove(Agent)
        VerseDevice.GameplayDevices.GoldCashier.SetItemCountRequired(0, Price)
        VerseDevice.GameplayDevices.GoldCashier.Activate(Agent)
        spawn {PurchaseAttempt(Agent)}

PurchaseAttempt(Agent: agent)<suspends>: void =
    race:
        block:
            VerseDevice.GameplayDevices.GoldCashier.ActivatedEvent.Await()
            Devices.Granter.GrantItem(Agent)
            VerseDevice.GameplayDevices.ShowHUDMessageAll("Purchased {Name}")
            if:
                Devices.PlacerMover.IsValid[]
                Devices.PlacerMover.TeleportTo[PropHoldingArea]
            VerseDevice.LeaveItemShop(Agent)
            SpawnProp(VerseDevice.GameplayAssets.SoldOutAsset, ItemLocation)
            VerseDevice.PlayerManager.GoldPenalty(Agent, Price)

        block:
            VerseDevice.GameplayDevices.GoldCashier.NotEnoughItemsEvent.Await()
            VerseDevice.GameplayDevices.ShowHUDMessageAll("Not Enough Gold.")

mayhem_shop_devices := class:

@editable
Placer: item_placer_device = item_placer_device{}

@editable
PlacerMover: creative_prop = creative_prop{}

@editable
Trigger: trigger_device = trigger_device{}

@editable
Granter: item_granter_device = item_granter_device{}

@editable
Remover: item_remover_device = item_remover_device{}

@editable
Billboard: billboard_device = billboard_device{}

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /Verse.org/Random }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }

mayhem_pet_manager := class(creative_device):

@editable
TestButton: button_device = button_device{}

@editable
LeavePetStoreButton: button_device = button_device{}

@editable
Pets: []mayhem_pet = array{}

var PlayerManager: mayhem_game_player_manager = mayhem_game_player_manager{}
var GameplayDevices: gameplay_devices = gameplay_devices{}

InitPets(GameManager: mayhem_game_setup_manager): void =
    TestButton.InteractedWithEvent.Subscribe(SetTestPet)
    LeavePetStoreButton.InteractedWithEvent.Subscribe(LeavePetStore)
    set PlayerManager = GameManager.PlayerManager
    set GameplayDevices = GameManager.GameplayDevices
    for (Pet : Pets):
        Pet.InitPet(Self)

SetTestPet(Agent: agent): void =
    if (GamePlayer := PlayerManager.GamePlayerMap[Agent]):
        if (Pet := Pets[0]):
            GamePlayer.SetPet(Pet)

LeavePetStore(Agent: agent): void =
    GameplayDevices.ReturnFromShop.Trigger(Agent)

mayhem_pet := class:

@editable
Name: string = "Pet"

@editable
Color: pet_color = pet_color.None

@editable
Price: int = 10

@editable
Dice: mayhem_pet_dice = mayhem_pet_dice{}

@editable
GoldBonus: int = 0

@editable
Devices: mayhem_pet_devices = mayhem_pet_devices{}

@editable
PetMeshes: []mayhem_pet_mesh = array{}

var VerseDevice: mayhem_pet_manager = mayhem_pet_manager{}

InitPet(MainDevice: mayhem_pet_manager): void =
    Print("{Name} setup started... ")
    set VerseDevice = MainDevice
    Devices.PurchaseButton.InteractedWithEvent.Subscribe(PetSelected)
    Devices.Billboard.SetText(VerseDevice.GameplayDevices.MakeMessage("X {Price}"))
    var MeshNumber: int = 0
    for (Mesh : PetMeshes):
        set Mesh.PropHoldingLocation = Mesh.Mover.GetTransform()
        set MeshNumber += 1

    Print("{MeshNumber} Meshes set up for {Name}")

PetSelected(Agent: agent): void =
    VerseDevice.GameplayDevices.GoldCashier.SetItemCountRequired(0, Price)
    VerseDevice.GameplayDevices.GoldCashier.Activate(Agent)
    spawn{PurchaseAttempt(Agent)}

PurchaseAttempt(Agent: agent)<suspends>: void =
    race:
        block:
            VerseDevice.GameplayDevices.GoldCashier.ActivatedEvent.Await()
            VerseDevice.GameplayDevices.ShowHUDMessageAll("Purchased {Name}")
            if (GamePlayer := VerseDevice.PlayerManager.GamePlayerMap[Agent]):
                GamePlayer.SetPet(Self)
                VerseDevice.LeavePetStore(Agent)

        block:
            VerseDevice.GameplayDevices.GoldCashier.NotEnoughItemsEvent.Await()
            VerseDevice.GameplayDevices.ShowHUDMessageAll("Not Enough Gold.")

mayhem_pet_dice := class:

@editable
Sides: []int = array{}

GetDiceBonus(): int =
    DiceSide := GetRandomInt(0, Sides.Length - 1)

    if (DiceRoll := Sides[DiceSide]):
        return DiceRoll

    return 0

mayhem_pet_mesh := class:

@editable
Mesh: creative_prop = creative_prop{}

@editable
Mover: creative_prop = creative_prop{}

var IsInUse: logic = false
var PropHoldingLocation: transform = transform{}

Clear(): void =
    if {Mover.TeleportTo[PropHoldingLocation]}

mayhem_pet_devices := class:

@editable
PurchaseButton: button_device = button_device{}

@editable
Billboard: billboard_device = billboard_device{}

pet_color := enum:

None
Green
Blue
Red
Orange
Pink
Purple
3

Error messages can be seen in this post: [Blocker] Cook TImeout / Failure to Launch Session