TerraBot - let's explore and save the planet !

• Responsabili & Autori: Alina Tudorache, Dragos Dragan, Andrei Marcu, Alexia Oprisan, Francesco Martinuț, Cleopatra Popescu
• Consultanți & Revizori: Sorina-Anamaria Buf, Ștefan Cocioran, Florian-Luis Micu
• Data publicării BETA testing: 21.10.2025
• Deadline HARD BETA testing: 10.11.2025
• Data publicării oficiale: 10.11.2025
• Deadline HARD oficial: 30.11.2025
• Ultima modificare (cerință, schelet sau teste): 21.10.2025
• Schelet și teste: https://github.com/oop-pub/schelet-tema1-2025

• Familiarizarea cu Java și conceptele de bază ale POO.
• Fundamentarea practică a constructorilor și a agregării/moștenirii.
• Dezvoltarea unor abilități de bază de organizare și design orientat obiect.
• Scrierea unui cod cât mai generic, ce va permite ulterior adăugarea de noi funcționalități.
• Familiarizarea conceptelor de polimorfism, abstractizare și încapsulare.
• Utilizarea colecțiilor din Java.
• Folosirea claselor speciale și a bibliotecii standard Java.
• Respectarea unui stil de codare și de comentare.
• Dezvoltarea aptitudinilor de depanare a problemelor în cod.

TerraBot, robotul nostru explorator creat de NASA, are o misiune deosebită: să descopere o nouă planetă și să o pregătească pentru viitoarea colonizare. El trebuie să exploreze cât mai mult din suprafața planetei, să adune informații esențiale despre mediul înconjurător și să contribuie la îmbunătățirea condițiilor de viață. Totuși, fiți atenți, deoarece energia lui TerraBot este limitată, așa că fiecare acțiune trebuie planificată cu grijă pentru a garanta succesul misiunii!

Odată lansat în misiune, TerraBot intră într-un mediu complet necunoscut, unde fiecare regiune a planetei ascunde provocări și condiții diferite. Robotul nostru este programat să efectueze simulări experimentale, fiecare având scopul de a observa cum evoluează ecosistemul, de a colecta date despre plante, animale, apă și sol, și de a aplica diferite metode pentru a menține mediul sănătos și sustenabil.

Pe parcursul fiecărei simulări, TerraBot experimentează, analizează datele obținute și ia decizii autonome pentru a-și îndeplini obiectivele. O simulare reprezintă o rundă completă de explorare: mediul se modifică în timp real, resursele sunt limitate, iar robotul trebuie să acționeze eficient și adaptabil. Astfel, în cadrul testelor pot exista una sau mai multe simulări, permițându-vă să evaluați performanța TerraBot în scenarii diferite.

Fiecare test are următoarea structură:

1. Se generează preambulul – se creează harta planetei, cu toate entitățile poziționate pe celule (vezi secțiunea Desfășurarea simulării).
2. Se inițiază simularea.
   • comanda startSimulation → marchează începutul simulării.
3. Se desfășoară simularea propriu-zisă – TerraBot primește comenzi, reacționează la mediu și se actualizează starea planetei.
4. Se finalizează simularea.
   • comanda endSimulation → marchează finalul simulării.
5. Se repetă pașii de mai sus pentru fiecare simulare indicată în cadrul testului.

Fiecare simulare trebuie să înceapă cu comanda startSimulation și să se încheie cu endSimulation.

1. Evoluția automată a mediului

Se produce independent de acțiunile TerraBot și reflectă procese naturale:

• calitatea aerului, solului și apei se modifică în timp (în această ordine)
• plantele cresc sau se ofilesc
• animalele se deplasează și își schimbă starea (consumă plante sau apă)

2. Acțiunile TerraBot

Se execută pe baza comenzilor trimise:

• se deplasează pe hartă
• scanează mediul și învață informații (facts)
• colectează plante, animale sau apă în inventar
• aplică metode de îmbunătățire a mediului
• explorează noi zone în funcție de calitatea mediului

O simulare este împărțită în iterații (unități de timp).

La fiecare iterație se execută ambele procese în această ordine: evoluția mediului și acțiunile robotului.

La începutul fiecărei simulări:

• TerraBot pornește de la zero:
  • bateria este complet încărcată
  • inventarul este gol
• Mediul este resetat:
  • harta este regenerată cu parametri noi
  • fiecare celulă primește un tip de sol
  • sunt repoziționate plantele și animalele
  • calitatea aerului și a apei este recalculată

