virtual machine & assembler

Corewar.rs

cargo run --release -n zork.cor big_feet.cor
Machine virtuelle + assembleur Corewar en Rust,
avec visualiseur ncurses et shell WASM.

$ Shell interactif > Guide complet ◈ Lancer le hacking game

corewar

nier:automata

| Hacking Game — MARS Protocol

MISSION CONTROL · POD 042 L'arène mémoire est infectée. Compilez votre warrior Red Code, défendez votre code des DAT ennemis et purgez les 7 secteurs du MARS.

LINK STANDBYSTATUS MARS · 7 SECTEURSOBJECTIVE

ZQSD Déplacement Souris Visée Clic Tir Espace Dash K Parade V Overdrive Tab Arme E Terminal P Pause M Muet Le sol wireframe est la mémoire — vos cellules dorées exécutent votre Red Code en direct.

visualizer

| Visualiseur ncurses

Controles clavier

Touche	Action
Espace	Pause / Reprendre
s	Step — avance d'exactement 1 cycle puis pause
↑ / ↓	Vitesse (pas de 500)
+ / −	Vitesse fine (pas de 100)
PgUp / PgDn	Scroller les processus
q	Quitter

Fonctionnalites

Arene 64x64 avec coloration par proprietaire et surbrillance des ecritures recentes
Panneau lateral : cycles, cycle_to_die, infos joueurs, liste des processus
Barre d'etat en bas : legende des controles et couleurs des joueurs
Mode step-by-step (s) : avancer cycle par cycle pour le debugging
Scroll des processus : PgUp/PgDn quand il y en a trop
Double buffering : wnoutrefresh() + doupdate() pour un affichage sans scintillement

architecture

| Crates

corewar-common

Constantes, types, op_table, utilitaires partages

corewar-asm

Assembleur — traduit les fichiers .s en bytecode .cor

corewar-vm

Machine virtuelle — execute les champions dans l'arene

corewar-disasm

Desassembleur — traduit les .cor en .s

Utilisation

$ cargo build

# Assembleur : .s -> .cor

$ ./target/debug/asm champs/zork.s

# Desassembleur : .cor -> .s

$ ./target/debug/disasm champs/zork.cor

# Machine virtuelle

$ ./target/debug/corewar --dump 1000 champs/zork.cor champs/big_feet.cor

$ ./target/debug/corewar -v champs/zork.cor champs/big_feet.cor

# Visualiseur ncurses interactif

$ ./target/debug/corewar -n champs/zork.cor champs/big_feet.cor

performance

| Benchmark : C vs Rust

Comparaison des performances entre la version C (-O2) et la version Rust (--release).

Test	C (-O2)	Rust (release)	Ratio
2 champions / 10k cycles	20 ms	8 ms	2.5x
2 champions / 50k cycles	50 ms	10 ms	5.0x
2 champions / 100k cycles	51 ms	11 ms	4.6x
4 champions / 10k cycles	160 ms	13 ms	12.3x
4 champions / 100k cycles	1 990 ms	93 ms	21x

Vitesse

5-21x

Rust plus rapide

Binaire C

231 Ko

5x plus petit

Binaire Rust

1.2 Mo

Runtime complet

Scaling

Rust

Performances stables

Pourquoi le Rust est plus rapide ?

Vec<Process> vs liste chainee — Tableau contigu en memoire = excellente localite cache. Le C utilise des t_list avec malloc individuel = cache misses constants.
Pas de malloc/free par fork/zombie — Le C alloue/libere un noeud pour chaque fork et zombie. Le Rust utilise un Vec qui recycle la memoire.
Optimisations LLVM — Inlining automatique, vectorisation SIMD, elimination de code mort. GCC -O2 ne matche pas LLVM sur cette base de code.
ft_printf vs formatage Rust — La reimplementation perso de printf dans le C est nettement plus lente que le formatage natif Rust.

essai

| Le Livre

Un essai complet sur le Corewar de l'école 42 : histoire, langage, machine virtuelle, assembleur, stratégie, implémentation en C et comparaison avec Rust. Cliquez sur la couverture pour l'ouvrir, puis naviguez avec les flèches ou en cliquant sur les pages.