Create a Matchmaking Channel

Last updated on 29 August, 2022 5:01 AM

Use the following function to create a matchmaking channel:

Go

ok, err := matchmakingService.CreateChannelHandler(input)
if err != nil {
    return err
}
return nil

Python

from accelbyte_py_sdk.api.matchmaking import create_channel_handler
from accelbyte_py_sdk.api.matchmaking.models import ModelsAllianceRule
from accelbyte_py_sdk.api.matchmaking.models import ModelsAllianceFlexingRule
from accelbyte_py_sdk.api.matchmaking.models import ModelsChannelRequest
from accelbyte_py_sdk.api.matchmaking.models import ModelsFlexingRule
from accelbyte_py_sdk.api.matchmaking.models import ModelsMatchOption
from accelbyte_py_sdk.api.matchmaking.models import ModelsMatchOptionRule
from accelbyte_py_sdk.api.matchmaking.models import ModelsMatchingRule
from accelbyte_py_sdk.api.matchmaking.models import ModelsRuleSet
from accelbyte_py_sdk.api.matchmaking.models import ModelsSubGameMode

result, error = create_channel_handler(
    body=ModelsChannelRequest.create(
        deployment="<deployment>",
        description="<description>",
        find_match_timeout_seconds=300,
        game_mode="<game-mode>",
        max_delay_ms=300,
        rule_set=ModelsRuleSet.create(
            alliance=ModelsAllianceRule.create(
                max_number=2,
                min_number=2,
                player_max_number=2,
                player_min_number=2
            ),
            alliance_flexing_rule=[
                ModelsAllianceFlexingRule.create(
                    duration=300,
                    max_number=2,
                    min_number=2,
                    player_max_number=2,
                    player_min_number=2
                )
            ],
            flexing_rule=[
                ModelsFlexingRule.create(
                    attribute="<attribute>",
                    criteria="<criteria>",
                    duration=300,
                    reference=10
                )
            ],
            match_options=ModelsMatchOptionRule.create(
                options=[
                    ModelsMatchOption.create(
                        name="<name>",
                        type_="<type>"
                    )
                ]
            ),
            matching_rule=[
                ModelsMatchingRule.create(
                    attribute="<attribute>",
                    criteria="<criteria>",
                    reference=10
                )
            ],
            sub_game_modes={
                "<game_mode>": ModelsSubGameMode.create(
                    alliance=ModelsAllianceRule.create(
                        max_number=2,
                        min_number=2,
                        player_max_number=2,
                        player_min_number=2
                    ),
                    alliance_flexing_rule=[
                        ModelsAllianceFlexingRule.create(
                            duration=300,
                            max_number=2,
                            min_number=2,
                            player_max_number=2,
                            player_min_number=2
                        )
                    ],
                    name="<game_mode>"
                )
            }
        ),
        session_queue_timeout_seconds=10000
    )
)
if error:
    print(error)

C#

Matchmaking wMatchmaking = new Matchmaking(sdk);

ModelsChannelRequest channelReq = new ModelsChannelRequest()
{
    Deployment = "<deployment_name>",
    Description = "<channel_description>",
    FindMatchTimeoutSeconds = 3600,
    GameMode = "<channel_name>",
    Joinable = false,
    MaxDelayMs = 0,
    SessionQueueTimeoutSeconds = 0,
    SocialMatchmaking = false,
    UseSubGamemode = false,
    RuleSet = new ModelsRuleSet()
    {
        Alliance = new ModelsAllianceRule()
        {
            MaxNumber = 2,
            MinNumber = 2,
            PlayerMaxNumber = 1,
            PlayerMinNumber = 1
        },
        AllianceFlexingRule = new List<ModelsAllianceFlexingRule>(),
        FlexingRule = new List<ModelsFlexingRule>(),
        MatchOptions = new ModelsMatchOptionRule()
        {
            Options = new List<ModelsMatchOption>()
        },
        MatchingRule = new List<ModelsMatchingRule>(),
        SubGameModes = new Dictionary<string, ModelsSubGameMode>()
    }
};

ModelsCreateChannelResponse? cResp = wMatchmaking.CreateChannelHandler(CreateChannelHandler.Builder
    .Build(channelReq, sdk.Namespace));