Panorama Voting System

using Plugify;
using static s2sdk.s2sdk;

public unsafe class VoteExample : Plugin
{
    public void OnPluginStart()
    {
        // Create a simple vote for all players
        PanoramaSendYesNoVoteToAll(
            duration: 30.0,
            caller: VOTE_CALLER_SERVER,
            voteTitle: "#SFUI_vote_passed",
            detailStr: "Restart the match?",
            votePassTitle: "#SFUI_vote_passed",
            detailPassStr: "Match restarting",
            failReason: 0,
            result: OnVoteResult,
            handler: OnVoteHandler
        );
    }

    // Called to determine if vote passes
    private bool OnVoteResult(int numVotes, int yesVotes, int noVotes,
                              int numClients, int[] clientInfoSlot, int[] clientInfoItem)
    {
        PrintToServer($"Vote finished: {yesVotes} Yes, {noVotes} No, " +
                     $"{numVotes}/{numClients} voted\n");

        // Simple majority: more than 50% yes votes
        return yesVotes > noVotes;
    }

    // Called for vote events
    private void OnVoteHandler(VoteAction action, int param1, int param2)
    {
        switch (action)
        {
            case VoteAction.Start:
                PrintToServer("Vote started!\n");
                break;

            case VoteAction.Vote:
                int clientSlot = param1;
                int choice = param2;
                string vote = choice == (int)CastVote.VOTE_OPTION1 ? "Yes" : "No";
                PrintToServer($"Player {clientSlot} voted: {vote}\n");
                break;

            case VoteAction.End:
                VoteEndReason reason = (VoteEndReason)param2;
                PrintToServer($"Vote ended: {reason}\n");

                // Execute action based on result
                // Note: This is called AFTER OnVoteResult determines pass/fail
                break;
        }
    }
}

#include <plugify/cpp_plugin.hpp>
#include "s2sdk.hpp"

using namespace s2sdk;

class VoteExample : public plg::IPluginEntry {
public:
    void OnPluginStart() override {
        PanoramaSendYesNoVoteToAll(
            30.0,
            VOTE_CALLER_SERVER,
            "#SFUI_vote_passed",
            "Restart the match?",
            "#SFUI_vote_passed",
            "Match restarting",
            0,
            // Result callback - determines pass/fail
            [](int numVotes, int yesVotes, int noVotes, int numClients,
               const plg::vector<int>& clientInfoSlot,
               const plg::vector<int>& clientInfoItem) -> bool {
                PrintToServer(std::format("Vote: {} Yes, {} No, {}/{} voted\n",
                             yesVotes, noVotes, numVotes, numClients).c_str());
                return yesVotes > noVotes;  // Simple majority
            },
            // Handler callback - vote events
            [](VoteAction action, int param1, int param2) {
                switch (action) {
                    case VoteAction::Start:
                        PrintToServer("Vote started!\n");
                        break;
                    case VoteAction::Vote: {
                        int clientSlot = param1;
                        int choice = param2;
                        const char* vote = choice == static_cast<int>(CastVote::VOTE_OPTION1)
                                          ? "Yes" : "No";
                        PrintToServer(std::format("Player {} voted: {}\n",
                                     clientSlot, vote).c_str());
                        break;
                    }
                    case VoteAction::End: {
                        VoteEndReason reason = static_cast<VoteEndReason>(param2);
                        PrintToServer("Vote ended\n");
                        break;
                    }
                }
            }
        );
    }
};

from plugify.plugin import Plugin
from plugify.pps import s2sdk as s2

class VoteExample(Plugin):
    def plugin_start(self):
        def on_vote_result(num_votes, yes_votes, no_votes, num_clients,
                          client_info_slot, client_info_item):
            s2.PrintToServer(f"Vote: {yes_votes} Yes, {no_votes} No, " +
                           f"{num_votes}/{num_clients} voted\n")
            return yes_votes > no_votes  # Simple majority

        def on_vote_handler(action, param1, param2):
            if action == s2.VoteAction.Start:
                s2.PrintToServer("Vote started!\n")
            elif action == s2.VoteAction.Vote:
                client_slot = param1
                choice = param2
                vote = "Yes" if choice == s2.CastVote.VOTE_OPTION1 else "No"
                s2.PrintToServer(f"Player {client_slot} voted: {vote}\n")
            elif action == s2.VoteAction.End:
                reason = param2  # VoteEndReason
                s2.PrintToServer(f"Vote ended: {reason}\n")

        s2.PanoramaSendYesNoVoteToAll(
            '''duration='''30.0,
            '''caller='''s2.VOTE_CALLER_SERVER,
            '''vote_title='''"#SFUI_vote_passed",
            '''detail_str='''"Restart the match?",
            '''vote_pass_title='''"#SFUI_vote_passed",
            '''detail_pass_str='''"Match restarting",
            '''fail_reason='''0,
            '''result='''on_vote_result,
            '''handler='''on_vote_handler
        )

package main

import (
    "fmt"
    "s2sdk"
    "github.com/untrustedmodders/go-plugify"
)

