diff --git a/.gitignore b/.gitignore
index 2c6eb3893..c5b2fd429 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,6 @@
 /.metadata
 /robots/.settings
 /robots/bin
-eclipse.bat
\ No newline at end of file
+eclipse.bat
+/out/
+/.idea/
diff --git a/robots/src/controllers/RobotUpdateController.java b/robots/src/controllers/RobotUpdateController.java
new file mode 100644
index 000000000..055389aba
--- /dev/null
+++ b/robots/src/controllers/RobotUpdateController.java
@@ -0,0 +1,29 @@
+package controllers;
+
+import models.RobotModel;
+
+import java.util.Timer;
+import java.util.TimerTask;
+
+public class RobotUpdateController {
+
+    private final Timer m_timer = initTimer();
+    private RobotModel m_model;
+    private static Timer initTimer() {
+        Timer timer = new Timer("events generator", true);
+        return timer;
+    }
+    public RobotUpdateController(RobotModel model){
+        m_model=model;
+        m_timer.schedule(new TimerTask() {
+            @Override
+            public void run() {
+                updateModel();
+            }
+        }, 0, 10);
+    }
+
+    public void updateModel(){
+        m_model.updatePos();
+    }
+}
diff --git a/robots/src/controllers/TargetPositionController.java b/robots/src/controllers/TargetPositionController.java
new file mode 100644
index 000000000..c36d945c4
--- /dev/null
+++ b/robots/src/controllers/TargetPositionController.java
@@ -0,0 +1,17 @@
+package controllers;
+
+import models.TargetModel;
+
+import java.awt.*;
+
+public class TargetPositionController {
+    private TargetModel m_model;
+
+
+    public TargetPositionController(TargetModel model){
+        m_model=model;
+    }
+    public void setTargetPos(Point p){
+        m_model.setPos(p.x,p.y);
+    }
+}
diff --git a/robots/src/gui/GameVisualizer.java b/robots/src/gui/GameVisualizer.java
index f82cfd8f8..34f3d7b6a 100644
--- a/robots/src/gui/GameVisualizer.java
+++ b/robots/src/gui/GameVisualizer.java
@@ -1,61 +1,42 @@
 package gui;
 
-import java.awt.Color;
-import java.awt.EventQueue;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.Point;
+import controllers.TargetPositionController;
+import gui.drawModels.RobotRepresentation;
+import gui.drawModels.TargetRepresentation;
+import models.RobotModel;
+import models.TargetModel;
+
+import java.awt.*;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
-import java.awt.geom.AffineTransform;
-import java.util.Timer;
-import java.util.TimerTask;
+import java.util.Observable;
+import java.util.Observer;
 
 import javax.swing.JPanel;
 
