Untitled

ausing { /Fortnite.com/Devices }
using { /Fortnite.com/Characters }
using { /Fortnite.com/Game }
using { /Verse.org/Simulation }
using { /Verse.org/Random }

assassin_contract_device := class(creative_device):
    @editable
    SignalRemoteManager : signal_remote_manager_device = signal_remote_manager_device{}
    @editable
    ScoreManagerAdd : score_manager_device = score_manager_device{} # For awarding money
    @editable
    ScoreManagerSubtract : score_manager_device = score_manager_device{} # For subtracting money
    @editable
    ContractReward : int = 100 # Amount to transfer

    var ContractActive : logic = false
    var Assassin : ?agent = false
    var Target : ?agent = false

    OnBegin<override>()<suspends>:void=
        Print("Device OnBegin running")
        Sleep(2.0)
        SignalRemoteManager.PrimarySignalEvent.Subscribe(OnContractTriggered)
        Print("SignalRemoteManager PrimarySignalEvent subscribed")

        Agents := GetPlayspace().GetParticipants()
        for (A : Agents, C := A.GetFortCharacter[]):
            C.EliminatedEvent().Subscribe(OnAgentEliminated)

    OnContractTriggered(Agent:agent):void=
        Print("Signal remote triggered by agent")
        if (ContractActive = true):
            Print("Contract already active, ignoring trigger")
            return

        Agents := GetPlayspace().GetParticipants()
        if (Agents.Length < 2):
            Print("Not enough agents for a contract")
            return

        StartContract(Agents)

    StartContract(Agents:[]agent):void=
        set ContractActive = true
        AssassinIndex := GetRandomInt(0, Agents.Length - 1)
        if (AssassinAgent := Agents[AssassinIndex]):
            set Assassin = option{AssassinAgent}
            var ExcludeIndices : []int = array{AssassinIndex}
            TargetIndex := GetRandomIntExcludingMultipleHelper(0, Agents.Length - 1, ExcludeIndices)
            if (TargetAgent := Agents[TargetIndex]):
                set Target = option{TargetAgent}
                Print("New contract: Assassin is agent {AssassinIndex}. Target is agent {TargetIndex}.")

    OnAgentEliminated(Result:elimination_result):void=
        Print("Elimination event detected!")
        if (ContractActive = false):
            return

        if (AssassinAgent := Assassin?, TargetAgent := Target?):
            EliminatedChar := Result.EliminatedCharacter

            if (EliminatorChar := Result.EliminatingCharacter?, EliminatorAgent := EliminatorChar.GetAgent[]):
                # If Assassin eliminates Target, transfer money using Score Managers
                if (EliminatorAgent = AssassinAgent):
                    Print("You are the Assassin!")
                    if (EliminatedChar = TargetAgent.GetFortCharacter[]):
                        Print("CONTRACT COMPLETE: Assassin eliminated the correct Target!")
                        # Award money to Assassin
                        ScoreManagerAdd.SetScoreAward(ContractReward)
                        ScoreManagerAdd.Activate(AssassinAgent)
                        # Subtract money from Target
                        ScoreManagerSubtract.SetScoreAward(ContractReward)
                        ScoreManagerSubtract.Activate(TargetAgent)
                        Print("Money transferred: {ContractReward} awarded to Assassin, subtracted from Target")
                        EndContract()
                    else:
                        Print("Assassin eliminated someone who was NOT the Target.")
                    return

                # Print for Target
                if (EliminatorAgent = TargetAgent):
                    Print("You are the Target!")
                    return

            # Print for the eliminated player if they are the Target
            if (EliminatedChar = TargetAgent.GetFortCharacter[]):
                Print("You were the Target and got eliminated.")
                return
            # Print for the eliminated player if they are the Assassin
            if (EliminatedChar = AssassinAgent.GetFortCharacter[]):
                Print("You were the Assassin and got eliminated (contract failed).")
                EndContract()
                return

            # Not part of the contract
            Print("You are not part of the contract.")

    EndContract():void=
        set ContractActive = false
        set Assassin = false
        set Target = false
        Print("Contract ended/reset")

    GetRandomIntExcludingMultipleHelper(MinValue:int, MaxValue:int, Exclude:[]int):int=
        var R:int = GetRandomInt(MinValue, MaxValue)
        for (E : Exclude):
            if (R = E):
                set R = GetRandomIntExcludingMultipleHelper(MinValue, MaxValue, Exclude)
        return R