func init() {
    plugify.OnPluginStart(func() {
        // Result callback
        onVoteResult := func(numVotes, yesVotes, noVotes, numClients int,
                            clientInfoSlot, clientInfoItem []int) bool {
            s2sdk.PrintToServer(fmt.Sprintf("Vote: %d Yes, %d No, %d/%d voted\n",
                               yesVotes, noVotes, numVotes, numClients))
            return yesVotes > noVotes
        }

        // Handler callback
        onVoteHandler := func(action s2sdk.VoteAction, param1, param2 int) {
            switch action {
            case s2sdk.VoteActionStart:
                s2sdk.PrintToServer("Vote started!\n")
            case s2sdk.VoteActionVote:
                clientSlot := param1
                choice := param2
                vote := "No"
                if choice == int(s2sdk.VOTE_OPTION1) {
                    vote = "Yes"
                }
                s2sdk.PrintToServer(fmt.Sprintf("Player %d voted: %s\n",
                                   clientSlot, vote))
            case s2sdk.VoteActionEnd:
                reason := param2  // VoteEndReason
                s2sdk.PrintToServer(fmt.Sprintf("Vote ended: %d\n", reason))
            }
        }

        s2sdk.PanoramaSendYesNoVoteToAll(
            30.0,
            s2sdk.VOTE_CALLER_SERVER,
            "#SFUI_vote_passed",
            "Restart the match?",
            "#SFUI_vote_passed",
            "Match restarting",
            0,
            onVoteResult,
            onVoteHandler,
        )
    })
}

import { Plugin } from 'plugify';
import * as s2 from ':s2sdk';

export class VoteExample extends Plugin {
    pluginStart() {
        s2.PanoramaSendYesNoVoteToAll(
            30.0,
            s2.VOTE_CALLER_SERVER,
            "#SFUI_vote_passed",
            "Restart the match?",
            "#SFUI_vote_passed",
            "Match restarting",
            0,
            // Result callback
            (numVotes, yesVotes, noVotes, numClients,
             clientInfoSlot, clientInfoItem) => {
                s2.PrintToServer(`Vote: ${yesVotes} Yes, ${noVotes} No, ` +
                               `${numVotes}/${numClients} voted\n`);
                return yesVotes > noVotes;
            },
            // Handler callback
            (action, param1, param2) => {
                if (action === s2.VoteAction.Start) {
                    s2.PrintToServer("Vote started!\n");
                } else if (action === s2.VoteAction.Vote) {
                    const clientSlot = param1;
                    const choice = param2;
                    const vote = choice === s2.CastVote.VOTE_OPTION1 ? "Yes" : "No";
                    s2.PrintToServer(`Player ${clientSlot} voted: ${vote}\n`);
                } else if (action === s2.VoteAction.End) {
                    const reason = param2;
                    s2.PrintToServer(`Vote ended: ${reason}\n`);
                }
            }
        );
    }
}

local plugify = require 'plugify'
local Plugin = plugify.Plugin
local s2 = require 's2sdk'

local VoteExample = {}
setmetatable(VoteExample, { __index = Plugin })

function VoteExample:plugin_start()
    local function on_vote_result(num_votes, yes_votes, no_votes, num_clients,
                                  client_info_slot, client_info_item)
        s2:PrintToServer(string.format("Vote: %d Yes, %d No, %d/%d voted\n",
                        yes_votes, no_votes, num_votes, num_clients))
        return yes_votes > no_votes
    end

    local function on_vote_handler(action, param1, param2)
        if action == s2.VoteAction.Start then
            s2:PrintToServer("Vote started!\n")
        elseif action == s2.VoteAction.Vote then
            local client_slot = param1
            local choice = param2
            local vote = choice == s2.CastVote.VOTE_OPTION1 and "Yes" or "No"
            s2:PrintToServer(string.format("Player %d voted: %s\n",
                            client_slot, vote))
        elseif action == s2.VoteAction.End then
            local reason = param2
            s2:PrintToServer(string.format("Vote ended: %d\n", reason))
        end
    end

    s2:PanoramaSendYesNoVoteToAll(
        30.0,
        s2.VOTE_CALLER_SERVER,
        "#SFUI_vote_passed",
        "Restart the match?",
        "#SFUI_vote_passed",
        "Match restarting",
        0,
        on_vote_result,
        on_vote_handler
    )
end

local M = {}
M.VoteExample = VoteExample
return M

// Include specific players by slot
public ulong BuildRecipients(int[] playerSlots)
{
    ulong recipients = 0;
    foreach (int slot in playerSlots)
    {
        if (slot >= 0 && slot < 64)
        {
            recipients |= (1UL << slot);
        }
    }
    return recipients;
}

// Examples:
// Only player slot 0
ulong player0Only = 1UL << 0;  // = 1

// Only player slot 5
ulong player5Only = 1UL << 5;  // = 32

// Players 0, 1, and 2
ulong players012 = (1UL << 0) | (1UL << 1) | (1UL << 2);  // = 7

// Use in vote
int[] targetPlayers = { 0, 2, 5 };
ulong recipients = BuildRecipients(targetPlayers);

PanoramaSendYesNoVote(
    duration: 30.0,
    caller: VOTE_CALLER_SERVER,
    voteTitle: "#SFUI_vote_passed",
    detailStr: "Kick player?",
    votePassTitle: "#SFUI_vote_passed",
    detailPassStr: "Player kicked",
    failReason: 0,
    recipients: recipients,
    result: OnVoteResult,
    handler: OnVoteHandler
);

def build_recipients(player_slots):
    """Build recipients bitmask from player slot list"""
    recipients = 0
    for slot in player_slots:
        if 0 <= slot < 64:
            recipients |= (1 << slot)
    return recipients

# Examples:
player_0_only = 1 << 0  # = 1
player_5_only = 1 << 5  # = 32
players_012 = (1 << 0) | (1 << 1) | (1 << 2)  # = 7

# Use in vote
target_players = [0, 2, 5]
recipients = build_recipients(target_players)

s2.PanoramaSendYesNoVote(
    '''duration='''30.0,
    '''caller='''s2.VOTE_CALLER_SERVER,
    '''vote_title='''"#SFUI_vote_passed",
    '''detail_str='''"Kick player?",
    '''vote_pass_title='''"#SFUI_vote_passed",
    '''detail_pass_str='''"Player kicked",
    '''fail_reason='''0,
    '''recipients='''recipients,
    '''result='''on_vote_result,
    '''handler='''on_vote_handler
)