Contract Example: Team-Based Multiplayer - Summer

What This Guide Covers

This guide illustrates a red-vs-blue team-mode contract:

Team creation with Summer.teams.create
Team assignment and auto-balance
Team-specific spawn points
Team score via Summer.score.add_team

The hosted gameplay runtime, player connection flow, team service, and score service are not production-live. The code is an authoring example for scaffolded interfaces, not runtime proof. See platform capability status.

Scene Setup

Create team_arena.tscn:

Root Node3D named TeamArena
Child Node3D named SpawnPointsRed with several spawn transforms
Child Node3D named SpawnPointsBlue with several spawn transforms

Complete Game Script (`team_arena.gd`)

extends SummerGame

const MOVE_SPEED := 8.0
const GRAVITY := 20.0
const ROUND_SECONDS := 300.0
const TEAM_SCORE_TO_WIN := 15

const RED_GOAL_X_MIN := 22.0
const BLUE_GOAL_X_MAX := -22.0

var _red_spawns: Array[Vector3] = []
var _blue_spawns: Array[Vector3] = []

func get_prediction_params() -> Dictionary:
    return {"move_speed": MOVE_SPEED, "gravity": GRAVITY}

func _game_init() -> void:
    Summer.teams.create("red", {"color": Color.RED, "max_size": 16})
    Summer.teams.create("blue", {"color": Color.BLUE, "max_size": 16})

    var red_root := get_node_or_null("SpawnPointsRed")
    if red_root:
        for child in red_root.get_children():
            if child is Node3D:
                _red_spawns.append(child.global_position)

    var blue_root := get_node_or_null("SpawnPointsBlue")
    if blue_root:
        for child in blue_root.get_children():
            if child is Node3D:
                _blue_spawns.append(child.global_position)

    if _red_spawns.is_empty():
        _red_spawns = [Vector3(-15, 1, -8), Vector3(-15, 1, 8)]
    if _blue_spawns.is_empty():
        _blue_spawns = [Vector3(15, 1, -8), Vector3(15, 1, 8)]

func _game_start() -> void:
    Summer.teams.auto_balance()
    Summer.set_time_limit(ROUND_SECONDS)
    Summer.send_announcement("Red vs Blue started")

func _game_end() -> void:
    var red_score := Summer.score.get_team("red")
    var blue_score := Summer.score.get_team("blue")
    if red_score > blue_score:
        Summer.send_announcement("Red wins %d - %d" % [red_score, blue_score])
    elif blue_score > red_score:
        Summer.send_announcement("Blue wins %d - %d" % [blue_score, red_score])
    else:
        Summer.send_announcement("Draw %d - %d" % [red_score, blue_score])

func _player_joined(player) -> void:
    var assigned := _assign_team(player)
    var spawn := _team_spawn_for(assigned)
    if player.has_method("respawn"):
        player.respawn(spawn)
    player.set_synced("team", assigned)

func _player_left(player) -> void:
    Summer.teams.remove_player(player)

func _process(delta: float) -> void:
    super._process(delta)
    if not Summer.is_server():
        return

    for p in get_players():
        apply_default_movement(p, delta, MOVE_SPEED, GRAVITY)
        _check_goal_score(p)

func _assign_team(player) -> String:
    var red_count := Summer.teams.get_members("red").size()
    var blue_count := Summer.teams.get_members("blue").size()
    var target := "red" if red_count <= blue_count else "blue"
    if not Summer.teams.assign(player, target):
        target = "blue" if target == "red" else "red"
        Summer.teams.assign(player, target)
    return target

func _team_spawn_for(team_id: String) -> Vector3:
    if team_id == "red":
        return _red_spawns.pick_random()
    return _blue_spawns.pick_random()

func _check_goal_score(player) -> void:
    var team_id := Summer.teams.get_team(player)
    if team_id == "":
        return

    if team_id == "red" and player.position.x >= RED_GOAL_X_MIN:
        _award_team_score("red", player)
    elif team_id == "blue" and player.position.x <= BLUE_GOAL_X_MAX:
        _award_team_score("blue", player)

func _award_team_score(team_id: String, scorer) -> void:
    Summer.score.add_team(team_id, 1)
    var score := Summer.score.get_team(team_id)
    Summer.send_announcement("%s team scored (%d/%d) by %s" % [team_id.capitalize(), score, TEAM_SCORE_TO_WIN, str(scorer.get("display_name"))])

    var current_team := Summer.teams.get_team(scorer)
    scorer.teleport(_team_spawn_for(current_team))

    if score >= TEAM_SCORE_TO_WIN:
        end_game(false)

Genre Note

This team model can be adapted for:

3D objective shooters,
2D objective games,
turn-based team tactics,
card games with team play.

Suggested `manifest.json`

{
  "id": "team-arena",
  "name": "Team Arena",
  "version": "1.0.0",
  "summer_sdk": "1.0",
  "entry_scene": "team_arena.tscn",
  "player_scene": "player.tscn",
  "min_players": 2,
  "max_players": 16,
  "tick_rate": 60,
  "description": "Red vs Blue objective mode.",
  "tags": ["teams", "pvp", "objective"]
}

⌘I