Quick start

We’ll show you how to join CodeBall in a few minutes.

Register

Of course, you need to register. We kindly ask all participants to provide accurate and complete information about yourself.

Download language pack

Download the package for your favorite programming language from the language packs page. We support C++, Java, C#, Python 3, Ruby, Kotlin, Rust. Unzip the archive and open an existing project or create a new one from scratch. You may need to configure some paths.

Download Local runner

Local runner is a special version of game engine adapted for participants. Local runner gives you the opportunity to run a test games locally on your computer. Read more about it here.

Read the documentation

The official and complete rules are published in the Rules section, please read them. Some organizational aspects you can find in the descriptions of the Sandbox and stages of the championship (Round 1, Round 2, Finals).

Submit your strategy

You can submit you strategy here. Before the system will accept your strategy, it will be compiled and tested in a few short games. If everything is OK, your strategy will automatically start to participate in regular qualifying games in Sandbox. Carefully read the section “What you should pay attention to” for various aspects due to which your strategy can get the “Verification error” verdict. The total number of submissions are not restricted, however there are restrictions on too frequent submitting. Any attempt to destabilize the system will result in disqualification. You can write your strategy in an arbitrary number of files, you will only need to pack everything into a ZIP archive and send it. All files must be in root of archive. Unfortunately, creating custom packages in the Java strategy is unacceptable. Remember that in your starter pack you can change only the file MyStrategy.${ext} (where ${ext} — extension language you are using), and even if you change some other file and also add it to the archive, it will be replaced on standard (except for MyStrategy.h in C++).

What you should pay attention to

• it is prohibited to interact with the network, file system and other resources, except for RAM and the current directory, violators will be disqualified;
• total CPU time of your strategy process is limited (exact details you can find in the documentation);
• the strategy process should not use more than 256 MB of RAM;
• if your strategy exceeds the time or memory limit or crashes during the execution, it stops to participate in this game (however, your score points do not expire);
• the strategy of each participant runs in a separate process.

Writing a simple strategy with Rust

Quick start strategies in some other languages are available on GitHub.

Simple strategy tries to hit the ball as soon as possible, not neccesarily into the net, just in opponent’s side of the arena.

It also does not take collisions into account, as well as y coordinate — only 2d geometry is used.

use crate::model::*;
use crate::strategy::Strategy;

const EPS: f64 = 1e-5;

#[derive(Default)]
pub struct MyStrategy;

// We will need to work with 2d vertors
#[derive(Copy, Clone, Debug)]
struct Vec2 {
    x: f64,
    y: f64,
}

impl Vec2 {
    fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }
    // Finding length of the vector
    fn len(&self) -> f64 {
        (self.x * self.x + self.y * self.y).sqrt()
    }
    // Normalizing vector (setting its length to 1)
    fn normalize(self) -> Self {
        self * (1.0 / self.len())
    }
}

// Subtraction operation for vectors
impl std::ops::Sub for Vec2 {
    type Output = Self;
    fn sub(self, b: Self) -> Self {
        Self::new(self.x - b.x, self.y - b.y)
    }
}

// Addition for vectors
impl std::ops::Add for Vec2 {
    type Output = Self;
    fn add(self, b: Self) -> Self {
        Self::new(self.x + b.x, self.y + b.y)
    }
}

// Multiplying vector by a number
impl std::ops::Mul<f64> for Vec2 {
    type Output = Self;
    fn mul(self, k: f64) -> Self {
        Self::new(self.x * k, self.y * k)
    }
}

// Common interface for ball and robots
trait Entity {
    // Position of the entity in XZ plane
    fn position(&self) -> Vec2;
    // Velocity of the entity in XZ plane
    fn velocity(&self) -> Vec2;
}

impl Entity for Robot {
    fn position(&self) -> Vec2 {
        Vec2::new(self.x, self.z)
    }
    fn velocity(&self) -> Vec2 {
        Vec2::new(self.velocity_x, self.velocity_z)
    }
}

impl Entity for Ball {
    fn position(&self) -> Vec2 {
        Vec2::new(self.x, self.z)
    }
    fn velocity(&self) -> Vec2 {
        Vec2::new(self.velocity_x, self.velocity_z)
    }
}

