🤖 Liga Boților - Arena Studenților ⚔️

Construiește un motor de simulare pentru o arenă tactică în care echipele de boți concurează pentru energie, teritoriu și puncte de stil. Formatul este 100% comandă-per-linie, astfel încât output-ul tău poate fi redat ca input pentru un alt student – perfect pentru dueluri!

Autor: Trifu Marius-Constantin

Tehnologii:

• ✅ Limbaj: C++ (este voie cu STL)
• ✅ Testare: 20 teste dinamice
• ✅ Deploy: GitHub Actions
• ✅ Clasament: rezultate.eu

Cerințe:

• ✅ Structuri/Clase proprii pentru boți, hartă, comenzi
• ✅ Separate `.h` / `.cpp`
• ✅ Compilare prin `make`

Administrezi o echipă de boți tactici într-o arenă rectangulară. Simularea rulează pe runde (ticks), iar intrarea este o succesiune de comenzi trimise de arbitru (`REF`). După fiecare comandă procesată trebuie să emiți propria ta decizie (`PLAYER …`) și să actualizezi scorul.

🎯 Obiectiv: Maximizează TOTAL_SCORE = energie colectată + damage util + stil - penalizări.

1. Citești configurarea arenei și profilurile boților.
2. Primești comenzi `REF ...` una câte una (spawn, evenimente, atacuri rivale etc.).
3. După fiecare linie citită **trebuie** să răspunzi cu exact 1 linie `PLAYER ...` care descrie acțiunea echipei tale pentru acel tick.
4. La final raportezi tabela scorurilor și cine câștigă arena.

📝 Respectă exact formatele! Fișierele de test vor fi în `teste/input/test01.in … test20.in`. Output-urile așteptate sunt în `teste/output/`.

ARENA LATIME INALTIME ROUNDS MAX_ENERGY
RESUPPLY ENERGY_REGEN SHIELD_REGEN
BOTS N
nume_bot hp attack shield speed ability_cost ability_cd
...
UPGRADES U
upgrade_name energy_cost attack_bonus shield_bonus speed_bonus
...
STREAM
REF TICK <t>
REF SPAWN <team> <bot_name> <id> <x> <y>
REF MOVE <team> <id> <direction> <steps>
REF ATTACK <team> <id> <target_id> <dmg>
REF EVENT <type> <value>
...
END

Explicații:

• `ARENA` – dimensiunile grilei (0-index), număr maxim de runde și energie totală.
• `RESUPPLY` – valori globale pentru refill-uri automate.
• `BOTS` – descrie șabloanele disponibile (max 12). `ability_cd` = număr de ticks până poate fi refolosită abilitatea.
• `UPGRADES` – boost-uri pe care le poți cumpăra când ai energie suficientă.
• `STREAM` – începe secvența de comenzi live. Liniile vin în timp real / sequential; nu există număr declarat, trebuie să citești până la `END`.

Direcții disponibile: `N`, `S`, `E`, `W`, `NE`, `NW`, `SE`, `SW`. Coordonatele ies din arenă → comandă invalidă (penalizare).

Restul de linii vor urma aceeași structură `REF <ACTIUNE> …`. Poți ignora tipuri necunoscute, dar trebuie să raportezi `PLAYER WAIT reason=UNKNOWN_COMMAND`.

PLAYER <tick> <action> <payload>
PLAYER <tick> <action> <payload>
...
SCOREBOARD
ENERGY_COLLECTED: value
DAMAGE_DEALT: value
STYLE_POINTS: value
PENALTIES: value
TOTAL_SCORE: value
WINNER: Alpha/Beta/Draw

Reguli:

• Exact 1 linie `PLAYER …` după fiecare linie `REF …` procesată.
• `action` ∈ {`SPAWN`, `MOVE`, `ATTACK`, `ABILITY`, `CHARGE`, `DEFEND`, `WAIT`, `UPGRADE`}.
• `payload` = argumentele tale (`bot_id`, coordonate țintă, energie cheltuită etc.).
• Output-ul trebuie să fie determinist (aceeași intrare → exact același output). Astfel putem lua fișierul rezultat și îl putem folosi ca input pentru un nou run (ex: `cat studentA.out | ./arena_bots`).
• Ultima parte `SCOREBOARD …` apare doar după `END`.

Pentru dueluri:

• Rulezi Student A → obții `arena.out`.
• Prefixezi liniile cu `REF` (script disponibil în `teste/scripturi/oficializeaza_transcriere.py`).
• Rulezi Student B cu acea transcriere suplimentară: `cat arena.out.refeed | ./arena`.
• Programul tău trebuie să ignore liniile `PLAYER` întâlnite în input (sunt tratate ca mișcări deja consumate) și să genereze răspunsuri noi.