Imaginea de mai sus prezintă structura hărții și pozițiile exemplificative pentru TerraBot și elementele mediului.

Pentru detalii despre mișcările robotului, acțiuni și comenzile disponibile, consultați secțiunea Comenzi .

Există mai multe tipuri de entități care se pot afla pe o pătrățică:

• Plant
• Animal
• Water
• Air
• Soil

Toate entitățile de mai sus au următoarele atribute comune:

Tipurile de plante sunt impărțite în 5 categorii:

• FloweringPlants
• GymnospermsPlants
• Ferns
• Mosses
• Algae

O plantă are un singur tip de efect: ea crește nivelul de oxigen din aer, interacționând direct cu mediul atmosferic.

Fiecare plantă generează oxigen în atmosferă în funcție de:

• Categoria plantei → oferă oxigenul de bază
• Nivelul de maturitate → oferă un bonus

oxigen_level += (maturity_oxigen_rate + oxigen_from_plant)

Fiecare categorie de plantă are asociat un procentaj care indică probabilitatea ca roboțelul să se agațe de acea plantă.

plant_possibility / 100.0

Animalele se deplasează pe hartă și consumă plantele întâlnite, ceea ce le permite să producă îngrășământ și să îmbunătățească calitatea solului.

Animalul se mută pe una din pătrățelele vecine la fiecare 2 iterații pentru a se hrăni. Algoritmul de alegere este:

1. Se caută pătrățica care are plantă și apă. Dacă există mai multe, se alege cea cu calitatea apei mai bună.
2. Dacă nu există, se caută pătrățica care are plantă sau apă:
   • Dacă există plante, se alege prima pătrățică conform parcurgerii (sus, dreapta, jos, stânga).
   • Dacă nu există plante, se alege pătrățica cu apă, prioritar cea cu calitate mai bună.

Animalul poate fi în una din stările:

1. dacă animalul este de tip Carnivore sau Parasite
   1. se va mânca animalul de pe pătrățica curentă dacă există:
      • se va crește masa animalului curent: animalMass += preyMass.
      • entitatea Soil de pe pătrățica curentă va primi +0.5 organicMatter.
      • animalul mâncat va dispărea de pe hartă.
   2. dacă nu există un animal:
      • dacă entitea Water și entitea Plant de pe pătrățică au fost deblocate deja la un pas anterior sau prezent de către robot:
        • planta va muri.
        • se va calcula nivelul de apă de băut: waterToDrink = Math.min(animalMass * intakeRate, waterMass), intakeRate = 0.08.
        • se va actualiza masa apei: waterMass -= waterToDrink.
        • se va crește masa animalului curent: animalMass += (waterToDrink + plantMass).
        • entitatea Soil de pe pătrățica curentă va primi +0.8 organicMatter.
      • se va mânca entitatea Water sau Plant, în funcție de care entitate este deblocată prima de robot:
        • dacă se va mânca planta:
          • planta va muri.
          • se va crește masa animalului curent: animalMass += plantMass.
          • entitatea Soil de pe pătrățica curentă va primi +0.5 organicMatter.
        • dacă se va bea apă:
          • se va calcula nivelul de apă de băut: waterToDrink = Math.min(animalMass * intakeRate, waterMass), intakeRate = 0.08.
          • se va actualiza masa apei: waterMass -= waterToDrink.
          • se va crește masa animalului curent: animalMass += waterToDrink.
          • entitatea Soil de pe pătrățica curentă va primi +0.5 organicMatter.
      • dacă nicio entitate de pe pătrățica curentă nu a fost deblocată la un pas anterior sau prezent de către robot nu se va mânca nimic.
        • în această situație nu se va produce îngrășământ.
2. dacă animalul nu este de tip Carnivore sau Parasite:
   • se reiau toți pașii descriși la pasul precedent pentru cazul “dacă nu există un animal”.

Animalele pot ataca robotul chiar dacă nu au fost deblocate.

attack_probability = (100 - animal_possibility_to_attack) / 10.0

Apa este o resursă esențială în ecosistem, influențând direct solul, aerul, plantele și animalele. Fără apă, ciclurile biologice nu pot funcționa.

Apa influențează direct celelalte entități ale ecosistemului:

Calitatea apei se determină în doi pași:

