From 6ffbfb0d1e6ce1a2b5900a38bc40dde6a5bff915 Mon Sep 17 00:00:00 2001
From: xiaoxiae <tomas@slama.dev>
Date: Tue, 11 Feb 2025 21:50:20 +0100
Subject: [PATCH] =?UTF-8?q?=C5=BD=C3=A1dn=C3=BD=20typy,=20pouze=20inty?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
asteracer-python/asteracer.py | 93 ++++++++++++------------
asteracer-rust/src/asteracer.rs | 121 +++++++++++++++-----------------
asteracer-rust/src/main.rs | 6 +-
3 files changed, 101 insertions(+), 119 deletions(-)
diff --git a/asteracer-python/asteracer.py b/asteracer-python/asteracer.py
index 929fdb4..548cc24 100644
--- a/asteracer-python/asteracer.py
+++ b/asteracer-python/asteracer.py
@@ -1,3 +1,4 @@
+"""The Asteracer game implementation. Includes the base movement code + couple of QOL additions (eg. save states)."""
from __future__ import annotations
import dataclasses
@@ -5,14 +6,6 @@ import random
from collections import defaultdict
from dataclasses import dataclass
from math import isqrt
-from typing import List, Union, Tuple, Dict
-
-# tohle dříve byly numpy typy, ale asi je lepší,
-# ať účastníci nemusí nic instalovat...
-InstType = int # np.int8
-PosType = int # np.int64
-SpeedType = int # np.int64
-SizeType = int # np.int64
class TickFlag:
@@ -23,18 +16,18 @@ class TickFlag:
@dataclass
class Racer:
- x: PosType = 0
- y: PosType = 0
- vx: SpeedType = 0
- vy: SpeedType = 0
- radius: SizeType = 1
+ x: int = 0
+ y: int = 0
+ vx: int = 0
+ vy: int = 0
+ radius: int = 1
@dataclass(frozen=True)
class Asteroid:
- x: PosType = 0
- y: PosType = 0
- radius: SizeType = 1
+ x: int = 0
+ y: int = 0
+ radius: int = 1
Goal = Asteroid
@@ -42,7 +35,7 @@ Goal = Asteroid
class Instruction:
MAX_ACCELERATION = 127
- def __init__(self, vx: Union[int, float] = 0, vy: Union[int, float] = 0):
+ def __init__(self, vx: int | float = 0, vy: int | float = 0):
"""Whatever values we get, normalize them."""
if distance_squared(vx, vy) > Instruction.MAX_ACCELERATION ** 2:
@@ -62,8 +55,8 @@ class Instruction:
assert distance_squared(vx, vy) <= Instruction.MAX_ACCELERATION ** 2
- self.vx = InstType(vx)
- self.vy = InstType(vy)
+ self.vx = vx
+ self.vy = vy
def __hash__(self):
return hash((self.vx, self.vy))
@@ -90,26 +83,26 @@ class Instruction:
@dataclass
class BoundingBox:
- min_x: PosType
- min_y: PosType
- max_x: PosType
- max_y: PosType
+ min_x: int
+ min_y: int
+ max_x: int
+ max_y: int
- def width(self) -> SizeType:
- return SizeType(self.max_x - self.min_x)
+ def width(self) -> int:
+ return int(self.max_x - self.min_x)
- def height(self) -> SizeType:
- return SizeType(self.max_y - self.min_y)
+ def height(self) -> int:
+ return int(self.max_y - self.min_y)
-def distance_squared(x1, y1, x2=0, y2=0) -> PosType:
+def distance_squared(x1, y1, x2=0, y2=0) -> int:
"""Squared Euclidean distance between two points."""
- return (PosType(x1) - PosType(x2)) ** 2 + (PosType(y1) - PosType(y2)) ** 2
+ return (int(x1) - int(x2)) ** 2 + (int(y1) - int(y2)) ** 2
def euclidean_distance(x1, y1, x2=0, y2=0):
"""Integer Euclidean distance between two points. Uses integer square root."""
- return PosType(isqrt(distance_squared(x1, y1, x2, y2)))
+ return int(isqrt(distance_squared(x1, y1, x2, y2)))
def signum(x):
@@ -132,8 +125,8 @@ class Simulation:
def __init__(
self,
racer: Racer = Racer(),
- asteroids: List[Asteroid] = None,
- goals: List[Goal] = None,
+ asteroids: list[Asteroid] = None,
+ goals: list[Goal] = None,
bounding_box: BoundingBox = None,
):
# the initial racer state (used when resetting the simulation)
@@ -146,7 +139,7 @@ class Simulation:
# to speed up the computation, we divide the bounding box (if we have one) into a grid
# we do this so we don't need to check all asteroids at each tick, only those that could collide with the racer
- self._grid: Dict[Tuple[int, int], List[Asteroid]] = defaultdict(list)
+ self._grid: dict[tuple[int, int], list[Asteroid]] = defaultdict(list)
for asteroid in asteroids:
min_x, min_y = self._coordinate_to_grid(
@@ -163,12 +156,12 @@ class Simulation:
for grid_y in range(min_y, max_y + 1):
self._grid[(grid_x, grid_y)].append(asteroid)
- self.reached_goals: List[bool] = [False] * len(self.goals)
+ self.reached_goals: list[bool] = [False] * len(self.goals)
# a list of simulation states that can be popped (restored to)
self._pushed_states = []
- def _coordinate_to_grid(self, x: float, y: float) -> Tuple[int, int]:
+ def _coordinate_to_grid(self, x: float, y: float) -> tuple[int, int]:
"""Translate an (x,y) coordinate into a coordinate of the grid."""
return (x // self.CELL_SIZE, y // self.CELL_SIZE)
@@ -181,14 +174,14 @@ class Simulation:
self.racer.vy = division(self.racer.vy * self.DRAG_FRACTION[0], self.DRAG_FRACTION[1])
# velocity
- self.racer.vx += SpeedType(vx)
- self.racer.vy += SpeedType(vy)
+ self.racer.vx += int(vx)
+ self.racer.vy += int(vy)
# movement
self.racer.x += self.racer.vx
self.racer.y += self.racer.vy
- def _push_out(self, obj: Union[Asteroid, BoundingBox]) -> bool:
+ def _push_out(self, obj: Asteroid | BoundingBox) -> bool:
"""Attempt to push the racer out of the object (if he's colliding), adjusting
his velocity accordingly (based on the angle of collision). Returns True if the
racer was pushed out, otherwise returns False."""
@@ -292,7 +285,7 @@ class Simulation:
return (TickFlag.COLLIDED if collided else 0) | (TickFlag.GOAL_REACHED if goal else 0)
- def simulate(self, instructions: List[Instruction]):
+ def simulate(self, instructions: list[Instruction]):
"""Simulate a number of instructions for the simulation (from the start)."""
self.restart()
@@ -337,10 +330,10 @@ class Simulation:
lines = f.read().splitlines()
racer_parts = lines[0].split()
- racer = Racer(x=PosType(racer_parts[0]), y=PosType(racer_parts[1]), radius=SizeType(racer_parts[2]))
+ racer = Racer(x=int(racer_parts[0]), y=int(racer_parts[1]), radius=int(racer_parts[2]))
bb_parts = lines[1].split()
- bb = BoundingBox(PosType(bb_parts[0]), PosType(bb_parts[1]), PosType(bb_parts[2]), PosType(bb_parts[2]))
+ bb = BoundingBox(int(bb_parts[0]), int(bb_parts[1]), int(bb_parts[2]), int(bb_parts[2]))
asteroid_count = int(lines[2])
@@ -349,9 +342,9 @@ class Simulation:
asteroid_parts = lines[i].split()
asteroids.append(
Asteroid(
- x=PosType(asteroid_parts[0]),
- y=PosType(asteroid_parts[1]),
- radius=SizeType(asteroid_parts[2]),
+ x=int(asteroid_parts[0]),
+ y=int(asteroid_parts[1]),
+ radius=int(asteroid_parts[2]),
)
)
@@ -362,9 +355,9 @@ class Simulation:
goal_parts = lines[i].split()
goals.append(
Asteroid(
- x=PosType(goal_parts[0]),
- y=PosType(goal_parts[1]),
- radius=SizeType(goal_parts[2]),
+ x=int(goal_parts[0]),
+ y=int(goal_parts[1]),
+ radius=int(goal_parts[2]),
)
)
@@ -390,7 +383,7 @@ class Simulation:
self.reached_goals = list(self._pushed_states[-1][1])
-def save_instructions(path: str, instructions: List[Instruction]):
+def save_instructions(path: str, instructions: list[Instruction]):
"""Save a list of instructions to a file:
| 4 // number if instructions
| -16 -127 // instructions...
@@ -405,13 +398,13 @@ def save_instructions(path: str, instructions: List[Instruction]):
f.write(f"{instruction.vx} {instruction.vy}\n")
-def load_instructions(path: str) -> List[Instruction]:
+def load_instructions(path: str) -> list[Instruction]:
"""Load a list of instructions from a file (see save_instructions for the format description)."""
instructions = []
with open(path) as f:
for line in f.read().splitlines()[1:]:
- instruction_parts = list(map(InstType, line.split()))
+ instruction_parts = list(map(int, line.split()))
instructions.append(Instruction(*instruction_parts))
return instructions
diff --git a/asteracer-rust/src/asteracer.rs b/asteracer-rust/src/asteracer.rs
index 0611101..a893f28 100644
--- a/asteracer-rust/src/asteracer.rs
+++ b/asteracer-rust/src/asteracer.rs
@@ -12,61 +12,50 @@ pub mod TickFlag {
pub type TickResult = usize;
-pub type InstType = i8;
-pub type PosType = i64;
-pub type SpeedType = i64;
-pub type SizeType = i64;
+pub static MAX_ACCELERATION: isize = 127;
-pub static MAX_ACCELERATION: InstType = 127;
-
-pub static DRAG_FRACTION: (SpeedType, SpeedType) = (9, 10);
-pub static COLLISION_FRACTION: (SpeedType, SpeedType) = (1, 2);
+pub static DRAG_FRACTION: (isize, isize) = (9, 10);
+pub static COLLISION_FRACTION: (isize, isize) = (1, 2);
pub static MAX_COLLISION_RESOLUTIONS: usize = 5;
-pub static CELL_SIZE: PosType = 10_000;
+pub static CELL_SIZE: isize = 10_000;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Racer {
- pub x: PosType,
- pub y: PosType,
- pub vx: SpeedType,
- pub vy: SpeedType,
- pub radius: SizeType,
+ pub x: isize,
+ pub y: isize,
+ pub vx: isize,
+ pub vy: isize,
+ pub radius: isize,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Asteroid {
- pub x: PosType,
- pub y: PosType,
- pub radius: SizeType,
+ pub x: isize,
+ pub y: isize,
+ pub radius: isize,
}
pub type Goal = Asteroid;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(crate) struct Instruction {
- pub vx: InstType,
- pub vy: InstType,
+ pub vx: isize,
+ pub vy: isize,
}
impl Instruction {
- fn valid(vx: PosType, vy: PosType) -> bool {
- distance_squared(vx, vy, 0, 0) <= (MAX_ACCELERATION as PosType).pow(2)
+ fn valid(vx: isize, vy: isize) -> bool {
+ distance_squared(vx, vy, 0, 0) <= (MAX_ACCELERATION).pow(2)
}
- pub fn new<T>(vx: T, vy: T) -> Self
- where
- T: Copy + Into<PosType>,
- {
- let vx: i64 = vx.into();
- let vy: i64 = vy.into();
-
+ pub fn new(vx: isize, vy: isize) -> Self {
if !Self::valid(vx, vy) {
// use float to properly normalize here
let float_distance = ((vx as f64).powf(2.) + (vy as f64).powf(2.)).powf(1. / 2.);
- let mut vx = ((vx as f64 / float_distance) * MAX_ACCELERATION as f64) as PosType;
- let mut vy = ((vy as f64 / float_distance) * MAX_ACCELERATION as f64) as PosType;
+ let mut vx = ((vx as f64 / float_distance) * MAX_ACCELERATION as f64) as isize;
+ let mut vy = ((vy as f64 / float_distance) * MAX_ACCELERATION as f64) as isize;
// if we're still over, decrement both values
if !Self::valid(vx, vy) {
@@ -74,14 +63,14 @@ impl Instruction {
vy -= vy.signum();
}
- return Self { vx: vx as InstType, vy: vy as InstType };
+ return Self { vx, vy };
}
assert!(Self::valid(vx, vy));
Self {
- vx: vx as InstType,
- vy: vy as InstType,
+ vx,
+ vy,
}
}
@@ -89,8 +78,8 @@ impl Instruction {
let mut rng = rand::rng();
Self {
- vx: rng.random::<InstType>(),
- vy: rng.random::<InstType>(),
+ vx: rng.random::<i64>() as isize,
+ vy: rng.random::<i64>() as isize,
}
}
@@ -110,8 +99,8 @@ impl Instruction {
.collect::<Vec<&str>>();
instructions.push(Instruction {
- vx: parts[0].parse::<InstType>().unwrap(),
- vy: parts[1].parse::<InstType>().unwrap(),
+ vx: parts[0].parse::<isize>().unwrap(),
+ vy: parts[1].parse::<isize>().unwrap(),
})
}
@@ -130,24 +119,24 @@ impl Instruction {
#[derive(Debug, Clone, Copy)]
pub struct BoundingBox {
- pub min_x: SizeType,
- pub min_y: SizeType,
- pub max_x: SizeType,
- pub max_y: SizeType,
+ pub min_x: isize,
+ pub min_y: isize,
+ pub max_x: isize,
+ pub max_y: isize,
}
impl BoundingBox {
- pub fn width(&self) -> SizeType {
+ pub fn width(&self) -> isize {
self.max_x - self.min_x
}
- pub fn height(&self) -> SizeType {
+ pub fn height(&self) -> isize {
self.max_y - self.min_y
}
}
/// Squared Euclidean distance; useful for distance checks.
-fn distance_squared(x1: PosType, y1: PosType, x2: PosType, y2: PosType) -> PosType {
+fn distance_squared(x1: isize, y1: isize, x2: isize, y2: isize) -> isize {
(x1 - x2).pow(2) + (y1 - y2).pow(2)
}
@@ -155,8 +144,8 @@ fn distance_squared(x1: PosType, y1: PosType, x2: PosType, y2: PosType) -> PosTy
///
/// Note: this implementation might break for larger position values, but since
/// the maps are never going to be this large, I'm not fixing it now.
-pub fn euclidean_distance(x1: PosType, y1: PosType, x2: PosType, y2: PosType) -> PosType {
- (distance_squared(x1, y1, x2, y2) as f64).sqrt() as PosType
+pub fn euclidean_distance(x1: isize, y1: isize, x2: isize, y2: isize) -> isize {
+ (distance_squared(x1, y1, x2, y2) as f64).sqrt() as isize
}
#[derive(Debug, Clone)]
@@ -170,8 +159,8 @@ pub struct Simulation {
pub reached_goals: Vec<bool>,
- _grid: HashMap<(PosType, PosType), Vec<Asteroid>>,
- _cell_size: PosType,
+ _grid: HashMap<(isize, isize), Vec<Asteroid>>,
+ _cell_size: isize,
}
///
@@ -234,7 +223,7 @@ impl Simulation {
simulation
}
- fn coordinate_to_grid(&self, x: PosType, y: PosType) -> (PosType, PosType) {
+ fn coordinate_to_grid(&self, x: isize, y: isize) -> (isize, isize) {
(x / self._cell_size, y / self._cell_size)
}
@@ -242,11 +231,11 @@ impl Simulation {
self.racer.vx = (self.racer.vx * DRAG_FRACTION.0) / DRAG_FRACTION.1;
self.racer.vy = (self.racer.vy * DRAG_FRACTION.0) / DRAG_FRACTION.1;
- self.racer.vx += instruction.vx as SpeedType;
- self.racer.vy += instruction.vy as SpeedType;
+ self.racer.vx += instruction.vx;
+ self.racer.vy += instruction.vy;
- self.racer.x += self.racer.vx as PosType;
- self.racer.y += self.racer.vy as PosType;
+ self.racer.x += self.racer.vx as isize;
+ self.racer.y += self.racer.vy as isize;
}
fn push_from_asteroids(&mut self) -> bool {
@@ -413,9 +402,9 @@ impl Simulation {
let racer_parts = parts_fn();
let racer = Racer {
- x: racer_parts[0].parse::<PosType>().unwrap(),
- y: racer_parts[1].parse::<PosType>().unwrap(),
- radius: racer_parts[2].parse::<SizeType>().unwrap(),
+ x: racer_parts[0].parse::<isize>().unwrap(),
+ y: racer_parts[1].parse::<isize>().unwrap(),
+ radius: racer_parts[2].parse::<isize>().unwrap(),
vx: 0,
vy: 0,
};
@@ -423,10 +412,10 @@ impl Simulation {
let bb_parts = parts_fn();
let bbox = BoundingBox {
- min_x: bb_parts[0].parse::<SizeType>().unwrap(),
- min_y: bb_parts[1].parse::<SizeType>().unwrap(),
- max_x: bb_parts[2].parse::<SizeType>().unwrap(),
- max_y: bb_parts[3].parse::<SizeType>().unwrap(),
+ min_x: bb_parts[0].parse::<isize>().unwrap(),
+ min_y: bb_parts[1].parse::<isize>().unwrap(),
+ max_x: bb_parts[2].parse::<isize>().unwrap(),
+ max_y: bb_parts[3].parse::<isize>().unwrap(),
};
let asteroid_count = parts_fn()[0].parse::<usize>().unwrap();
@@ -436,9 +425,9 @@ impl Simulation {
let asteroid_parts = parts_fn();
asteroids.push(Asteroid {
- x: asteroid_parts[0].parse::<PosType>().unwrap(),
- y: asteroid_parts[1].parse::<PosType>().unwrap(),
- radius: asteroid_parts[2].parse::<PosType>().unwrap(),
+ x: asteroid_parts[0].parse::<isize>().unwrap(),
+ y: asteroid_parts[1].parse::<isize>().unwrap(),
+ radius: asteroid_parts[2].parse::<isize>().unwrap(),
});
}
@@ -449,9 +438,9 @@ impl Simulation {
let goal_parts = parts_fn();
goals.push(Asteroid {
- x: goal_parts[0].parse::<PosType>().unwrap(),
- y: goal_parts[1].parse::<PosType>().unwrap(),
- radius: goal_parts[2].parse::<PosType>().unwrap(),
+ x: goal_parts[0].parse::<isize>().unwrap(),
+ y: goal_parts[1].parse::<isize>().unwrap(),
+ radius: goal_parts[2].parse::<isize>().unwrap(),
});
}
diff --git a/asteracer-rust/src/main.rs b/asteracer-rust/src/main.rs
index 77c24ff..920f720 100644
--- a/asteracer-rust/src/main.rs
+++ b/asteracer-rust/src/main.rs
@@ -7,7 +7,7 @@ use std::path::PathBuf;
mod asteracer;
pub fn load_asteroid_graph(path: &PathBuf) -> (
- Vec<(PosType, PosType)>,
+ Vec<(isize, isize)>,
Vec<(usize, usize)>,
Vec<(char, usize)>,
) {
@@ -37,7 +37,7 @@ pub fn load_asteroid_graph(path: &PathBuf) -> (
// Load vertices
for i in 0..(n_racer + n_asteroid + n_goal) {
- let line: Vec<i64> = iter
+ let line: Vec<isize> = iter
.next()
.unwrap()
.split_whitespace()
@@ -120,7 +120,7 @@ fn main() {
// posbíráme zbývající cíle tak, že k nim poletíme přímou čarou
while simulation.reached_goals.iter().any(|&reached| !reached) {
let mut nearest_goal = None;
- let mut nearest_goal_distance = PosType::MAX;
+ let mut nearest_goal_distance = isize::MAX;
for (i, &reached) in simulation.reached_goals.iter().enumerate() {
if !reached {