-public class GameVisualizer extends JPanel
-{
-    private final Timer m_timer = initTimer();
-    
-    private static Timer initTimer() 
-    {
-        Timer timer = new Timer("events generator", true);
-        return timer;
-    }
-    
-    private volatile double m_robotPositionX = 100;
-    private volatile double m_robotPositionY = 100; 
-    private volatile double m_robotDirection = 0; 
-
-    private volatile int m_targetPositionX = 150;
-    private volatile int m_targetPositionY = 100;
-    
-    private static final double maxVelocity = 0.1; 
-    private static final double maxAngularVelocity = 0.001; 
-    
-    public GameVisualizer() 
-    {
-        m_timer.schedule(new TimerTask()
-        {
-            @Override
-            public void run()
-            {
-                onRedrawEvent();
-            }
-        }, 0, 50);
-        m_timer.schedule(new TimerTask()
-        {
-            @Override
-            public void run()
-            {
-                onModelUpdateEvent();
-            }
-        }, 0, 10);
-        addMouseListener(new MouseAdapter()
-        {
+public class GameVisualizer extends JPanel implements Observer {
+
+
+
+    private RobotRepresentation m_robotView;
+    private TargetRepresentation m_targetView;
+
+    private TargetPositionController m_targetController;
+    private RobotModel m_robot;
+
+
+
+
+    public GameVisualizer(TargetPositionController modelController, RobotModel model, TargetModel target) {
+
+        m_robot =model;
+        m_robotView = new RobotRepresentation(m_robot);
+        m_targetView = new TargetRepresentation(target);
+        m_targetController = modelController;
+
+        addMouseListener(new MouseAdapter() {
             @Override
-            public void mouseClicked(MouseEvent e)
-            {
+            public void mouseClicked(MouseEvent e) {
                 setTargetPosition(e.getPoint());
                 repaint();
             }
@@ -63,148 +44,35 @@ public void mouseClicked(MouseEvent e)
         setDoubleBuffered(true);
     }
 
-    protected void setTargetPosition(Point p)
-    {
-        m_targetPositionX = p.x;
-        m_targetPositionY = p.y;
+    protected void setTargetPosition(Point p) {
+
+
+        m_targetController.setTargetPos(p);
     }
-    
-    protected void onRedrawEvent()
-    {
+
+    protected void onRedrawEvent() {
         EventQueue.invokeLater(this::repaint);
     }
 
-    private static double distance(double x1, double y1, double x2, double y2)
-    {
-        double diffX = x1 - x2;
-        double diffY = y1 - y2;
-        return Math.sqrt(diffX * diffX + diffY * diffY);
-    }
-    
-    private static double angleTo(double fromX, double fromY, double toX, double toY)
-    {
-        double diffX = toX - fromX;
-        double diffY = toY - fromY;
-        
-        return asNormalizedRadians(Math.atan2(diffY, diffX));
-    }
-    
-    protected void onModelUpdateEvent()
-    {
-        double distance = distance(m_targetPositionX, m_targetPositionY, 
-            m_robotPositionX, m_robotPositionY);
-        if (distance < 0.5)
-        {
-            return;
-        }
-        double velocity = maxVelocity;
-        double angleToTarget = angleTo(m_robotPositionX, m_robotPositionY, m_targetPositionX, m_targetPositionY);
-        double angularVelocity = 0;
-        if (angleToTarget > m_robotDirection)
-        {
-            angularVelocity = maxAngularVelocity;
-        }
-        if (angleToTarget < m_robotDirection)
-        {
-            angularVelocity = -maxAngularVelocity;
-        }
-        
-        moveRobot(velocity, angularVelocity, 10);
-    }
-    
-    private static double applyLimits(double value, double min, double max)
-    {
-        if (value < min)
-            return min;
-        if (value > max)
-            return max;
-        return value;
-    }
-    
-    private void moveRobot(double velocity, double angularVelocity, double duration)
-    {
-        velocity = applyLimits(velocity, 0, maxVelocity);
-        angularVelocity = applyLimits(angularVelocity, -maxAngularVelocity, maxAngularVelocity);
-        double newX = m_robotPositionX + velocity / angularVelocity * 
-            (Math.sin(m_robotDirection  + angularVelocity * duration) -
-                Math.sin(m_robotDirection));
-        if (!Double.isFinite(newX))
-        {
-            newX = m_robotPositionX + velocity * duration * Math.cos(m_robotDirection);
-        }
-        double newY = m_robotPositionY - velocity / angularVelocity * 
-            (Math.cos(m_robotDirection  + angularVelocity * duration) -
-                Math.cos(m_robotDirection));
-        if (!Double.isFinite(newY))
-        {
-            newY = m_robotPositionY + velocity * duration * Math.sin(m_robotDirection);
-        }
-        m_robotPositionX = newX;
-        m_robotPositionY = newY;
-        double newDirection = asNormalizedRadians(m_robotDirection + angularVelocity * duration); 
-        m_robotDirection = newDirection;
-    }
 
-    private static double asNormalizedRadians(double angle)
-    {
-        while (angle < 0)
-        {
-            angle += 2*Math.PI;
-        }
-        while (angle >= 2*Math.PI)
-        {
-            angle -= 2*Math.PI;
-        }
-        return angle;
-    }
-    
-    private static int round(double value)
-    {
-        return (int)(value + 0.5);
+    protected void onModelUpdateEvent() {
+        onRedrawEvent();
     }
-    
+
+
     @Override
-    public void paint(Graphics g)
-    {
+    public void paint(Graphics g) {
         super.paint(g);
-        Graphics2D g2d = (Graphics2D)g; 
-        drawRobot(g2d, round(m_robotPositionX), round(m_robotPositionY), m_robotDirection);
-        drawTarget(g2d, m_targetPositionX, m_targetPositionY);
-    }
-    
-    private static void fillOval(Graphics g, int centerX, int centerY, int diam1, int diam2)
-    {
-        g.fillOval(centerX - diam1 / 2, centerY - diam2 / 2, diam1, diam2);
-    }
-    
-    private static void drawOval(Graphics g, int centerX, int centerY, int diam1, int diam2)
-    {
-        g.drawOval(centerX - diam1 / 2, centerY - diam2 / 2, diam1, diam2);
-    }
-    
-    private void drawRobot(Graphics2D g, int x, int y, double direction)
-    {
-        int robotCenterX = round(m_robotPositionX); 
-        int robotCenterY = round(m_robotPositionY);
-        AffineTransform t = AffineTransform.getRotateInstance(direction, robotCenterX, robotCenterY); 
-        g.setTransform(t);
-        g.setColor(Color.MAGENTA);
-        fillOval(g, robotCenterX, robotCenterY, 30, 10);
-        g.setColor(Color.BLACK);
-        drawOval(g, robotCenterX, robotCenterY, 30, 10);
-        g.setColor(Color.WHITE);
-        fillOval(g, robotCenterX  + 10, robotCenterY, 5, 5);
-        g.setColor(Color.BLACK);
-        drawOval(g, robotCenterX  + 10, robotCenterY, 5, 5);
+        Graphics2D g2d = (Graphics2D) g;
+        m_robotView.draw(g2d);
+        m_targetView.draw(g2d);
+
     }
-    
-    private void drawTarget(Graphics2D g, int x, int y)
-    {
-        AffineTransform t = AffineTransform.getRotateInstance(0, 0, 0); 
-        g.setTransform(t);
-        g.setColor(Color.GREEN);
-        fillOval(g, x, y, 5, 5);
-        g.setColor(Color.BLACK);
-        drawOval(g, x, y, 5, 5);
+
+
+    @Override
+    public void update(Observable o, Object arg) {
+        EventQueue.invokeLater(this::onModelUpdateEvent);
     }
+
 }
diff --git a/robots/src/gui/GameWindow.java b/robots/src/gui/GameWindow.java
index ecb63c00f..6612fab60 100644
--- a/robots/src/gui/GameWindow.java
+++ b/robots/src/gui/GameWindow.java
@@ -1,5 +1,10 @@
 package gui;
 
+import controllers.TargetPositionController;
+import models.RobotModel;
+import models.TargetModel;
+
+
 import java.awt.BorderLayout;
 
 import javax.swing.JInternalFrame;
@@ -8,10 +13,12 @@
 public class GameWindow extends JInternalFrame
 {
     private final GameVisualizer m_visualizer;
-    public GameWindow() 
+    public GameWindow(RobotModel model, TargetPositionController controller, TargetModel target)
     {
         super("Игровое поле", true, true, true, true);
-        m_visualizer = new GameVisualizer();
+
+        m_visualizer = new GameVisualizer(controller,model,target);
+        model.addObserver(m_visualizer);
         JPanel panel = new JPanel(new BorderLayout());
         panel.add(m_visualizer, BorderLayout.CENTER);
         getContentPane().add(panel);
diff --git a/robots/src/gui/MainApplicationFrame.java b/robots/src/gui/MainApplicationFrame.java
index 62e943ee1..328cc02ae 100644
--- a/robots/src/gui/MainApplicationFrame.java
+++ b/robots/src/gui/MainApplicationFrame.java
@@ -14,7 +14,10 @@
 import javax.swing.UIManager;
 import javax.swing.UnsupportedLookAndFeelException;
 
+import controllers.TargetPositionController;
 import log.Logger;
+import models.RobotModel;
+import models.TargetModel;
 
 /**
  * Что требуется сделать:
@@ -26,7 +29,7 @@ public class MainApplicationFrame extends JFrame
 {
     private final JDesktopPane desktopPane = new JDesktopPane();
     
-    public MainApplicationFrame() {
+    public MainApplicationFrame(RobotModel model, TargetPositionController controller, TargetModel target) {
         //Make the big window be indented 50 pixels from each edge
         //of the screen.
         int inset = 50;        
@@ -36,13 +39,18 @@ public MainApplicationFrame() {
             screenSize.height - inset*2);
 
         setContentPane(desktopPane);
-        
+
         
         LogWindow logWindow = createLogWindow();
         addWindow(logWindow);
 
-        GameWindow gameWindow = new GameWindow();
+
+        GameWindow gameWindow = new GameWindow(model,controller,target);
         gameWindow.setSize(400,  400);
+
+        PositionShowWindow coordWindow=new PositionShowWindow(model);
+        coordWindow.setSize(200,100);
+        addWindow(coordWindow);
         addWindow(gameWindow);
 
         setJMenuBar(generateMenuBar());
diff --git a/robots/src/gui/PositionShowWindow.java b/robots/src/gui/PositionShowWindow.java
new file mode 100644
index 000000000..cd519c5f2
--- /dev/null
+++ b/robots/src/gui/PositionShowWindow.java
@@ -0,0 +1,39 @@
+package gui;
+
+
+import models.RobotModel;
+import models.states.RobotStateReader;
+
+import javax.swing.*;
+import java.awt.*;
+import java.util.Observable;
+import java.util.Observer;
+
+public class PositionShowWindow extends JInternalFrame implements Observer {
+    private RobotModel m_model;
+    private JLabel m_labelX;
+    private JLabel m_labelY;
+    public PositionShowWindow(RobotModel model){
+        super("Robot coordinates", true, true, true, true);
+        m_model=model;
+        RobotStateReader state= m_model.getState();
+        m_labelX=new JLabel("X : %f".formatted(state.getX()));
+        m_labelY=new JLabel("T : %f".formatted(state.getY()));
+        m_model.addObserver(this);
+        JPanel panel = new JPanel(new BorderLayout());
+        panel.add(m_labelX, BorderLayout.CENTER);
+        panel.add(m_labelY, BorderLayout.AFTER_LAST_LINE);
+        getContentPane().add(panel);
+        pack();
+    }
+
+    @Override
+    public void update(Observable o, Object arg) {
+        EventQueue.invokeLater(this::onTextUpdate);
+    }
+    void onTextUpdate(){
+        RobotStateReader state= m_model.getState();
+        m_labelX.setText("X : %f".formatted(state.getX()));
+        m_labelY.setText("Y : %f".formatted(state.getY()));
+    }
+}
diff --git a/robots/src/gui/RobotsProgram.java b/robots/src/gui/RobotsProgram.java
index ae0930a8b..040b3427c 100644
--- a/robots/src/gui/RobotsProgram.java
+++ b/robots/src/gui/RobotsProgram.java
@@ -1,5 +1,10 @@
 package gui;
 
+import controllers.TargetPositionController;
+import controllers.RobotUpdateController;
+import models.RobotModel;
+import models.TargetModel;
+
 import java.awt.Frame;
 
 import javax.swing.SwingUtilities;
@@ -17,7 +22,12 @@ public static void main(String[] args) {
         e.printStackTrace();
       }
       SwingUtilities.invokeLater(() -> {
-        MainApplicationFrame frame = new MainApplicationFrame();
+        TargetModel target=new TargetModel(150,100);
+        RobotModel model=new RobotModel(100,100,100,target);
+        RobotUpdateController updateController = new RobotUpdateController(model);
+        TargetPositionController movementController=new TargetPositionController(target);
+
+        MainApplicationFrame frame = new MainApplicationFrame(model, movementController, target);
         frame.pack();
         frame.setVisible(true);
         frame.setExtendedState(Frame.MAXIMIZED_BOTH);
diff --git a/robots/src/gui/drawModels/Drawable.java b/robots/src/gui/drawModels/Drawable.java
new file mode 100644
index 000000000..24f9383ac
--- /dev/null
+++ b/robots/src/gui/drawModels/Drawable.java
@@ -0,0 +1,15 @@
+package gui.drawModels;
+
+import java.awt.*;
+
+public interface Drawable {
+    void draw(Graphics2D g);
+
+
+
+
+
+
+
+
+}
diff --git a/robots/src/gui/drawModels/RobotRepresentation.java b/robots/src/gui/drawModels/RobotRepresentation.java
new file mode 100644
index 000000000..b9866eac7
--- /dev/null
+++ b/robots/src/gui/drawModels/RobotRepresentation.java
@@ -0,0 +1,37 @@
+package gui.drawModels;
+import models.RobotModel;
+import models.states.RobotStateReader;
+
+import static utils.DrawUtils.*;
+import static utils.MathUtils.*;
+import java.awt.*;
+import java.awt.geom.AffineTransform;
+
+public class RobotRepresentation implements Drawable{
+    private RobotModel m_model;
+
+    public RobotRepresentation(RobotModel model) {
+        m_model=model;
+    }
+
+
+    @Override
+    public void draw(Graphics2D g) {
+        RobotStateReader state=m_model.getState();
+        int robotCenterX = round(state.getX());
+        int robotCenterY = round(state.getY());
+        AffineTransform t = AffineTransform.getRotateInstance(state.getDir(), robotCenterX, robotCenterY);
+        g.setTransform(t);
+        g.setColor(Color.MAGENTA);
+        fillOval(g, robotCenterX, robotCenterY, 30, 10);
+        g.setColor(Color.BLACK);
+        drawOval(g, robotCenterX, robotCenterY, 30, 10);
+        g.setColor(Color.WHITE);
+        fillOval(g, robotCenterX  + 10, robotCenterY, 5, 5);
+        g.setColor(Color.BLACK);
+        drawOval(g, robotCenterX  + 10, robotCenterY, 5, 5);
+    }
+
+
+
+}
diff --git a/robots/src/gui/drawModels/TargetRepresentation.java b/robots/src/gui/drawModels/TargetRepresentation.java
new file mode 100644
index 000000000..fc71f4d91
--- /dev/null
+++ b/robots/src/gui/drawModels/TargetRepresentation.java
@@ -0,0 +1,34 @@
+package gui.drawModels;
+
+
+import models.TargetModel;
+import models.states.TargetStateReader;
+
+import java.awt.*;
+import java.awt.geom.AffineTransform;
+
+import static utils.DrawUtils.*;
+import static utils.MathUtils.*;
+
+public class TargetRepresentation implements Drawable {
+
+    private TargetModel m_model;
+
+    public TargetRepresentation(TargetModel model) {
+        m_model=model;
+    }
+
+
+    @Override
+    public void draw(Graphics2D g) {
+        TargetStateReader targetCoord=m_model.getState();
+        AffineTransform t = AffineTransform.getRotateInstance(0, 0, 0);
+        g.setTransform(t);
+        g.setColor(Color.GREEN);
+        fillOval(g, round(targetCoord.getX()) ,round(targetCoord.getY()) , 5, 5);
+        g.setColor(Color.BLACK);
+        drawOval(g, round(targetCoord.getX()) ,round(targetCoord.getY()),  5, 5);
+    }
+
+
+}
diff --git a/robots/src/models/RobotModel.java b/robots/src/models/RobotModel.java
new file mode 100644
index 000000000..4d0c78604
--- /dev/null
+++ b/robots/src/models/RobotModel.java
@@ -0,0 +1,113 @@
+package models;
+
+
+import models.states.RobotState;
+import models.states.RobotStateReader;
+import models.states.TargetStateReader;
+
+import static utils.MathUtils.*;
+import java.util.Observable;
+
+public class RobotModel extends Observable {
+
+
+    private volatile double m_PositionX = 100;
+    private volatile double m_PositionY = 100;
+    private TargetModel m_Target;
+
+    private volatile double m_Direction = 0;
+
+
+    private double turn_duration=10;
+
+    private static final double maxVelocity = 0.1;
+    private static final double maxAngularVelocity = 0.001;
+
+
+    public RobotModel(double m_PositionX, double m_PositionY, double m_Direction,TargetModel target) {
+        this.m_PositionX = m_PositionX;
+        this.m_PositionY = m_PositionY;
+        this.m_Direction = m_Direction;
+        m_Target=target;
+    }
+
+
+    public void updatePos(){
+        if(isTooClose()){
+            return;
+        }
+        double velocity=calculateVelocity();
+        double angular = calculateAngularVelocity();
+        move(velocity,angular);
+        setChanged();
+        notifyObservers();
+    }
+
+
+
+    public RobotStateReader getState(){
+        RobotState ans;
+        synchronized (this){
+            ans=new RobotState(m_PositionX,m_PositionY,m_Direction);
+        }
+        return ans;
+
+    }
+
+
+    private double calculateVelocity(){
+        return maxVelocity;
+    }
+    private double calculateAngularVelocity(){
+        TargetStateReader targetCoord= m_Target.getState();
+        double angleToTarget = angleTo(m_PositionX, m_PositionY, targetCoord.getX(), targetCoord.getY());
+        double angularVelocity = 0;
+        if (angleToTarget > m_Direction)
+        {
+            angularVelocity = maxAngularVelocity;
+        }
+        if (angleToTarget < m_Direction)
+        {
+            angularVelocity = -maxAngularVelocity;
+        }
+        if(Math.abs(angleToTarget-m_Direction)>Math.PI){
+            angularVelocity=-angularVelocity;
+
+        }
+        return angularVelocity;
+    }
+    private boolean isTooClose(){
+        TargetStateReader targetCoord= m_Target.getState();
+        double distance = distance(targetCoord.getX(), targetCoord.getY(),
+                m_PositionX, m_PositionY);
+        return distance<0.5;
+    }
+    private void move(double velocity,double angularVelocity){
+        velocity = applyLimits(velocity, 0, maxVelocity);
+        angularVelocity = applyLimits(angularVelocity, -maxAngularVelocity, maxAngularVelocity);
+        double newX = m_PositionX + velocity / angularVelocity *
+                (Math.sin(m_Direction  + angularVelocity * turn_duration) -
+                        Math.sin(m_Direction));
+        if (!Double.isFinite(newX))
+        {
+            newX = m_PositionX + velocity * turn_duration * Math.cos(m_Direction);
+        }
+        double newY = m_PositionY - velocity / angularVelocity *
+                (Math.cos(m_Direction  + angularVelocity * turn_duration) -
+                        Math.cos(m_Direction));
+        if (!Double.isFinite(newY))
+        {
+            newY = m_PositionY + velocity * turn_duration * Math.sin(m_Direction);
+        }
+        m_PositionX = newX;
+        m_PositionY = newY;
+        double newDirection = asNormalizedRadians(m_Direction + angularVelocity * turn_duration);
+        m_Direction = newDirection;
+    }
+
+
+
+
+
+
+}
diff --git a/robots/src/models/TargetModel.java b/robots/src/models/TargetModel.java
new file mode 100644
index 000000000..a8202de89
--- /dev/null
+++ b/robots/src/models/TargetModel.java
@@ -0,0 +1,32 @@
+package models;
+
+
+import models.states.TargetState;
+import models.states.TargetStateReader;
+
+import java.util.Observable;
+
+public class TargetModel extends Observable {
+    private volatile double m_PositionX = 100;
+    private volatile double m_PositionY = 100;
+
+    public TargetModel(double posX, double posY) {
+        setPos(posX, posY);
+    }
+
+
+    public TargetStateReader getState(){
+        TargetStateReader ans;
+        synchronized (this){
+            ans=new TargetState(m_PositionX,m_PositionY);
+        }
+        return ans;
+    }
+
+    public void setPos(double posX, double posY) {
+        m_PositionX = posX;
+        m_PositionY = posY;
+        setChanged();
+        notifyObservers();
+    }
+}
diff --git a/robots/src/models/states/RobotState.java b/robots/src/models/states/RobotState.java
new file mode 100644
index 000000000..83b090f28
--- /dev/null
+++ b/robots/src/models/states/RobotState.java
@@ -0,0 +1,32 @@
+package models.states;
+
+public class RobotState implements RobotStateReader{
+
+
+    private volatile double m_x;
+    private volatile double m_y;
+    private volatile double m_dir;
+
+    public RobotState(double m_x, double m_y, double m_dir) {
+        this.m_x = m_x;
+        this.m_y = m_y;
+        this.m_dir = m_dir;
+    }
+
+    @Override
+    public double getX() {
+        return m_x;
+    }
+
+    @Override
+    public double getY() {
+        return m_y;
+    }
+
+    @Override
+    public double getDir() {
+        return m_dir;
+    }
+
+
+}
diff --git a/robots/src/models/states/RobotStateReader.java b/robots/src/models/states/RobotStateReader.java
new file mode 100644
index 000000000..543c6842b
--- /dev/null
+++ b/robots/src/models/states/RobotStateReader.java
@@ -0,0 +1,7 @@
+package models.states;
+
+public interface RobotStateReader {
+    double getX();
+    double getY();
+    double getDir();
+}
diff --git a/robots/src/models/states/TargetState.java b/robots/src/models/states/TargetState.java
new file mode 100644
index 000000000..399404908
--- /dev/null
+++ b/robots/src/models/states/TargetState.java
@@ -0,0 +1,19 @@
+package models.states;
+
+public class TargetState implements TargetStateReader{
+    private double x;
+    private double y;
+
+    public TargetState(double x, double y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public double getX() {
+        return x;
+    }
+
+    public double getY() {
+        return y;
+    }
+}
diff --git a/robots/src/models/states/TargetStateReader.java b/robots/src/models/states/TargetStateReader.java
new file mode 100644
index 000000000..d692a161b
--- /dev/null
+++ b/robots/src/models/states/TargetStateReader.java
@@ -0,0 +1,6 @@
+package models.states;
+
+public interface TargetStateReader {
+    double getX();
+    double getY();
+}
diff --git a/robots/src/utils/DrawUtils.java b/robots/src/utils/DrawUtils.java
new file mode 100644
index 000000000..a87ef3489
--- /dev/null
+++ b/robots/src/utils/DrawUtils.java
@@ -0,0 +1,15 @@
+package utils;
+
+import java.awt.*;
+
+public class DrawUtils {
+    public static void fillOval(Graphics g, int centerX, int centerY, int diam1, int diam2)
+    {
+        g.fillOval(centerX - diam1 / 2, centerY - diam2 / 2, diam1, diam2);
+    }
+
+    public static void drawOval(Graphics g, int centerX, int centerY, int diam1, int diam2)
+    {
+        g.drawOval(centerX - diam1 / 2, centerY - diam2 / 2, diam1, diam2);
+    }
+}
diff --git a/robots/src/utils/MathUtils.java b/robots/src/utils/MathUtils.java
new file mode 100644
index 000000000..bd7a6626a
--- /dev/null
+++ b/robots/src/utils/MathUtils.java
@@ -0,0 +1,45 @@
+package utils;
+
+public class MathUtils {
+    public static int round(double value)
+    {
+        return (int)(value + 0.5);
+    }
+
+    public static double asNormalizedRadians(double angle)
+    {
+        while (angle < 0)
+        {
+            angle += 2*Math.PI;
+        }
+        while (angle >= 2*Math.PI)
+        {
+            angle -= 2*Math.PI;
+        }
+        return angle;
+    }
+
+    public static double distance(double x1, double y1, double x2, double y2)
+    {
+        double diffX = x1 - x2;
+        double diffY = y1 - y2;
+        return Math.sqrt(diffX * diffX + diffY * diffY);
+    }
+
+    public static double angleTo(double fromX, double fromY, double toX, double toY)
+    {
+        double diffX = toX - fromX;
+        double diffY = toY - fromY;
+
+        return asNormalizedRadians(Math.atan2(diffY, diffX));
+    }
+    public static double applyLimits(double value, double min, double max)
+    {
+        if (value < min)
+            return min;
+        if (value > max)
+            return max;
+        return value;
+    }
+
+}