diff --git a/ProjectStormtrooper/.idea/uiDesigner.xml b/ProjectStormtrooper/.idea/uiDesigner.xml new file mode 100644 index 0000000..2b63946 --- /dev/null +++ b/ProjectStormtrooper/.idea/uiDesigner.xml @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/ProjectStormtrooper/Resources/arrowDown.jpg b/ProjectStormtrooper/Resources/arrowDown.jpg new file mode 100644 index 0000000..6d11c1f Binary files /dev/null and b/ProjectStormtrooper/Resources/arrowDown.jpg differ diff --git a/ProjectStormtrooper/Resources/arrowLeft.jpg b/ProjectStormtrooper/Resources/arrowLeft.jpg new file mode 100644 index 0000000..c49840c Binary files /dev/null and b/ProjectStormtrooper/Resources/arrowLeft.jpg differ diff --git a/ProjectStormtrooper/Resources/arrowRight.jpg b/ProjectStormtrooper/Resources/arrowRight.jpg new file mode 100644 index 0000000..9ec9071 Binary files /dev/null and b/ProjectStormtrooper/Resources/arrowRight.jpg differ diff --git a/ProjectStormtrooper/Resources/arrowUp.jpg b/ProjectStormtrooper/Resources/arrowUp.jpg new file mode 100644 index 0000000..2eaea0f Binary files /dev/null and b/ProjectStormtrooper/Resources/arrowUp.jpg differ diff --git a/ProjectStormtrooper/src/CanvasStormtrooper.java b/ProjectStormtrooper/src/CanvasStormtrooper.java new file mode 100644 index 0000000..bbd0290 --- /dev/null +++ b/ProjectStormtrooper/src/CanvasStormtrooper.java @@ -0,0 +1,18 @@ +import Drawnings.DrawingBaseStormtrooper; + +import javax.swing.*; +import java.awt.*; + +public class CanvasStormtrooper extends JComponent { + public DrawingBaseStormtrooper _drawingBaseStormtrooper; + public CanvasStormtrooper(){} + public void paintComponent(Graphics g) { + if (_drawingBaseStormtrooper == null) { + return; + } + super.paintComponents(g); + Graphics2D g2d = (Graphics2D) g; + _drawingBaseStormtrooper.DrawTransport(g2d); + super.repaint(); + } +} diff --git a/ProjectStormtrooper/src/Drawnings/DirectionType.java b/ProjectStormtrooper/src/Drawnings/DirectionType.java new file mode 100644 index 0000000..293a2f9 --- /dev/null +++ b/ProjectStormtrooper/src/Drawnings/DirectionType.java @@ -0,0 +1,9 @@ +package Drawnings; + +public enum DirectionType { + Unknow, + Up, + Down, + Left, + Right +} diff --git a/ProjectStormtrooper/src/Drawnings/DrawingBaseStormtrooper.java b/ProjectStormtrooper/src/Drawnings/DrawingBaseStormtrooper.java new file mode 100644 index 0000000..5460079 --- /dev/null +++ b/ProjectStormtrooper/src/Drawnings/DrawingBaseStormtrooper.java @@ -0,0 +1,133 @@ +package Drawnings; +import Entities.*; +import java.awt.*; + +public class DrawingBaseStormtrooper { + public EntityBaseStormtrooper EntityBaseStormtrooper; + protected Integer _pictureWidth; + protected Integer _pictureHeight; + protected Integer _startPosX; + protected Integer _startPosY; + public Integer getPosX(){return _startPosX;} + public Integer getPosY(){return _startPosY;} + private Integer _drawningStormtrooperWidth = 140; + public Integer getWidth(){return _drawningStormtrooperWidth;} + private Integer _drawningStormtrooperHeight = 135; + public Integer getHeight(){return _drawningStormtrooperHeight;} + + protected DrawingBaseStormtrooper(){ + _pictureWidth=null; + _pictureHeight=null; + _startPosX=null; + _startPosY=null; + } + public DrawingBaseStormtrooper(int speed, float weight, Color bodyColor) { + super(); + EntityBaseStormtrooper = new EntityBaseStormtrooper(speed, weight, bodyColor); + } + + public boolean SetPictureSize(int width, int height) { + // TODO проверка, что объект "влезает" в размеры поля + // если влезает, сохраняем границы и корректируем позицию объекта, если она была уже установлена + if (width < _drawningStormtrooperWidth || height < _drawningStormtrooperHeight) return false; + _pictureWidth = width; + _pictureHeight = height; + if (_startPosX != null || _startPosY != null) { + if (_startPosX + _drawningStormtrooperWidth > _pictureWidth) { + _startPosX = -_drawningStormtrooperWidth + _pictureWidth; + } else if (_startPosX < 0) { + _startPosX = 0; + } + if (_startPosY + _drawningStormtrooperHeight > _pictureHeight) { + _startPosY = -_drawningStormtrooperHeight + _pictureHeight; + } else if (_startPosY < 0) { + _startPosY = 0; + } + } + return true; + } + + public void SetPosition(int x, int y) { + if (!(_pictureHeight != null && _pictureWidth != null)) return; + // TODO если при установке объекта в эти координаты, он будет "выходить" за границы формы + // то надо изменить координаты, чтобы он оставался в этих границах + if (x + _drawningStormtrooperWidth > _pictureWidth) { + _startPosX = x - (x + _drawningStormtrooperWidth - _pictureWidth); + } else if (x < 0) { + _startPosX = 0; + } else { + _startPosX = x; + } + if (y + _drawningStormtrooperHeight > _pictureHeight) { + _startPosY = y - (y + _drawningStormtrooperHeight - _pictureHeight); + } else if (y < 0) { + _startPosY = 0; + } else { + _startPosY = y; + } + } + + public boolean MoveTransport(DirectionType direction) { + if (EntityBaseStormtrooper == null || _startPosX == null || _startPosY == null) { + return false; + } + switch (direction) { + //влево + case DirectionType.Left: + if (_startPosX - EntityBaseStormtrooper.Step > 0) { + _startPosX -= (int) EntityBaseStormtrooper.Step; + } + return true; + //вверх + case DirectionType.Up: + if (_startPosY - EntityBaseStormtrooper.Step > 0) { + _startPosY -= (int) EntityBaseStormtrooper.Step; + } + return true; + // вправо + case DirectionType.Right: + //TODO прописать логику сдвига в право + if (_startPosX + _drawningStormtrooperWidth + EntityBaseStormtrooper.Step < _pictureWidth) { + _startPosX += (int) EntityBaseStormtrooper.Step; + } + return true; + //вниз + case DirectionType.Down: + //TODO прописать логику сдвига в вниз + if (_startPosY + _drawningStormtrooperHeight + EntityBaseStormtrooper.Step < _pictureHeight) { + _startPosY += (int) EntityBaseStormtrooper.Step; + } + return true; + default: + return false; + } + } + public void DrawTransport(Graphics g) { + if (EntityBaseStormtrooper == null || _startPosX == null || _startPosY == null) { + return; + } + g.setColor(Color.black); + //Тело бомбардировщика + g.drawRect(_startPosX + 20, _startPosY + 60, 120, 20); + //Задние крылья бомбардировщика + g.drawLine(_startPosX + 140, _startPosY + 30, _startPosX + 140, _startPosY + 110); + g.drawLine(_startPosX + 120, _startPosY + 90, _startPosX + 120, _startPosY + 80); + g.drawLine(_startPosX + 140, _startPosY + 110, _startPosX + 120, _startPosY + 90); + g.drawLine(_startPosX + 140, _startPosY + 30, _startPosX + 120, _startPosY + 50); + g.drawLine(_startPosX + 120, _startPosY + 50, _startPosX + 120, _startPosY + 60); + //Крылья бомбардировщика + g.drawLine(_startPosX + 50, _startPosY, _startPosX + 50, _startPosY + 60); + g.drawLine(_startPosX + 50, _startPosY + 80, _startPosX + 50, _startPosY + 135); + g.drawLine(_startPosX + 50, _startPosY + 135, _startPosX + 60, _startPosY + 135); + g.drawLine(_startPosX + 60, _startPosY + 135, _startPosX + 65, _startPosY + 80); + g.drawLine(_startPosX + 50, _startPosY, _startPosX + 60, _startPosY); + g.drawLine(_startPosX + 60, _startPosY, _startPosX + 65, _startPosY + 60); + ///Нос бомбардировщика + g.setColor(EntityBaseStormtrooper.getBodyColor()); + Point[] Nose = new Point[3]; + int[] arrX = {_startPosX + 20, _startPosX, _startPosX + 20}; + int[] arrY = {_startPosY + 80, _startPosY + 70, _startPosY + 60}; + Polygon poly = new Polygon(arrX, arrY, 3); + g.fillPolygon(poly); + } +} diff --git a/ProjectStormtrooper/src/Drawnings/DrawingStormtrooper.java b/ProjectStormtrooper/src/Drawnings/DrawingStormtrooper.java new file mode 100644 index 0000000..4ea2061 --- /dev/null +++ b/ProjectStormtrooper/src/Drawnings/DrawingStormtrooper.java @@ -0,0 +1,63 @@ +package Drawnings; +import Drawnings.Engines.DrawingEngines; +import Drawnings.Engines.DrawingOvalEngines; +import Drawnings.Engines.DrawingTriangleEngines; +import Drawnings.Engines.IDrawingEngines; +import Entities.*; +import java.awt.*; + +public class DrawingStormtrooper extends DrawingBaseStormtrooper{ + public IDrawingEngines drawingEngines =null; + public DrawingStormtrooper(int speed, float weight, Color bodyColor, Color additionalColor,boolean rockets, boolean bombs, boolean engines, int typeOfEngines) { + EntityBaseStormtrooper = new EntityStormtrooper(speed, weight, bodyColor, additionalColor, rockets, bombs, engines); + if(engines){ + switch(typeOfEngines){ + case 1: + drawingEngines = new DrawingEngines(); + drawingEngines.setAmountOfEngines((int)((Math.random()*3)+1)*2); + break; + case 2: + drawingEngines = new DrawingTriangleEngines(); + drawingEngines.setAmountOfEngines((int)((Math.random()*3)+1)*2); + break; + case 3: + drawingEngines = new DrawingOvalEngines(); + drawingEngines.setAmountOfEngines((int)((Math.random()*3)+1)*2); + break; + } + + } + _startPosX=null; + _startPosY=null; + _pictureWidth = null; + _pictureHeight = null; + } + + @Override + public void DrawTransport(Graphics g) + { + if (EntityBaseStormtrooper == null ||!(EntityBaseStormtrooper instanceof EntityStormtrooper entityStormtrooper) || _startPosX==null || _startPosY==null) + { + return; + } + super.DrawTransport(g); + //Ракеты бомбардировщика + if (entityStormtrooper.getRockets()) + { + g.setColor(entityStormtrooper.getAdditionalColor()); + g.setColor(entityStormtrooper.getAdditionalColor()); + g.fillRect( _startPosX + 35, _startPosY + 20, 15, 5); + g.fillRect( _startPosX + 35, _startPosY + 110, 15, 5); + } + //Бомбы бомбардировщика + if (entityStormtrooper.getBombs()) + { + g.setColor(entityStormtrooper.getAdditionalColor()); + g.fillRect(_startPosX + 40, _startPosY + 40, 10, 10); + g.fillRect(_startPosX + 40, _startPosY + 90, 10, 10); + } + if(entityStormtrooper.getEngines() && drawingEngines!=null){ + drawingEngines.SwitchDrawEngines(g, _startPosX, _startPosY, EntityBaseStormtrooper.getBodyColor()); + } + } +} diff --git a/ProjectStormtrooper/src/Drawnings/Engines/DrawingEngines.java b/ProjectStormtrooper/src/Drawnings/Engines/DrawingEngines.java new file mode 100644 index 0000000..04d3c91 --- /dev/null +++ b/ProjectStormtrooper/src/Drawnings/Engines/DrawingEngines.java @@ -0,0 +1,52 @@ +package Drawnings.Engines; +import java.awt.*; + +public class DrawingEngines implements IDrawingEngines { + private NumberOfEngines numberOfEngines; + @Override + public NumberOfEngines getNumberOfEngines() { + return numberOfEngines; + } + @Override + public void setAmountOfEngines(int amount){ + if(NumberOfEngines.contains(amount)) { + numberOfEngines = NumberOfEngines.getNumber(amount); + } + } + @Override + public void DrawEngines(Graphics g, int x, int y, Color bodyColor) { + g.setColor(bodyColor); + g.fillRect(x, y, 10, 10); + } + @Override + public void drawTwoEngines(Graphics g, int x, int y, Color bodyColor){ + DrawEngines(g,x + 65, y + 50, bodyColor); + DrawEngines(g,x + 65, y + 81,bodyColor); + } + @Override + public void drawFourEngines(Graphics g, int x, int y, Color bodyColor){ + DrawEngines(g,x + 62, y + 10,bodyColor); + DrawEngines(g,x + 64, y + 101,bodyColor); + DrawEngines(g,x + 64, y + 30,bodyColor); + DrawEngines(g,x + 62, y + 121,bodyColor); + } + @Override + public void drawSixEngines(Graphics g, int x, int y, Color bodyColor){ + drawFourEngines(g,x,y,bodyColor); + drawTwoEngines(g,x,y,bodyColor); + } + @Override + public void SwitchDrawEngines(Graphics g, int x, int y, Color bodyColor){ + switch(getNumberOfEngines()){ + case NumberOfEngines.TWO: + drawTwoEngines(g,x,y,bodyColor); + break; + case NumberOfEngines.FOUR: + drawFourEngines(g,x,y,bodyColor); + break; + case NumberOfEngines.SIX: + drawSixEngines(g,x,y,bodyColor); + break; + } + } +} diff --git a/ProjectStormtrooper/src/Drawnings/Engines/DrawingOvalEngines.java b/ProjectStormtrooper/src/Drawnings/Engines/DrawingOvalEngines.java new file mode 100644 index 0000000..012fc2a --- /dev/null +++ b/ProjectStormtrooper/src/Drawnings/Engines/DrawingOvalEngines.java @@ -0,0 +1,53 @@ +package Drawnings.Engines; + +import java.awt.*; + +public class DrawingOvalEngines implements IDrawingEngines { + private NumberOfEngines numberOfEngines; + @Override + public NumberOfEngines getNumberOfEngines() { + return numberOfEngines; + } + @Override + public void setAmountOfEngines(int amount){ + if(NumberOfEngines.contains(amount)) { + numberOfEngines = NumberOfEngines.getNumber(amount); + } + } + @Override + public void DrawEngines(Graphics g, int x, int y, Color bodyColor) { + g.setColor(bodyColor); + g.fillOval(x, y, 10, 10); + } + @Override + public void drawTwoEngines(Graphics g, int x, int y, Color bodyColor){ + DrawEngines(g,x + 65, y + 50, bodyColor); + DrawEngines(g,x + 65, y + 81,bodyColor); + } + public @Override + void drawFourEngines(Graphics g, int x, int y, Color bodyColor){ + DrawEngines(g,x + 62, y + 10,bodyColor); + DrawEngines(g,x + 64, y + 101,bodyColor); + DrawEngines(g,x + 64, y + 30,bodyColor); + DrawEngines(g,x + 62, y + 121,bodyColor); + } + @Override + public void drawSixEngines(Graphics g, int x, int y, Color bodyColor){ + drawFourEngines(g,x,y,bodyColor); + drawTwoEngines(g,x,y,bodyColor); + } + @Override + public void SwitchDrawEngines(Graphics g, int x, int y, Color bodyColor){ + switch(getNumberOfEngines()){ + case NumberOfEngines.TWO: + drawTwoEngines(g,x,y,bodyColor); + break; + case NumberOfEngines.FOUR: + drawFourEngines(g,x,y,bodyColor); + break; + case NumberOfEngines.SIX: + drawSixEngines(g,x,y,bodyColor); + break; + } + } +} diff --git a/ProjectStormtrooper/src/Drawnings/Engines/DrawingTriangleEngines.java b/ProjectStormtrooper/src/Drawnings/Engines/DrawingTriangleEngines.java new file mode 100644 index 0000000..510be8e --- /dev/null +++ b/ProjectStormtrooper/src/Drawnings/Engines/DrawingTriangleEngines.java @@ -0,0 +1,57 @@ +package Drawnings.Engines; + +import java.awt.*; + +public class DrawingTriangleEngines implements IDrawingEngines { + private NumberOfEngines numberOfEngines; + @Override + public NumberOfEngines getNumberOfEngines() { + return numberOfEngines; + } + @Override + public void setAmountOfEngines(int amount){ + if(NumberOfEngines.contains(amount)) { + numberOfEngines = NumberOfEngines.getNumber(amount); + } + } + @Override + public void DrawEngines(Graphics g, int x, int y, Color bodyColor) { + g.setColor(bodyColor); + Point[] Nose = new Point[3]; + int[] arrX = {x,x,x+10}; + int[] arrY = {y,y+12,y+6}; + Polygon poly = new Polygon(arrX, arrY, 3); + g.fillPolygon(poly); + } + @Override + public void drawTwoEngines(Graphics g, int x, int y, Color bodyColor){ + DrawEngines(g,x + 65, y + 50, bodyColor); + DrawEngines(g,x + 65, y + 81,bodyColor); + } + public @Override + void drawFourEngines(Graphics g, int x, int y, Color bodyColor){ + DrawEngines(g,x + 62, y + 10,bodyColor); + DrawEngines(g,x + 64, y + 101,bodyColor); + DrawEngines(g,x + 64, y + 30,bodyColor); + DrawEngines(g,x + 62, y + 121,bodyColor); + } + @Override + public void drawSixEngines(Graphics g, int x, int y, Color bodyColor){ + drawFourEngines(g,x,y,bodyColor); + drawTwoEngines(g,x,y,bodyColor); + } + public void SwitchDrawEngines(Graphics g, int x, int y, Color bodyColor){ + switch(getNumberOfEngines()){ + case NumberOfEngines.TWO: + drawTwoEngines(g,x,y,bodyColor); + break; + case NumberOfEngines.FOUR: + drawFourEngines(g,x,y,bodyColor); + break; + case NumberOfEngines.SIX: + drawSixEngines(g,x,y,bodyColor); + break; + } + } +} + diff --git a/ProjectStormtrooper/src/Drawnings/Engines/IDrawingEngines.java b/ProjectStormtrooper/src/Drawnings/Engines/IDrawingEngines.java new file mode 100644 index 0000000..366fe13 --- /dev/null +++ b/ProjectStormtrooper/src/Drawnings/Engines/IDrawingEngines.java @@ -0,0 +1,17 @@ +package Drawnings.Engines; + +import java.awt.*; + +public interface IDrawingEngines { + void setAmountOfEngines(int amount); + + NumberOfEngines getNumberOfEngines(); + + void DrawEngines(Graphics g, int x, int y, Color bodyColor); + + void drawTwoEngines(Graphics g, int x, int y, Color bodyColor); + void drawFourEngines(Graphics g, int x, int y, Color bodyColor); + void drawSixEngines(Graphics g, int x, int y, Color bodyColor); + void SwitchDrawEngines(Graphics g, int startPosX, int startPosY, Color bodyColor); + +} diff --git a/ProjectStormtrooper/src/Drawnings/Engines/NumberOfEngines.java b/ProjectStormtrooper/src/Drawnings/Engines/NumberOfEngines.java new file mode 100644 index 0000000..5b9208d --- /dev/null +++ b/ProjectStormtrooper/src/Drawnings/Engines/NumberOfEngines.java @@ -0,0 +1,30 @@ +package Drawnings.Engines; + +public enum NumberOfEngines { + TWO(2), + FOUR(4), + SIX(6); + + private final int value; + NumberOfEngines(int value){ + this.value=value; + } + public static NumberOfEngines getNumber(int amount){ + NumberOfEngines [] num = NumberOfEngines.values(); + for(int i =0 ; i canvasStormtrooper._drawingBaseStormtrooper.MoveTransport(DirectionType.Up); + case "DOWN" -> canvasStormtrooper._drawingBaseStormtrooper.MoveTransport(DirectionType.Down); + case "LEFT" -> canvasStormtrooper._drawingBaseStormtrooper.MoveTransport(DirectionType.Left); + case "RIGHT" -> canvasStormtrooper._drawingBaseStormtrooper.MoveTransport(DirectionType.Right); + default -> false; + }; + if (result) { + canvasStormtrooper.repaint(); + } + } + }; + UpButton.addActionListener(actionListener); + DownButton.addActionListener(actionListener); + LeftButton.addActionListener(actionListener); + RightButton.addActionListener(actionListener); + setSize(dimension.width,dimension.height); + setLayout(null); + canvasStormtrooper.setBounds(0,0, getWidth(), getHeight()); + CreateBaseStormtrooper.setBounds(10, getHeight() - 90, 130, 40); + CreateStormtrooper.setBounds(160,getHeight()-90,130,40); + UpButton.setBounds(getWidth() - 180, getHeight() - 210, 70, 70); + DownButton.setBounds(getWidth() - 180, getHeight() - 140, 70, 70); + RightButton.setBounds(getWidth() - 110, getHeight() - 140, 70, 70); + LeftButton.setBounds(getWidth() - 250, getHeight() - 140, 70, 70); + ComboBoxStrategy.setBounds(getWidth() - 170, 10, 140, 35); + ButtonStrategy.setBounds(getWidth() - 130, 55, 100, 25); + add(CreateBaseStormtrooper); + add(CreateStormtrooper); + add(ComboBoxStrategy); + add(ButtonStrategy); + add(UpButton); + add(DownButton); + add(RightButton); + add(LeftButton); + add(canvasStormtrooper); + setVisible(true); + addComponentListener(new ComponentAdapter() { + public void componentResized(ComponentEvent e) { + Width = getWidth() -10; + Height = getHeight() - 34; + if (canvasStormtrooper._drawingBaseStormtrooper != null)canvasStormtrooper._drawingBaseStormtrooper.SetPictureSize(Width, Height); + canvasStormtrooper.setBounds(0,0, getWidth(), getHeight()); + CreateBaseStormtrooper.setBounds(10, getHeight() - 90, 130, 40); + CreateStormtrooper.setBounds(160,getHeight()-90,130,40); + UpButton.setBounds(getWidth() - 180, getHeight() - 210, 70, 70); + DownButton.setBounds(getWidth() - 180, getHeight() - 140, 70, 70); + RightButton.setBounds(getWidth() - 110, getHeight() - 140, 70, 70); + LeftButton.setBounds(getWidth() - 250, getHeight() - 140, 70, 70); + ComboBoxStrategy.setBounds(getWidth() - 170, 10, 140, 35); + ButtonStrategy.setBounds(getWidth() - 130, 55, 100, 25); + } + }); + } +} diff --git a/ProjectStormtrooper/src/Main.java b/ProjectStormtrooper/src/Main.java index 3e59c38..b4b6838 100644 --- a/ProjectStormtrooper/src/Main.java +++ b/ProjectStormtrooper/src/Main.java @@ -1,5 +1,8 @@ +import java.awt.*; + public class Main { public static void main(String[] args) { - System.out.println("Hello world!"); + FormStormtrooper form = new FormStormtrooper("Бомбардировщик", new Dimension(800,800)); + form.Init(); } } \ No newline at end of file diff --git a/ProjectStormtrooper/src/MovementStrategy/AbstractStrategy.java b/ProjectStormtrooper/src/MovementStrategy/AbstractStrategy.java new file mode 100644 index 0000000..c13ae17 --- /dev/null +++ b/ProjectStormtrooper/src/MovementStrategy/AbstractStrategy.java @@ -0,0 +1,60 @@ +package MovementStrategy; +public abstract class AbstractStrategy +{ + private IMoveableObject _moveableObject; + private StrategyStatus _state = StrategyStatus.NotInit; + public int FieldWidth; + public int FieldHeight; + public StrategyStatus GetStatus (){ return _state; } + public void SetData(IMoveableObject moveableObject, int width, int height) + { + if (moveableObject == null) + { + _state = StrategyStatus.NotInit; + return; + } + _state = StrategyStatus.InProgress; + _moveableObject = moveableObject; + FieldWidth = width; + FieldHeight = height; + } + + public void MakeStep() + { + if (_state != StrategyStatus.InProgress) + { + return; + } + if (IsTargetDestinaion()) + { + _state = StrategyStatus.Finish; + return; + } + MoveToTarget(); + } + + protected boolean MoveLeft() {return MoveTo(MovementDirection.Left);} + protected boolean MoveRight() {return MoveTo(MovementDirection.Right);} + protected boolean MoveUp(){return MoveTo(MovementDirection.Up);} + protected boolean MoveDown(){return MoveTo(MovementDirection.Down);} + + protected ObjectParameters GetObjectParameters (){return _moveableObject.GetObjectPosition();} + protected int GetStep(){ + if (_state != StrategyStatus.InProgress) + { + return -1; + } + return _moveableObject.getStep(); + } + protected abstract void MoveToTarget(); + protected abstract boolean IsTargetDestinaion(); + private boolean MoveTo(MovementDirection movementDirection) { + if (_state != StrategyStatus.InProgress) { + return false; + } + if (_moveableObject.TryMoveObject(movementDirection)) { + return _moveableObject.TryMoveObject(movementDirection); + } + return false; + } +} \ No newline at end of file diff --git a/ProjectStormtrooper/src/MovementStrategy/IMoveableObject.java b/ProjectStormtrooper/src/MovementStrategy/IMoveableObject.java new file mode 100644 index 0000000..ae0259a --- /dev/null +++ b/ProjectStormtrooper/src/MovementStrategy/IMoveableObject.java @@ -0,0 +1,7 @@ +package MovementStrategy; +public interface IMoveableObject +{ + ObjectParameters GetObjectPosition (); + int getStep(); + boolean TryMoveObject(MovementDirection direction); +} \ No newline at end of file diff --git a/ProjectStormtrooper/src/MovementStrategy/MoveToBorder.java b/ProjectStormtrooper/src/MovementStrategy/MoveToBorder.java new file mode 100644 index 0000000..bc84419 --- /dev/null +++ b/ProjectStormtrooper/src/MovementStrategy/MoveToBorder.java @@ -0,0 +1,29 @@ +package MovementStrategy; +public class MoveToBorder extends AbstractStrategy +{ + @Override + protected boolean IsTargetDestinaion() + { + ObjectParameters objParams = GetObjectParameters(); + if (objParams == null) + { + return false; + } + return objParams.LeftBorder - GetStep() <= 0 && + objParams.RightBorder + GetStep() >= FieldWidth && + objParams.TopBorder - GetStep() <= 0 + && objParams.ObjectMiddleVertical + GetStep() >= FieldHeight; + } + @Override + protected void MoveToTarget() + { + ObjectParameters objParams = GetObjectParameters(); + if (objParams == null) { + return; + } + int x = objParams.RightBorder; + if (x + GetStep() < FieldWidth)MoveRight(); + int y = objParams.DownBorder; + if (y + GetStep() < FieldHeight) MoveDown(); + } +} diff --git a/ProjectStormtrooper/src/MovementStrategy/MoveToCenter.java b/ProjectStormtrooper/src/MovementStrategy/MoveToCenter.java new file mode 100644 index 0000000..a3e72bb --- /dev/null +++ b/ProjectStormtrooper/src/MovementStrategy/MoveToCenter.java @@ -0,0 +1,51 @@ +package MovementStrategy; +public class MoveToCenter extends AbstractStrategy +{ + @Override + protected boolean IsTargetDestinaion() + { + ObjectParameters objParams = GetObjectParameters(); + if (objParams == null) + { + return false; + } + return objParams.ObjectMiddleHorizontal - GetStep() <= FieldWidth / 2 && + objParams.ObjectMiddleHorizontal + GetStep() >= FieldWidth / 2 && + objParams.ObjectMiddleVertical - GetStep() <= FieldHeight / 2 && + objParams.ObjectMiddleVertical + GetStep() >= FieldHeight /2; + } + + @Override + protected void MoveToTarget() { + + ObjectParameters objParams = GetObjectParameters(); + if (objParams == null) + { + return; + } + int diffX = objParams.ObjectMiddleHorizontal - FieldWidth / 2; + if (Math.abs(diffX) > GetStep()) + { + if (diffX > 0) + { + MoveLeft(); + } + else + { + MoveRight(); + } + } + int diffY = objParams.ObjectMiddleVertical - FieldHeight / 2; + if (Math.abs(diffY) > GetStep()) + { + if (diffY > 0) + { + MoveUp(); + } + else + { + MoveDown(); + } + } + } +} \ No newline at end of file diff --git a/ProjectStormtrooper/src/MovementStrategy/MoveableStormtrooper.java b/ProjectStormtrooper/src/MovementStrategy/MoveableStormtrooper.java new file mode 100644 index 0000000..63210a4 --- /dev/null +++ b/ProjectStormtrooper/src/MovementStrategy/MoveableStormtrooper.java @@ -0,0 +1,46 @@ +package MovementStrategy; +import Drawnings.*; +import Entities.EntityBaseStormtrooper; +public class MoveableStormtrooper implements IMoveableObject +{ + private DrawingBaseStormtrooper _stormtrooper ; + + public MoveableStormtrooper(DrawingBaseStormtrooper stormtrooper) + { + _stormtrooper = stormtrooper; + } + @Override + public ObjectParameters GetObjectPosition() { + if (_stormtrooper == null || _stormtrooper.EntityBaseStormtrooper == null || _stormtrooper.getPosX()==null || _stormtrooper.getPosY()==null) { + return null; + } + return new ObjectParameters(_stormtrooper.getPosX(), _stormtrooper.getPosY(), _stormtrooper.getWidth(), _stormtrooper.getHeight()); + } + @Override + public int getStep(){ return (int)(_stormtrooper.EntityBaseStormtrooper.Step);} + @Override + public boolean TryMoveObject(MovementDirection direction) + { + if (_stormtrooper == null || _stormtrooper.EntityBaseStormtrooper == null) + { + return false; + } + return _stormtrooper.MoveTransport(GetDirectionType(direction)); + } + private static DirectionType GetDirectionType(MovementDirection direction) { + switch (direction) { + case Left: + return DirectionType.Left; + case Right: + return DirectionType.Right; + case Up: + return DirectionType.Up; + case Down: + return DirectionType.Down; + default: + return DirectionType.Unknow; + } + } +} + + diff --git a/ProjectStormtrooper/src/MovementStrategy/MovementDirection.java b/ProjectStormtrooper/src/MovementStrategy/MovementDirection.java new file mode 100644 index 0000000..2aa1079 --- /dev/null +++ b/ProjectStormtrooper/src/MovementStrategy/MovementDirection.java @@ -0,0 +1,12 @@ +package MovementStrategy; +public enum MovementDirection { + ///Вверх + Up, + ///Вниз + Down, + ///Влево + Left, + ///Вправо + Right + +} diff --git a/ProjectStormtrooper/src/MovementStrategy/ObjectParameters.java b/ProjectStormtrooper/src/MovementStrategy/ObjectParameters.java new file mode 100644 index 0000000..e23f255 --- /dev/null +++ b/ProjectStormtrooper/src/MovementStrategy/ObjectParameters.java @@ -0,0 +1,24 @@ +package MovementStrategy; +public class ObjectParameters +{ + private int _x; + private int _y; + public int _width; + private int _height; + public int TopBorder =_y; + public int LeftBorder = _x; + public int RightBorder = _x + _width; + public int DownBorder = _y + _height; + public int ObjectMiddleHorizontal; + public int ObjectMiddleVertical; + public ObjectParameters(int x, int y, int width, int height) + { + _x = x; + _y = y; + _width = width; + _height = height; + ObjectMiddleHorizontal = _x + _width/ 2; + ObjectMiddleVertical = _y + _height/ 2; + + } +} \ No newline at end of file diff --git a/ProjectStormtrooper/src/MovementStrategy/StrategyStatus.java b/ProjectStormtrooper/src/MovementStrategy/StrategyStatus.java new file mode 100644 index 0000000..27691d3 --- /dev/null +++ b/ProjectStormtrooper/src/MovementStrategy/StrategyStatus.java @@ -0,0 +1,7 @@ +package MovementStrategy; +public enum StrategyStatus +{ + NotInit, + InProgress, + Finish +}