1. Normalizarea factorilor:

   purity_score        = purity / 100
   pH_score            = 1 - abs(pH - 7.5) / 7.5
   salinity_score      = 1 - (salinity / 350)
   turbidity_score     = 1 - (turbidity / 100)
   contaminant_score   = 1 - (contaminantIndex / 100)
   frozen_score        = isFrozen ? 0 : 1

2. Formula finală:

   water_quality =
     (0.3 * purity_score
    + 0.2 * pH_score
    + 0.15 * salinity_score
    + 0.1 * turbidity_score
    + 0.15 * contaminant_score
    + 0.2 * frozen_score) * 100

Solul este esențial pentru creșterea plantelor și îmbunătățirea mediului. Acesta își poate crește calitatea prin absorbția apei și prin primirea de îngrășământ.

Solul interacționează cu plantele și apa:

Formula de calcul depinde de tipul solului:

normalizeScore = Math.max(0, Math.min(100, score))

Aerul este esențial pentru ecosistem, permițând animalelor să respire și să interacționeze cu mediul. Monitorizarea calității aerului este crucială pentru sănătatea animalelor și funcționarea TerraBot.

Calitatea aerului este calculată diferit pentru fiecare tip, folosind câmpurile specifice:

Nivelul de toxicitate se calculează astfel:

toxicityAQ = 100 * (1 - airQualityScore / maxScore)
finalResult = Math.round(toxicityAQ * 100.0) / 100.0

Evenimentele meteorologice modifică calitatea aerului:

Math.round(score * 100.0) / 100.0

Toxicitatea aerului și calitatea acestuia pot influența animalele și TerraBot. Se folosesc formulele din secțiunea Interacțiuni cu mediul pentru calcul.

În simulare, entitățile din mediu (Air, Soil, Water, Plant, Animal) pot interacționa între ele, influențându-se reciproc în timp.

Ordinea exactă în care sunt aplicate interacțiunile și actualizările este mereu aceeași:

1. Air
2. Soil
3. Water
4. Plant
5. Animal

Dacă la timestamp 3 se primește comanda scanObject pentru apă, atunci:

Abia la timestamp 5 vor începe actualizările (conform frecvențelor de mai sus) pentru:

• Water → Soil
• Water → Air

Fiecare simulare este independentă. Nu se păstrează inventarul robotului, energia sau starea mediului între simulări.

Simulările se execută una după alta, nu există simulări în paralel.

Comenzile trimise între endSimulation și următorul startSimulation sunt ignorate.

Fiecare celulă de pe hartă poate conține:

• maxim 1 plantă
• maxim 1 animal
• maxim 1 sursă de apă

• marchează începerea unei simulări
• robotul pornește mereu de pe poziția [0, 0] a hărții

Mesaje posibile pentru această comandă:

• "Simulation has started."

• "ERROR: Simulation already started. Cannot perform action"

• marchează sfârșitul unei simulări

Mesaje posibile pentru această comandă:

• "Simulation has ended."

• "ERROR: Simulation not started. Cannot perform action"

• marchează un fenomen meteo care produce schimbări pentru aer (vezi secțiunea Air)
• Valorile posibile pentru tipul de schimbare meteo:
  • desertStorm → desert air
  • peopleHiking → mountain air
  • newSeason → temp air
  • polarStorm → polar air
  • rainfall → tropical air

Mesaje posibile pentru această comandă:

• "The weather has changed."

• "ERROR: The weather change does not affect the environment. Cannot perform action"

• "ERROR: Simulation not started. Cannot perform action"

• consumă energie
• robotul se va muta pe pătrățelul cu scorul de calitate cel mai bun
• nu se poate explora mai departe de dimensiunea maximă a matricei
• se verifică dacă robotul are suficientă baterie pentru a se putea muta
• se poate trece în timpul simulării prin aceeași pătrățică
• consumul de baterie pentru mutare este raportat la scorul de calitate

Se va duce pe pătrățelul cu scorul de calitate cel mai bun (normalizat, de la 0 la 100, 100 find 0 scor la toate)

• ordinea în care se verifică celulele: sus, dreapta, jos, stânga
• pentru calcularea scorului, se vor lua în considerare următoarele lucruri
  • PossibilityToGetStuckInSoil
    • pentru fiecare categorie de sol, se ia procentul de a rămâne blocat în el (secțiune Soil)
  • PossibilityToGetDamagedByAir
    • pentru fiecare tip de aer, se iau valorile specifice și se înlocuiesc în formulele date (secțiune Air)
  • PossibilityToBeAttackedByAnimal
    • pentru fiecare categorie de animale, se ia procentul de a fi atacat de ele (secțiune Animal)
  • PossibiltyToGetStuckInPlants
    • pentru fiecare categorie de plante, se ia procentul de a rămâne blocat în ele (secțiune Plant)
