Lab5 do oceny

oolab/src/main/java/agh/ics/oop/Simulation.java

@@ -12,7 +12,6 @@ public class Simulation {
     public Simulation(List<Vector2d> positions, List<MoveDirection> moves, WorldMap map) {
         this.Moves = moves;
         this.Map = map;
-
         for(Vector2d position : positions) {
             Animal new_animal = new Animal(position.getX(), position.getY());
             if(map.place(new_animal)) {
@@ -23,6 +22,7 @@ public Simulation(List<Vector2d> positions, List<MoveDirection> moves, WorldMap
     }
 
     public void run() {
+        System.out.println(Map);
         int animal_count = Animals.size();
         int cnt = 0;
 

oolab/src/main/java/agh/ics/oop/World.java

@@ -4,6 +4,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 
 public class World {
@@ -27,11 +28,14 @@ public static void run(List<MoveDirection> directions) {
         }
     }
     public static void main(String[] args) {
-        List<MoveDirection> directions = OptionsParser.Parser(args);
+        String[] args1 = {"f", "b", "l", "r", "r", "f", "l", "b", "b"};
+        List<MoveDirection> directions = OptionsParser.Parser(args1);
         List<Vector2d> positions = List.of(new Vector2d(2,2), new Vector2d(3,4), new Vector2d(0,0));
-        WorldMap worldMap = new RectangularMap(5,5);
-        Simulation simulation = new Simulation(positions, directions, worldMap);
-        simulation.run();
+
+        GrassField map = new GrassField(10);
+        Simulation sim = new Simulation(positions, directions, map);
+        sim.run();
+
 
     }
 }

oolab/src/main/java/agh/ics/oop/model/AbstractWorldMap.java

@@ -0,0 +1,71 @@
+package agh.ics.oop.model;
+
+import agh.ics.oop.model.util.MapVisualizer;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public abstract class AbstractWorldMap implements WorldMap {
+    protected Map<Vector2d, Animal> animals = new HashMap<>();
+    protected Map<Vector2d, WorldElement> all_elements = new HashMap<>();
+    protected MapVisualizer mapVisualizer = new MapVisualizer(this);
+    Vector2d MAP_LEFT_BOTTOM = new Vector2d(0,0);
+    Vector2d MAP_RIGHT_TOP = new Vector2d(0,0);
+
+    @Override
+    public boolean place(Animal animal) {
+        if (canMoveTo(animal.getPosition())){
+            animals.put(animal.getPosition(), animal);
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public boolean canMoveTo(Vector2d position) {
+        return !animals.containsKey(position);
+    }
+
+    @Override
+    public WorldElement objectAt(Vector2d position) {
+        return animals.get(position);
+    }
+
+    @Override
+    public boolean isOccupied(Vector2d position) {
+        return animals.containsKey(position);
+    }
+
+    @Override
+    public void move(Animal animal, MoveDirection direction) {
+        Vector2d position = animal.getPosition();
+        if (animals.containsKey(position)){
+            animal.move(direction, this);
+            if (!position.equals(animal.getPosition())){
+                animals.put(animal.getPosition(), animal);
+                animals.remove(position);
+                int x = animal.getPosition().getX();
+                int y = animal.getPosition().getY();
+                Vector2d vec = new Vector2d(x, y);
+                calculateMapSize(vec);
+            }
+        }
+    }
+
+    public void calculateMapSize(Vector2d vec) {
+        MAP_LEFT_BOTTOM = MAP_LEFT_BOTTOM.lowerLeft(vec);
+        MAP_RIGHT_TOP = MAP_RIGHT_TOP.upperRight(vec);
+    }
+
+    public Map<Vector2d, WorldElement> getElements(){
+        for(Map.Entry<Vector2d, Animal> entry : animals.entrySet()){
+            Vector2d key = entry.getKey();
+            WorldElement element = entry.getValue();
+
+            all_elements.put(key, element);
+        }
+
+        return all_elements;
+    }
+}

oolab/src/main/java/agh/ics/oop/model/Animal.java

@@ -1,6 +1,6 @@
 package agh.ics.oop.model;
 
-public class Animal {
+public class Animal implements WorldElement {
     private MapDirection direction;
     private Vector2d position;
     public Animal() {

oolab/src/main/java/agh/ics/oop/model/Grass.java

@@ -0,0 +1,15 @@
+package agh.ics.oop.model;
+
+public class Grass implements WorldElement {
+    private final Vector2d position;
+    public Grass(Vector2d position) {
+        this.position = position;
+    }
+
+    public Vector2d getPosition() {
+        return position;
+    }
+    public String toString() {
+        return "*";
+    }
+}

oolab/src/main/java/agh/ics/oop/model/GrassField.java

@@ -0,0 +1,72 @@
+package agh.ics.oop.model;
+import agh.ics.oop.model.util.MapVisualizer;
+
+import java.util.*;
+
+public class GrassField extends AbstractWorldMap {
+    private int grass_amount;
+    private final Map<Vector2d, Grass> grass = new HashMap<>();
+
+
+    public GrassField(int grass_amount) {
+        this.grass_amount = grass_amount;
+        generatePositions();
+    }
+
+    public void generatePositions() {
+        int maxX = (int) Math.sqrt((double) grass_amount * 10);
+        int maxY = maxX;
+        Set<Vector2d> positions = new HashSet<>();
+        while (positions.size() < grass_amount) {
+            int x = (int) (Math.random() * maxX);
+            int y = (int) (Math.random() * maxY);
+            Vector2d vec = new Vector2d(x, y);
+            calculateMapSize(vec);
+            Vector2d position = new Vector2d(x, y);
+            positions.add(position);
+        }
+        for(Vector2d position : positions) {
+            grass.put(position, new Grass(position));
+        }
+    }
+    @Override
+    public String toString() {
+        return mapVisualizer.draw(MAP_LEFT_BOTTOM, MAP_RIGHT_TOP);
+    }
+
+
+    @Override
+    public boolean isOccupied(Vector2d position) {
+        return (super.isOccupied(position) || grass.containsKey(position));
+    }
+    @Override
+    public WorldElement objectAt(Vector2d position) {
+
+        if (grass.containsKey(position)) {
+            return grass.get(position);
+        }
+        return super.objectAt(position);
+    }
+
+    public Map<Vector2d, Grass> getGrass(){
+        return grass;
+    }
+
+    public Map<Vector2d, Animal> getAnimals(){
+        return animals;
+    }
+
+    @Override
+    public Map<Vector2d, WorldElement> getElements(){
+        Map<Vector2d, WorldElement> all_animals = super.getElements();
+
+        for(Map.Entry<Vector2d, Grass> entry : grass.entrySet()){
+            Vector2d key = entry.getKey();
+            WorldElement element = entry.getValue();
+
+            all_elements.put(key, element);
+        }
+
+        return all_elements;
+    }
+}

oolab/src/main/java/agh/ics/oop/model/RectangularMap.java

@@ -1,57 +1,26 @@
 package agh.ics.oop.model;
-
 import agh.ics.oop.model.util.MapVisualizer;
-
 import java.util.HashMap;
 import java.util.Map;
+public class RectangularMap extends AbstractWorldMap {
 
-public class RectangularMap implements WorldMap {
-    private Map<Vector2d, Animal> animals = new HashMap<>();
     private final int width;
     private final int height;
     private final Vector2d MAP_RIGHT_TOP;
     private final Vector2d MAP_LEFT_BOTTOM;
     private final MapVisualizer mapVisualizer = new MapVisualizer(this);
-
     public RectangularMap(int width, int height) {
         this.width = width;
         this.height = height;
-
         MAP_RIGHT_TOP = new Vector2d(width - 1, height - 1);
         MAP_LEFT_BOTTOM = new Vector2d(0,0);
     }
-    @Override
-    public void move(Animal animal, MoveDirection direction) {
-        Vector2d position = animal.getPosition();
-        if (animals.containsKey(position)){
-            animal.move(direction, this);
-            if (!position.equals(animal.getPosition())){
-                animals.put(animal.getPosition(), animal);
-                animals.remove(position);
-            }
-        }
-    }
-    @Override
-    public boolean place(Animal animal) {
-        if (canMoveTo(animal.getPosition())){
-            animals.put(animal.getPosition(), animal);
-            return true;
-        }
-        return false;
-    }
-    @Override
-    public boolean isOccupied(Vector2d position) {
-        return animals.containsKey(position);
-    }
-    @Override
-    public Animal objectAt(Vector2d position) {
-        return animals.get(position);
-    }
+
+
     @Override
     public boolean canMoveTo(Vector2d position) {
         return (!isOccupied(position) && position.precedes(MAP_RIGHT_TOP) && position.follows(MAP_LEFT_BOTTOM));
     }
-
     public Vector2d getMAP_RIGHT_TOP() {
         return MAP_RIGHT_TOP;
     }
@@ -62,4 +31,4 @@ public Vector2d getMAP_LEFT_BOTTOM() {
     public String toString(){
         return mapVisualizer.draw(MAP_LEFT_BOTTOM, MAP_RIGHT_TOP);
     }
-}
+}

oolab/src/main/java/agh/ics/oop/model/WorldElement.java

@@ -0,0 +1,7 @@
+package agh.ics.oop.model;
+
+public interface WorldElement {
+    String toString();
+
+    Vector2d getPosition();
+}

oolab/src/main/java/agh/ics/oop/model/WorldMap.java

@@ -41,5 +41,5 @@ public interface WorldMap extends MoveValidator {
      * @param position The position of the animal.
      * @return animal or null if the position is not occupied.
      */
-    Animal objectAt(Vector2d position);
+    WorldElement objectAt(Vector2d position);
 }

oolab/src/main/java/agh/ics/oop/model/util/MapVisualizer.java

@@ -1,6 +1,7 @@
 package agh.ics.oop.model.util;
 
 import agh.ics.oop.model.Vector2d;
+import agh.ics.oop.model.WorldElement;
 import agh.ics.oop.model.WorldMap;
 
 /**
@@ -75,7 +76,9 @@ private String drawHeader(Vector2d lowerLeft, Vector2d upperRight) {
 
     private String drawObject(Vector2d currentPosition) {
         if (this.map.isOccupied(currentPosition)) {
+
             Object object = this.map.objectAt(currentPosition);
+
             if (object != null) {
                 return object.toString();
             }

oolab/src/test/java/agh/ics/oop/model/GrassFieldTest.java

@@ -0,0 +1,58 @@
+package agh.ics.oop.model;
+
+import agh.ics.oop.OptionsParser;
+import agh.ics.oop.Simulation;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class GrassFieldTest {
+    @Test
+    public void placeTest() {
+        List<Vector2d> positions = List.of(new Vector2d(2,2), new Vector2d(3,4), new Vector2d(0,0));
+        GrassField map = new GrassField(10);
+        Map<Vector2d, Animal> finalAnimals = map.getAnimals();
+
+        for(Vector2d position : positions) {
+            map.place(new Animal(position.getX(), position.getY()));
+        }
+
+        assertTrue(finalAnimals.containsKey(new Vector2d(3,4)));
+        assertTrue(finalAnimals.containsKey(new Vector2d(0,0)));
+        assertTrue(finalAnimals.containsKey(new Vector2d(2,2)));
+        assertFalse(finalAnimals.containsKey(new Vector2d(1,2)));
+    }
+
+    @Test
+    public void isOccupiedTest() {
+        List<Vector2d> positions = List.of(new Vector2d(2,2), new Vector2d(5,7), new Vector2d(-4,0));
+        GrassField map = new GrassField(10);
+
+        for(Vector2d position : positions) {
+            map.place(new Animal(position.getX(), position.getY()));
+        }
+
+        assertTrue(map.isOccupied(new Vector2d(2,2)));
+        assertTrue(map.isOccupied(new Vector2d(5,7)));
+        assertTrue(map.isOccupied(new Vector2d(-4,0)));
+    }
+
+    @Test
+    public void objectAtTest() {
+        List<Vector2d> positions = List.of(new Vector2d(2,2));
+        GrassField map = new GrassField(10);
+
+        for(Vector2d position : positions) {
+            map.place(new Animal(position.getX(), position.getY()));
+        }
+
+        Animal animal = (Animal) map.objectAt(new Vector2d(2,2));
+        Vector2d vec = animal.getPosition();
+
+        assertEquals(vec, new Vector2d(2,2));
+    }
+}