Josh Creek 1811e9333e feat(training): curriculum generation 4 — MultiDiscrete action space redesign
Three curriculum generations (2026-07-21 through 2026-08-04) all tried
gating *when* the policy could use vertical thrust/pitch-roll on top of a
continuous Gaussian action space, and all three failed the same way: PPO's
action-distribution std collapsed within ~10% of steps and never recovered,
landing at a 15-32% win rate vs the grounded reference regardless of
mechanism (hard mask, then a gradual ramp). Generation 3's final attempt
just landed at 24% — the worst of the three.

Root cause, verified against this project's own physics: hovering this ship
requires *holding* thrust.y ~= 0.408 continuously (mass 5.0, vertical_thrust
120, gravity 9.8). A collapsed near-zero-mean Gaussian can brush that value
but never sustain it long enough to earn the reward gradient that would
move the mean — no amount of gating *when* the axis acts fixes a problem in
*how* the policy represents a decision on it. This also independently found
and fixes a real bug: godot_rl never marks an episode timeout as a
truncation, so PPO was bootstrapping V(s)=0 on every 30s draw in every
generation to date.

- Game/scripts/ship_action_codec.gd (new): single source of truth for a
  per-axis MultiDiscrete action space (7 heads, nvec [5,5,5,5,5,5,2]) shared
  by training and in-game inference, replacing the continuous Gaussian.
  thrust_y's bins are deliberately asymmetric so a random policy drifts
  through the volume instead of floor-pinning. Legacy continuous decode
  (ai_ship_controller.gd's old logic) preserved verbatim so every
  pre-generation-4 export (e.g. Game/bots/promoted/easy.json) keeps working
  unchanged via an optional "action_space" JSON field.
- ship_observations.gd: append own contact state (SIZE 31 -> 35, append-only)
  so the value function can see what wall_contact_penalty fires on.
- ship_ai_controller.gd: action space/decode via the codec; drop the
  vertical_ramp/pitch_roll_ramp mechanism entirely; tilt_penalty default
  lowered 4x (aerial approaches require pitching); flight telemetry
  (airborne_fraction, mean_altitude, air_touch_fraction, vertical_thrust_mean)
  and truncation-snapshot fields on get_info().
- training_mode.gd: new air_drill_chance state-setter branch (ball spawned
  high, ships low, kept clear of walls) so aerial practice is forced by the
  environment instead of relying on reward-driven exploration alone; snapshot
  terminal observations before a timeout reset for the truncation fix.
- cosmic_env.py: remap ShipAIController's truncated/terminal_obs info into
  SB3's TimeLimit.truncated/terminal_observation keys.
- train.py: --reset-logits (+ --reset-logits-heads) replaces the
  now-meaningless --reset-std; new EntropyFloorCallback (a persistent
  per-rollout ent_coef controller replacing the one-shot std-reset shock)
  and per-head entropy logging; FlightTelemetryCallback; --air-drill-chance/
  --tilt-penalty flags; optional AbortIfCallback kill-criterion.
- export_policy.py: writes the action_space block for MultiDiscrete models;
  index-level parity check (argmax per head) instead of comparing floats.
- curriculum.py: full rewrite — 3 stages (bootstrap/selfplay/gauntlet), no
  grounded stage, full action space live from step 1; deletes generation
  1-3's checkpoint-lineage machinery (nothing to resume from); final report
  evaluates against both promoted/easy.json and the new
  promoted/reference-grounded.json (a copy of curric-s5-aggression, the
  strongest grounded-era artifact, kept as a fixed yardstick).
- run_training.sh/.gitignore: commit only final.zip, not the ~2400
  intermediate checkpoint files a single stage was writing (~500MB ->
  ~0.2MB per run); requirements.txt pinned (behaviour here now depends on
  specific library internals, not just public APIs).
- test_action_space.py (new): offline rung-0 check catching a head-order
  mismatch before it silently corrupts 24h of training.

Validated: GDScript compiles clean (Godot --headless --import + script
validation), free_play.tscn and training.tscn both boot headless without
errors, offline action-space assertions pass. Not yet run: the actual
smoke-training/A-B validation ladder steps in TRAINING.md's "Generation 4"
section, before committing to the full ~32h curriculum.

See TRAINING.md's "Generation 4" section for the full design writeup.
2026-08-04 23:27:57 +01:00
2024-02-21 12:33:08 +00:00
2024-02-23 18:13:33 +00:00
2024-02-21 12:49:29 +00:00

Cosmic Clash

In "Cosmic Clash," the heart-pounding action takes place in variable gravity environments where vehicles hover just above the ground. In this thrilling spiritual successor to Rocket League, players engage in high-speed, gravity-defying matches set in the far reaches of space. Each pitch is situated in a unique environment or planet, offering breathtaking vistas and challenging terrain. But instead of cars, competitors pilot rocket-powered ships, each equipped with its own set of customisable features and special abilities.

Ships hover just above the ground, defying the laws of physics and adding an extra layer of intensity to the gameplay. With no friction to hold them back, players must master the art of control as they glide effortlessly across the pitch, executing precise manoeuvres and lightning-fast aerial tricks. With precise control and lightning-fast reflexes, players boost, drift, slam and even turn upside down on their way to victory, scoring epic goals against their opponents.

Whether you're soaring through asteroid fields, navigating treacherous alien landscapes, or battling in the depths of cosmic storms, "Cosmic Clash" delivers non-stop action and adrenaline-pumping excitement that's out of this world! Get ready to take your skills to the stars and dominate the galaxy in the ultimate celestial showdown!

Reason for being

Since Epic Games bought Psyonix, Rocket League has never been the same, and rather than releasing an Unreal Engine 5 version of the game, or giving any meaningful updates, instead item trading was removed and 'Rocket Racing' was added to Fortnite. With no one else stepping up to the plate, it falls to the Open Source Community to come up with a spiritual successor, to keep the spirit of the game alive.

Legality

The concept of 'vehicle soccer' cannot be copyrighted, but the original expression of ideas such as the specific code, art, music and narrative of a game can be. So long as all code, assets game design and other elements are made from scratch, this project will remain legal. The use of an alternative game engine, Godot, serves to ensure that this is achieved, as does the move to using space ships instead of cars as the vehicles.

Technical Information

This project is composed of two parts:

  1. Godot game
  2. C# backend

Contributing

Eventually there will be contributor guidelines, but for now open a PR and make sure it has been formatted according to the auto-formatting rules.

Gameplay

The core gameplay is still football/soccer but with vehicles, however there are key changes to the format used in Rocket League. The vehicles are now space ships, which hover above the surface of the pitch. This will impact core game mechanics, enabling near-immediate changes in direction (thanks to those spacefaring engines!), the ability to play upside down (which will change the way you interact with the ball in as-yet unknown ways), slamming down at full boost speed, and many more that will be discovered along the way.

Bots

There will be default bots available, trained using reinforcement learning, and it will be possible to train your own using a gym for submission to be included in the game itself. It will NOT be possible to connect bots to the game, and with the community itself ensuring rigorous anti-cheat measures are in place we will aim to keep it that way. Cheaters have no place here.

MVP

The first version of this game will be JUST the game, no server-side functionality at all. It will be a local only game where you can play against bots. Split-screen multiplayer could be added in a version 0.2 if demand is high enough. If there is sufficient interest then the server-side functionality can be added to enable online play, with a system in place to ensure that servers can be paid for (perhaps a cheap monthly subscription model?).

Monetisation

The aim for this project is NOT to monetise it. Rocket League saw terrible changes once the Item Shop was added, and even the costs for crates and keys prevented some members of the community from collecting items and fully enjoying the game. Instead, this game will, if it becomes successful enough to warrant online servers, only use funding to keep itself running, and in the event anyone needs to be employed full time to maintain it with a growing playerbase, to pay them a fair wage for their time. Any additional profit in any given year should be held for maintaining servers in the future should demand fall, or for any future needs of the game such as a large effort to upgrade to a new engine, anti-cheating measures, etc.

S
Description
No description provided
Readme AGPL-3.0 4.8 GiB
Languages
GDScript 80.4%
Python 15.2%
Shell 1.9%
GDShader 1.5%
C# 0.8%
Other 0.2%