• scorul final se calculează ca și medie aritmetică din cele 4 scori pentru fiecare posibilitate
• i se va scădea din baterie numărul de puncte echivalent cu valoarea scorulului obținut pentru celula pe care se va muta robotul (vezi exemplu mai jos)

• double sum = sum(possibilityToGetStuckInSoil + possibilityToGetDamagedByAir + possibilityToBeAttackedByAnimal + possibiltyToGetStuckInPlants)

• double mean = sum / count

• int result = (int) Math.round(mean)

Robotul poate să rămână fără baterie înainte să se mute pe altă pătrățică

• dacă robotul nu mai are baterie el nu se va deplasa până când nu se primește comada rechargeBattery pentru a-și încărca bateria, dar restul pașilor se vor executa, inclusiv cei de analiză și funcționalitățile automate din spate
• bateria se va consuma pentru fiecare mișcare a robotului pe altă celulă

Mesaje posibile pentru această comandă:

• "The robot has successfully moved to position ${(coord_X, coord_Y)}."

• "ERROR: Not enough battery left. Cannot perform action"

• "ERROR: Robot still charging. Cannot perform action"

• "ERROR: Simulation not started. Cannot perform action"

• se pune pauză simulării curente în derulare pentru ca roboțelul să se încarce unde se află în mod curent (are panouri solare 😎)
• se încarcă numărul de puncte de energie primite la input (1 punct de energie = 1min de încărcare)
  • exemplu: dacă se dă această comandă la timestamp 5 pentru 20 de puncte de energie, atunci următoarea comandă care poate fi efectuată va fi la timestamp 25

Mesaje posibile pentru această comandă:

• "The simulation was paused until charging is finished."

• "ERROR: Robot still charging. Cannot perform action"

• "ERROR: Simulation not started. Cannot perform action"

• consumă energie
• scanează un obiect (plantă, animal, apă) și salvează rezultatul (se salvează în baza de date și în inventar)
• se caută în harta salvată pentru secțiunea curentă de teritoriu dacă există un obiect de tipul respectiv pentru scanat (nu este garantat că se găsește pe hartă)
• consumă 7 puncte energie

Roboțelul scanează obiectele de pe pătrățica curentă și determină tipul acestuia în funcție de 3 parametrii:

• color
• smell
• sound

Combinațiile de parametrii pentru obiecte:

• none + none + none = water
• pink + sweet + none = plant
• brown + earthy + muuu = animal

Mesaje posibile pentru această comandă:

• "The scanned object is ${type_of_entity}"

• "ERROR: Object not found. Cannot perform action"

• "ERROR: Not enough battery left. Cannot perform action"

• "ERROR: Simulation not started. Cannot perform action"

• consumă energie
• adaugă un nou fapt științific sub un anumit subiect
• se primește un subiect și componentele pentru acel subiect, mai multe detalii la comanda de improveEnvironment
• consumă 2 puncte energie

Mesaje posibile pentru această comandă:

• "The fact has been successfully saved in the database."

• "ERROR: Subject not yet saved. Cannot perform action"

• "ERROR: Not enough battery left. Cannot perform action"

• "ERROR: Simulation not started. Cannot perform action"

• consumă energie
• robotul încearcă să îmbunătățească mediul de pe pătrățica curentă pentru a putea face planeta locuibilă
• consumă 10 puncte energie

Putem avea 4 tipuri de improvement:

• plantVegetation
  • +0.3 oxigen pentru aer față de cantitatea curentă
• fertilizeSoil
  • +0.3 organicMatter pentru soil
• increaseHumidity
  • +0.2 humidity la aer
• increaseMoisture
  • +0.2 waterRetention pentru apă

Mesaje posibile pentru această comandă:

• "The ${plant_name} was planted successfully."

• "The ${improved_entity} was successfully ${fertilized /increased } using ${component_name}"

• "ERROR: Subject not yet saved. Cannot perform action"

• "ERROR: Fact not yet saved. Cannot perform action"

• "ERROR: Not enough battery left. Cannot perform action"

• "ERROR: Simulation not started. Cannot perform action"

• returnează energia curentă a TerraBot-ului

Mesaje posibile pentru această comandă:

• "TerraBot has ${energy_points} energy points left."