// Strategy logic
impl Strategy for MyStrategy {
    fn act(&mut self, me: &Robot, rules: &Rules, game: &Game, action: &mut Action) {

        // The strategy only plays on the ground
        // So, if we are not touching the ground, use nitro
        // to go back as soon as possible
        if !me.touch {
            *action = Action {
                target_velocity_x: 0.0,
                target_velocity_y: -rules.MAX_ENTITY_SPEED,
                target_velocity_z: 0.0,
                jump_speed: 0.0,
                use_nitro: true,
            };
            return;
        }

        // Lets jump if we would hit the ball, and
        // we are on the same side of the ball as out net, so 
        // the ball would go into opponent's side of the arena
        let jump = ((me.x - game.ball.x).powi(2)
            + (me.y - game.ball.y).powi(2)
            + (me.z - game.ball.z).powi(2))
        .sqrt()
            < rules.BALL_RADIUS + rules.ROBOT_MAX_RADIUS
            && me.z < game.ball.z;

        // Since there are multiple robots in out team lets determine out role - attacker or defender
        // We will be attacker if there is friendly robot closer
        // to out net than current one.
        let mut is_attacker = game.robots.len() == 2;
        for robot in &game.robots {
            if robot.is_teammate && robot.id != me.id {
                if robot.position().y < me.position().y {
                    is_attacker = true;
                }
            }
        }

        if is_attacker {
            // Attacker strategy:
            // Simulate approximate location of the ball for the next 10 seconds with 0.1 second precision
            for i in 1..100 {
                let t = i as f64 * 0.1;
                let ball_pos = game.ball.position() + game.ball.velocity() * t;
                // If ball will not leave arena boundary
                // (collision with the arena would happen, but we are not considering it),
                // and the ball will be closer to opponent's net than the robot,
                if ball_pos.y > me.position().y
                    && ball_pos.x.abs() < (rules.arena.width / 2.0)
                    && ball_pos.y.abs() < (rules.arena.depth / 2.0)
                {
                    // Compute the speed robot needs to run with
                    // To be at ball's location at the same time as the ball
                    let delta_pos = Vec2::new(ball_pos.x, ball_pos.y)
                        - Vec2::new(me.position().x, me.position().y);
                    let need_speed = delta_pos.len() / t;
                    // If the speed is in acceptable range
                    if 0.5 * rules.ROBOT_MAX_GROUND_SPEED < need_speed
                        && need_speed < rules.ROBOT_MAX_GROUND_SPEED
                    {
                        // Then this is out action
                        let target_velocity =
                            Vec2::new(delta_pos.x, delta_pos.y).normalize() * need_speed;
                        *action = Action {
                            target_velocity_x: target_velocity.x,
                            target_velocity_y: 0.0,
                            target_velocity_z: target_velocity.y,
                            jump_speed: if jump { rules.ROBOT_MAX_JUMP_SPEED } else { 0.0 },
                            use_nitro: false,
                        };
                        return;
                    }
                }
            }
        }
        // Defender's strategy (or attacker's who did not find good moment):
        // Standing in the middle of out net
        let mut target_pos = Vec2::new(0.0, -(rules.arena.depth / 2.0) + rules.arena.bottom_radius);
        // And, if the ball is rolling towars it
        if game.ball.velocity().y < -EPS {
            // Find time and place where ball crosses the net line
            let t = (target_pos.y - game.ball.position().y) / game.ball.velocity().y;
            let x = game.ball.position().x + game.ball.velocity().x * t;
            // If this place is inside the net
            if x.abs() < (rules.arena.goal_width / 2.0) {
                // Go defend there
                target_pos.x = x;
            }
        }

        // Setting fields of the needed action
        let target_velocity = Vec2::new(
            target_pos.x - me.position().x,
            target_pos.y - me.position().y,
        ) * rules.ROBOT_MAX_GROUND_SPEED;
        *action = Action {
            target_velocity_x: target_velocity.x,
            target_velocity_y: 0.0,
            target_velocity_z: target_velocity.y,
            jump_speed: if jump { rules.ROBOT_MAX_JUMP_SPEED } else { 0.0 },
            use_nitro: false,
        }
    }
}