• Nu poți cheltui mai multă energie decât `MAX_ENERGY`.
• `CHARGE` crește energia curentă până la limită.
• `UPGRADE` consumă energia specificată și aplică bonusurile asupra unui bot activ.

• Fiecare celulă poate conține max. 1 bot pe echipă.
• Mișcările trebuie să rămână în `[0, LATIME) × [0, INALTIME)`.
• Nodurile de energie (id numeric) se capturează cu acțiunea `CAPTURE node_id`.

• Damage efectiv = `attack + bonusuri - shield_target`.
• Dacă damage ≤ 0 → este considerat blocaj și primești `STYLE_POINTS +1` pentru combinații defensive valide.
• Abilitățile respectă cooldown-ul declarat și costul de energie.

• Pentru fiecare `REF TICK t` trebuie să setezi contextul curent.
• Comenzile `REF` cu alt tick decât cel curent sunt erori → tratează-le ca `WAIT`.
• Două comenzi `REF` pot apărea cu același tick; le procesezi în ordine.

• `ENERGY_COLLECTED` – sumă totală de energie netă acumulată.
• `DAMAGE_DEALT` – damage valid aplicat adversarilor (`ATTACK`, `ABILITY`).
• `STYLE_POINTS` – bonusuri pentru combo-uri (abilitate după MOVE, contra atac etc.) conform fișierului de limite.
• `PENALTIES` – se adună pentru comenzi invalide, ieșire din arenă, lipsă răspuns.

• `main.cpp` doar creează obiectul principal (`ArenaController controller; controller.run(argc, argv);`).
• Folosește clase pentru: `Arena`, `Bot`, `Command`, `Scoreboard`.
• Tratează intrarea ca flux: citești linie → parsezi → execuți → produci output imediat.
• Este permisă bufferizarea, dar output-ul trebuie să păstreze ordinea exactă a liniilor `REF`.
• Comenzile necunoscute → `PLAYER <tick> WAIT reason=UNKNOWN_COMMAND`.
• Folosește `std::getline` și `std::istringstream` proprii (nu STL – scrie un parser minimal).

• 20 teste × 0.45p.
• Fiecare test are limită minimă în `teste/limite_minime.txt`.
• Unele teste includ dueluri simulate (output → input). Programul trebuie să rămână consistent.

• Nume + grupă.
• Cum e structurată arena (clase/fișiere).
• Cum asiguri determinismul output-ului.

• Clasament calculat după `TOTAL_SCORE` cumulat pe toate testele.
• Top 1 → +5p, 2-3 → +4p, 4-5 → +3p, 6-10 → +2p, 11-20 → +1p.

1. Rulați `make record TEST=test07` pentru a salva transcriptul oficial (`out/test07.log`). 2. Trimiteți fișierul altui student. 3. Acesta îl poate reda cu `cat out/test07.log | ./arena`. 4. Pentru turnee, există scriptul `scripts/run_duel.sh studentA studentB testID` care combină output-urile și declară câștigătorul după reguli.

Programul vostru trebuie să fie robust la:

• Comenzi duplicat (ex: același `REF SPAWN` repetat).
• Ticks lipsă (trebuie să faceți `PLAYER WAIT` până revine).
• Output folosit ca input (linii `PLAYER` în stream).

Comenzi Make:

make              # compilează și rulează toate testele din teste/input
make build        # doar compilare
make run          # rulează arena.txt -> arena.out
make test05       # rulează doar testul 5
make record TEST=test12  # rulează testul și păstrează transcriptul pentru duel

GitHub Actions rulează `make` + trimite rezultatele la `rezultate.eu`. Output-ul scriptului `trimite_rezultate.py` va include `TOTAL_SCORE`, nickname etc.

• ✅ Stochează istoric comenzi pentru a putea reface dueluri.
• ✅ Normalizează toate coordonatele/ids.
• ✅ Scrie teste proprii folosind `scripts/generate_random_stream.py`.
• ✅ Asigură-te că output-ul tău nu are spații în plus.
• ⛔ Nu amesteca logică de I/O cu logica de simulare – folosește un controller clar.

Checklist:

1. [ ] `make build` fără warnings
2. [ ] Toate testele oficiale trecute local
3. [ ] README complet
4. [ ] Transcript deterministic
5. [ ] Trimite la timp pe GitHub

Succes și abia așteptăm duelurile! 🥊