• "ERROR: Simulation not started. Cannot perform action"

• se printează pentru pătrățica curentă următoarele:
  • tipul de plantă, dacă există
  • tipul de animal, dacă există
  • tipul de sursă de apă, dacă există
  • componenta solului
  • componenta aerului

Mesaje posibile pentru această comandă:

• "ERROR: Simulation not started. Cannot perform action"

• se printează pentru fiecare pătrățică de pe hartă următoarele:
  • numărul total de enități de pe pătrățică (sum(plant, animal, water_source))
  • calitate aerului
  • calitatea solului

Mesaje posibile pentru această comandă:

• "ERROR: Simulation not started. Cannot perform action"

• afișează pentru fiecare tip de entitate fact-urile învățate
  • exemplu: s-a scanat și învățat despre RedAlgae, se printează toate facts despre RedAlgae
• ordinea de printare va fi:
  • topic-urile vor fi în ordinea în care s-a efectuat scanarea lor
  • facts vor fi în ordinea în care au fost învățate de robot

Mesaje posibile pentru această comandă:

• "ERROR: Simulation not started. Cannot perform action"

Pentru a ilustra mai bine ordinea și efectul operațiilor din secțiunile anterioare, vă atașăm un exemplu minimal al unei simulări.

• Se citesc datele de la input și se reține preambulul cu parametrii pentru simulare.
• Se începe prelucrarea comenzilor

startSimulation

• Se încarcă datele pentru simularea curentă
• Se începe simularea de pe poziția (0, 0).
• Încă nu s-au scanat obiecte, deci nu se vor face schimbări automate pentru mediu sau entități.

moveRobot

• Se fac actualizările automate pentru interacțiuni, plante și animale
  • încă nu s-a efectuat o scanare, așadar încă nu avem interacțiuni
• Se fac actualizările automate pentru mediu - sol și aer
  • Se calculează doar calitatea aerului și a solului, întrucât robotul încă nu a scanat o entitate
  • Avem TemperateAir → se aplică formula specifică acestui tip de aer
    • double score = (oxygenLevel * 2) + (humidity * 0.7) - (pollenLevel * 0.1) = 81.0
    • double airQuality = Math.round(score * 100.0) / 100.0 = 81.0
  • Avem ForestSoil → se aplică formula specifică acestui tip de sol
    • double score = (nitrogen * 1.2) + (organicMatter * 2) + (waterRetention * 1.5) + (leafLitter * 0.3) = 4.409999999999999
    • double soilQuality = Math.round(score * 100.0) / 100.0 = 4.41
• Se identifică pătrățelele vecine: (0, 1) și (1, 0)
• Se parcurg pătrățelele vecine în ordinea sus, dreapta, jos, stânga ⇒ se va parcurge (0, 1) și apoi (1, 0)
• Celula (0, 1) are: animal, ForestSoil, apă, TemperateAir, plantă
• Celula (1, 0) are: animal, SwampSoil, apă, TemperateAir
• Se calculează fiecare posibilitate de daune pentru robot:

• Scorul final pentru pătrățica (1, 0): Math.round(3.69) = 4
• Scorul final pentru pătrățica (0, 1): Math.round(1.61125) = 2
• Scorul pentru pătrățica (0, 1) este mai bun ⇒ robotul se mută pe pătrățica (0, 1)
  • Un scor mai mic presupune șanse mai scăzute ca robotul să primească daune
• Se verifică dacă robotul mai are suficientă baterie pentru a se muta
  • nu s-au efectuat alte comenzi care să consume baterie, așadar robotul are 22 puncte energie
  • încă are suficientă baterie, deci se va afișa mesaj de succes
• Se actulizează cantitatea de baterie necesară pentru mutare: 22 - 2 = 20

scanObject

• Se fac actualizările automate pentru interacțiuni, plante și animale
  • încă nu s-a efectuat o scanare, așadar încă nu avem interacțiuni
• Se fac actualizările automate pentru mediu - sol și aer
  • întrucât tipul de soil și air sunt de același tip ca și celula anterioară, vom avea aceleași valori pentru calitatea solului și a aerului → airQuality = 81.0 și soilQuality = 4.41
• Se verifică dacă robotul are minim 7 puncte de energie rămase pentru a efectua comanda
  • are 18 puncte ramase → se va efectua comanda
• Se actulizează cantitatea de baterie: 20 - 7 = 13
• Robotul scanează un obiect
• Pe baza celor 3 parametrii scanați se determină că obiectul scanat este o plantă (pink + sweet + none)
• Se caută în baza de date a simulării dacă există planta pe celula curentă (0, 1)
  • se găsește că există o plantă Tulip și se returnează restul de detalii pentru plantă (type, name, etc.)
• Se salvează planta Tulip în inventar

printEnvConditions

• Se fac actualizările automate pentru interacțiuni, plante și animale
  • interacțiuni
    • Soil → Plant
      • planta curentă este Tulip și abia a fost scanată → va avea status “young” și growth rate 0
      • solul ajută planta să crească cu 0.2 ⇒ growthRate = 0 + 0.2 = 0.2
    • Plant → Air
      • aerul este de tip TemperateAir și are oxygenLevel = 20 (este valoarea de la citire nemodificată)
      • planta are statusul “young” → improveRate = 0.2
      • planta este de tipul FloweringPlants → oxygenFromPlant = 6.0
      • se va actualiza nivelul de oxigen: oxygenLevel = 20 + 6.0 + 0.2 = 26.2
• Se fac actualizările automate pentru mediu - sol și aer
  • noile valori pentru mediu: airQuality = 93.4 și soilQuality = 4.41
  • întrucât doar aerul a suferit modificări, doar calitatea acestuia se va actuliza, iar pentru sol va rămâne la fel
• Se printează toate detaliile despre pătrățica curentă

learnFact

• Se fac actualizările automate pentru interacțiuni, plante și animale
  • interacțiuni
    • Soil → Plant
      • solul ajută planta să crească cu 0.2 ⇒ growthRate = 0.2 + 0.2 = 0.4
    • Plant → Air
      • oxygenLevel = 26.2
      • planta are statusul “young” → improveRate = 0.2
      • planta este de tipul FloweringPlants → oxygenFromPlant = 6.0
      • se va actualiza nivelul de oxigen: oxygenLevel = 26.2 + 6.0 + 0.2 = 32.4
• Se fac actualizările automate pentru mediu - sol si aer
  • valorile pentru mediu (se modifică doar pentru aer): airQuality = 100.0 și soilQuality = 4.41
• Se verifică dacă robotul are minim 2 puncte de energie rămase pentru a efectua comanda
• Se actulizează cantitatea de baterie: 13 - 2 = 11
• Se verifică dacă obiectul pentru care s-a dat fact-ul există în inventarul robotului (ce este în câmpul de “components”)
  • există planta Tulip în inventar → se poate salva fact-ul
• Fact-ul se va salva în baza de date a robotului sub obiectul Tulip

improveEnvConditions

• Se fac actualizările automate pentru interacțiuni, plante și animale
  • interacțiuni
    • Soil → Plant
      • solul ajută planta să crească cu 0.2 ⇒ growthRate = 0.4 + 0.2 = 0.6
    • Plant → Air
      • oxygenLevel = 32.4
      • planta are statusul “young” → improveRate = 0.2
      • planta este de tipul FloweringPlants → oxygenFromPlant = 6.0
      • se va actualiza nivelul de oxigen: oxygenLevel = 32.4 + 6.0 + 0.2 = 38.6
• Se fac actualizările automate pentru mediu - sol si aer
  • valorile pentru mediu (nu se modifică): airQuality = 100.0 și soilQuality = 4.41
  • valoarea maximă pentru calitate este 100.0 → calitatea aerului nu se va actualiza
• Se verifică dacă robotul are minim 10 puncte de energie rămase pentru a efectua comanda
  • De la comada precedentă mai avem 11 puncte de energie, așadar se va efectua comanda
• * Se actulizează cantitatea de baterie: 11 - 10 = 1
• Se verifică cele 2 conditii pentru comandă:
  • dacă există în inventar obiectul cu name “Tulip”
  • dacă pentru obiectul de tip “Tulip” s-a salvat fact de tipul “method for “Method to plant Tulip”
• Cum cele 2 condiții sunt îndeplinite, se va aplica improvement-ul pe pătrățică
  • aerul este de tip TemperateAir și are oxygenLevel = 38.6
  • tipul de improvement este “plantVegetation” → trebuie actulatizat oxygenLevel cu + 0.3
  • oxygenLevel = 38.6 + 0.3 = 38.9
  • se va printa mesajul de succes pentru comandă

printEnvConditions

• Se fac actualizările automate pentru interacțiuni, plante și animale
  • interacțiuni
    • Soil → Plant
      • solul ajută planta să crească cu 0.2 ⇒ growthRate = 0.6 + 0.2 = 0.8
    • Plant → Air
      • oxygenLevel = 38.6
      • planta are statusul “young” → improveRate = 0.2
      • planta este de tipul FloweringPlants → oxygenFromPlant = 6.0
      • se va actualiza nivelul de oxigen: oxygenLevel = 38.6 + 6.0 + 0.2 = 45.1
• Se fac actualizările automate pentru mediu - sol si aer
  • valorile pentru mediu (nu se modifica): airQuality = 100.0 și soilQuality = 4.41
• Se printează toate detaliile despre pătrățica curentă

getEnergyStatus

• Se fac actualizările automate pentru interacțiuni, plante și animale
  • interacțiuni
    • Soil → Plant
      • solul ajută planta să crească cu 0.2 ⇒ growthRate = 0.8 + 0.2 = 1.0
      • s-a ajuns la growthRate = 1.0, deci trebuie schimbat statusul pentru plantă → din “young” va deveni “mature”
      • se va reseta growthRate la 0
    • Plant → Air
      • oxygenLevel = 45.1
      • planta are statusul “mature” → improveRate = 0.7
      • planta este de tipul FloweringPlants → oxygenFromPlant = 6.0
      • se va actualiza nivelul de oxigen: oxygenLevel = 45.1 + 6.0 + 0.7 = 51.8
• Se fac actualizările automate pentru mediu - sol și aer
  • valorile pentru mediu (nu se modifica): airQuality = 100.0 și soilQuality = 4.41
• Se printează bateria rămasă a robotului la momentul curent
  • mai este doar 1 punct de energie rămas în baterie

printMap

• Se fac actualizările automate pentru interacțiuni, plante și animale
  • interacțiuni
    • Soil → Plant
      • solul ajută planta să crească cu 0.2 ⇒ growthRate = 0 + 0.2 = 0.2
    • Plant → Air
      • oxygenLevel = 51.8
      • planta are statusul “mature” → improveRate = 0.7
      • planta este de tipul FloweringPlants → oxygenFromPlant = 6.0
      • se va actualiza nivelul de oxigen: oxygenLevel = 51.8 + 6.0 + 0.7 = 58.5
• Se fac actualizările automate pentru mediu - sol și aer
  • valorile pentru mediu (nu se modifica): airQuality = 100.0 și soilQuality = 4.41
• Se printează pentru fiecare pătrățică numărul de entități optionale - plantă, animal, apă - și calitatea solului și a aerului până la momentul curent

endSimulation

• Se încheie simularea
• Nu se mai pot procesa alte comenzi
• Se resetează câmpurile pentru a începe o nouă simulare

moveRobot

• comanda aceasta este primită dupa încheierea simulării, prin urmare nu se va efectua și se va afișa mesajul de eroare aferent

În rezolvarea temei va fi nevoie de folosirea unor obiecte pentru stocarea și maparea datelor primite în format JSON. Scheletul temei vă oferă mai multe clase utile pentru citirea și rularea temei. Acestea se regăsesc în cadrul scheletului, astfel:

• Clasele de input din cadrul pachetului fileio: Acestea se vor folosi pentru parsarea datelor de input. Astfel, preluați toate informațiile necesare pentru a crea propriile clase pentru rezolvarea temei.
• Clasa Main care este punctul de intrare pentru logica de rezolvare a temei.

Pentru a întelege mai bine cum funcționează citirea/scrierea în fișierele JSON vă recomandăm să citiți Json & Jackson sau Jackson Object Mapper tutorial (Baeldung).

Pentru a rula checker-ul intrați în fișierul “src/test/java/TestRunner” și rulați clasa.

O să vi se deschidă un panou în IntelliJ de unde puteți vedea statusul tuturor testelor. De asemenea, vi se va afișa și eroarea sau diferența rezultatului pe care îl aveți pentru fiecare test în parte.

• Tema a fost concepută pentru a vă testa cunoștințele dobândite în urma parcurgerii laboratoarelor 1-6, aceasta putând fi rezolvată doar cu noțiunile invățate din acele laboratoare.
• Tema fiind o specificație destul de stufoasă recomandăm citirea de cel putin două ori a enunțului inainte de inceperea implementării.

Puteți folosi modele de limbaj (LLM-uri) pentru asistență în realizarea temei doar ca instrument suplimentar, de exemplu pentru clarificări, explicații sau verificarea ideilor.

Totuși, recomandarea noastră este să încercați să rezolvați tema pe cont propriu, fără a depinde de astfel de instrumente. Scopul exercițiului este să învățați și să vă dezvoltați abilitățile, iar progresul real vine doar prin înțelegere și practică personală.

Puteți folosi LLM-uri pentru:

• explicații teoretice.
• exemple suplimentare.
• verificarea codului sau a ideilor.
• clarificarea unor concepte.

NU este acceptat să:

• trimiteți soluții generate integral de un LLM.
• folosiți cod sau text pe care nu îl înțelegeți.
• copiați fără să puteți explica ce ați făcut în cod.
• generați README-ul folosind un LLM.

Punctajul constă din:

• 80p implementare - trecerea testelor
• 10p coding style (vezi checkstyle)
• 5p README.md clar, concis, explicații axate pe design (flow, interacțiuni)
• 5p folosire git pentru versionarea temei

Depunctările pentru temă sunt acoperite în barem, totuși pot apărea depunctări care nu se află în imaginile furnizate.

Bonusuri: La evaluare, putem oferi bonusuri pentru design foarte bun, cod bine documentat dar și pentru diverse elemente suplimentare.

Folosirea git pentru versionare va fi verificata din folderul .git pe care trebuie să îl includeți în arhiva temei. Punctajul se va acorda dacă ați făcut minim 3 commit-uri relevante și cu mesaj sugestiv. NU este permis să aveți repository-urile de git publice până la deadline-ul hard.

Unul din obiectivele temei este învățarea respectării code-style-ului limbajului pe care îl folosiți. Aceste convenții (de exemplu cum numiți fișierele, clasele, variabilele, cum indentați) sunt verificate pentru temă de către tool-ul checkstyle (care se află în pom.xml ca dependență).

Pe pagina de Recomandări cod găsiți câteva exemple de coding style.

Dacă numărul de erori depistate de checkstyle depășește 30, atunci punctele pentru coding-style nu vor fi acordate. Dacă punctajul este negativ, acesta se trunchiază la 0.

Exemple:

• punctaj_total = 100 și nr_erori = 200 ⇒ nota_finala = 90
• punctaj_total = 100 și nr_erori = 29 ⇒ nota_finala = 100
• punctaj_total = 80 și nr_erori = 30 ⇒ nota_finala = 80
• punctaj_total = 80 și nr_erori = 31 ⇒ nota_finala = 70

1. test01_initialize_entities.json
2. test02_initialize_entities_errors.json
3. test03_move_robot.json
4. test04_move_robot_errors.json
5. test05_env_condition.json
6. test06_update_battery.json
7. test07_update_battery_errors.json
8. test08_change_weather.json
9. test09_scan_plant.json
10. test10_scan_water.json
11. test11_scan_animal.json
12. test12_scan_object_errors.json
13. test13_learn_fact.json
14. test14_improve_environment.json
15. test15_improve_environment_errors.json
16. test16_medium.json
17. test17_multiple_simulations.json
18. test18_multiple_simulations_errors.json
19. test19_complex.json
20. test20_complex_errors.json
21. test21_complex_combined.json

Arhiva o veţi urca pe Code Devmind, unde sunt si informații despre structura ei.

Q: Pot folosi biblioteca “X”?
A: Dacă doriți să folosiți o anumită bibliotecă vă recomandăm să întrebați pe forum, ca apoi să o validăm și să o includem și în pom-ul de pe Code Devmind.

Q: Pot folosi GSON în loc de Jackson?
A: Sigur, contează doar să aveți output-ul corect și să respectați convențiile de coding style și modularitate.

Q: Am descoperit edge case-ul “Y”, trebuie să îl tratez?
A: Nu. Toate datele necesare pentru soluționarea temei vă sunt date in cerință. Dacă totuși am omis ceva ne puteți contacta pe forum.

Q: Pot folosi clase de tip “Enum” pentru constante?
A: Da.

Q: Ce JDK recomandați?
A: 25

Q: Pot să fac în orice ordine testele?
A: Depinde. Testele au fost concepute sa fie cât mai decuplate și să testeze câte o funcționalitate în întregime. Cu toate astea, vă recomandăm să implementați mai întâi testele 01, 02, 03 deoarece reprezintă funcționalitățile de bază pentru rezolvarea următoarelor teste mai complexe.

• Schelet de cod
• Forum
• Indicații pentru teme
• Recomandări coding style & javadoc
• Tutorial Git