diff --git a/src/AbstractStrategy.java b/src/AbstractStrategy.java new file mode 100644 index 0000000..451bebb --- /dev/null +++ b/src/AbstractStrategy.java @@ -0,0 +1,77 @@ +public abstract class AbstractStrategy { + private IMoveableObject moveableObject; + private Status state = Status.NotInit; + private int fieldWidth; + protected int getFieldWidth() { + return fieldWidth; + } + private int fieldHeight; + protected int getFieldHeight() { + return fieldHeight; + } + public Status getStatus() { + return state; + } + public void setData(IMoveableObject moveableObject, int width, int height) { + if (moveableObject == null) { + state = Status.NotInit; + return; + } + state = Status.InProgress; + this.moveableObject = moveableObject; + fieldWidth = width; + fieldHeight = height; + } + public void makeStep() { + if (state != Status.InProgress) { + return; + } + if (isTargetDestination()) { + state = Status.Finish; + return; + } + moveToTarget(); + } + protected boolean moveLeft() { + return moveTo(DirectionBulldozer.Left); + } + protected boolean moveRight() { + return moveTo(DirectionBulldozer.Right); + } + protected boolean moveUp() { + return moveTo(DirectionBulldozer.Up); + } + protected boolean moveDown() { + return moveTo(DirectionBulldozer.Down); + } + protected ObjectParameters getObjectParameters() { + if (moveableObject == null) { + return null; + } + return moveableObject.getObjectsPosition(); + } + protected Integer getStep() { + if (state != Status.InProgress) { + return null; + } + if (moveableObject == null) { + return null; + } + return moveableObject.getStep(); + } + protected abstract void moveToTarget(); + protected abstract boolean isTargetDestination(); + private boolean moveTo(DirectionBulldozer directionBulldozer) { + if (state != Status.InProgress) { + return false; + } + if (moveableObject == null) { + return false; + } + if (moveableObject.checkCanMove(directionBulldozer)) { + moveableObject.moveObject(directionBulldozer); + return true; + } + return false; + } +} diff --git a/src/DirectionBulldozer.java b/src/DirectionBulldozer.java index 7798f66..4414869 100644 --- a/src/DirectionBulldozer.java +++ b/src/DirectionBulldozer.java @@ -3,5 +3,4 @@ public enum DirectionBulldozer { Down, Left, Right - } diff --git a/src/DrawningBulldozer.java b/src/DrawningBulldozer.java index f297a26..56e5f30 100644 --- a/src/DrawningBulldozer.java +++ b/src/DrawningBulldozer.java @@ -1,28 +1,65 @@ import java.awt.*; +import java.util.Random; public class DrawningBulldozer { private EntityBulldozer entityBulldozer; public EntityBulldozer getEntityBulldozer() { return entityBulldozer; } - private DrawningWheels drawningWheels; + protected void setEntityBulldozer(EntityBulldozer entityBulldozer) { + this.entityBulldozer = entityBulldozer; + } + private IDrawningWheels drawningWheels; private int _pictureWidth; private int _pictureHeight; - private int _startPosX; - private int _startPosY; - private int _bulldozerWidth = 160; - private int _bulldozerHeight = 80; - public boolean Init(int speed, double weight, Color bulldozerColor, Color cabinColor, Color covshColor, boolean hasMoldboardfront, boolean hasRipper, int width, int height, int wheelNumber) + protected int _startPosX; + protected int _startPosY; + protected int _bulldozerWidth = 160; + protected int _bulldozerHeight = 90; + public int getPosX() { + return _startPosX; + } + public int getPosY() { + return _startPosY; + } + public int getWidth() { + return _bulldozerWidth; + } + public int getHeight() { + return _bulldozerHeight; + } + public DrawningBulldozer(int speed, double weight, Color bodyColor, boolean covsh, boolean rearbucket, Color covshColor, Color rearbucketColor, int width, int height, int wheelNumber) { if (height < _bulldozerHeight || width < _bulldozerWidth) { - return false; + return; } _pictureWidth = width; _pictureHeight = height; - entityBulldozer = new EntityBulldozer(); - entityBulldozer.Init(speed, weight, bulldozerColor, cabinColor, covshColor, hasMoldboardfront, hasRipper); - drawningWheels = new DrawningWheels(); + entityBulldozer = new EntityBulldozer(speed, weight, bodyColor); + Random random = new Random(); + drawningWheels = switch (random.nextInt(0, 3)) { + case 0 -> new DrawningWheels(); + case 1 -> new DrawningWheelsStar(); + case 2 -> new DrawningWheelsCircles(); + default -> new DrawningWheels(); + }; + drawningWheels.setWheelNumber(wheelNumber); + } + protected DrawningBulldozer(int speed, double weight, Color bodyColor, int width, int height, int bulldozerWidth, int bulldozerHeight, int wheelNumber) + { + if (width < bulldozerWidth || height < bulldozerHeight) return; + _pictureWidth = width; + _pictureHeight = height; + _bulldozerWidth = bulldozerWidth; + _bulldozerHeight = bulldozerHeight; + entityBulldozer = new EntityBulldozer(speed, weight, bodyColor); + Random random = new Random(); + drawningWheels = switch (random.nextInt(0, 3)) { + case 0 -> new DrawningWheels(); + case 1 -> new DrawningWheelsStar(); + case 2 -> new DrawningWheelsCircles(); + default -> new DrawningWheels(); + }; drawningWheels.setWheelNumber(wheelNumber); - return true; } public void SetPosition(int x, int y) { @@ -31,8 +68,21 @@ public class DrawningBulldozer { _startPosX = x; _startPosY = y; } + public boolean CanMove(DirectionBulldozer direction) { + if (entityBulldozer == null) { + return false; + } + return switch (direction) { + case Left -> _startPosX - entityBulldozer.getStep() > 0; + case Up -> _startPosY - entityBulldozer.getStep() > 0; + case Right -> _startPosX + _bulldozerWidth + entityBulldozer.getStep() < _pictureWidth; + case Down -> _startPosY + _bulldozerHeight + entityBulldozer.getStep() < _pictureHeight; + default -> false; + }; + } public void MoveTransport(DirectionBulldozer direction) { - if (entityBulldozer == null) return; + if (!CanMove(direction) || entityBulldozer == null) return; + switch (direction) { //влево case Left: @@ -70,7 +120,7 @@ public class DrawningBulldozer { return; } g2D.setStroke(new BasicStroke(3)); - g2D.setPaint(entityBulldozer.getBulldozerColor()); + g2D.setPaint(entityBulldozer.getBodyColor()); g2D.fillRect(_startPosX + 25, _startPosY + 20, 110, 30); g2D.fillRect(_startPosX+60, _startPosY, 10, 30); int x = _startPosX + 30; // начальная позиция X @@ -87,24 +137,9 @@ public class DrawningBulldozer { g2D.drawLine(x + width - radius - 5, y + height + 60, x + radius - 5, y + height + 60); // нижняя горизонталь g2D.drawArc(x - 5, y + height - radius * 2 + 60, radius * 2, radius * 2, 90, 90); // нижний левый угол // Кабина - g2D.setPaint(entityBulldozer.getCabinColor()); + g2D.setPaint(entityBulldozer.getBodyColor()); g2D.fillRect(_startPosX + 105, _startPosY, 30, 20); //Колёса drawningWheels.drawWheels(g2D, Color.BLACK, _startPosX, _startPosY); - if (entityBulldozer.getHasMoldboardfront()) - { - g2D.setPaint(entityBulldozer.getCabinColor()); - int[] xPoints = {_startPosX + 25, _startPosX + 25, _startPosX}; - int[] yPoints = {_startPosY + 30, _startPosY + 80, _startPosY + 80}; - Polygon triangle = new Polygon(xPoints, yPoints, 3); - g2D.drawPolygon(triangle); - } - if (entityBulldozer.getHasRipper()) - { - int[] xPoints2 = {_startPosX + 130, _startPosX + 160, _startPosX + 160}; - int[] yPoints2 = {_startPosY + 50, _startPosY + 50, _startPosY + 80}; - Polygon triangle2 = new Polygon(xPoints2, yPoints2, 3); - g2D.drawPolygon(triangle2); - } } } diff --git a/src/DrawningFastBulldozer.java b/src/DrawningFastBulldozer.java new file mode 100644 index 0000000..7f791e1 --- /dev/null +++ b/src/DrawningFastBulldozer.java @@ -0,0 +1,34 @@ +import java.awt.*; +public class DrawningFastBulldozer extends DrawningBulldozer { + public DrawningFastBulldozer(int speed, double weight, Color bodyColor, boolean covsh, boolean rearbucket, Color covshColor, Color rearbucketColor, int width, int height, int wheelNumber) + { + super(speed, weight, bodyColor, width, height, 160, 90, wheelNumber); + if (getEntityBulldozer() != null) + { + setEntityBulldozer(new EntityFastBulldozer(speed, weight, bodyColor, covsh, rearbucket, covshColor, rearbucketColor)); + } + } + @Override + public void DrawTransport(Graphics2D g2D) { + if (!(getEntityBulldozer() instanceof EntityFastBulldozer fastBulldozer)) { + return; + } + super.DrawTransport(g2D); + if (fastBulldozer.getCovsh()) + { + g2D.setPaint(fastBulldozer.getCovshColor()); + int[] xPoints = {_startPosX + 25, _startPosX + 25, _startPosX}; + int[] yPoints = {_startPosY + 30, _startPosY + 80, _startPosY + 80}; + Polygon triangle = new Polygon(xPoints, yPoints, 3); + g2D.drawPolygon(triangle); + } + if (fastBulldozer.getRearbucket() && fastBulldozer.getCovsh()) + { + g2D.setPaint(fastBulldozer.getRearbucketColor()); + int[] xPoints2 = {_startPosX + 130, _startPosX + 160, _startPosX + 160}; + int[] yPoints2 = {_startPosY + 50, _startPosY + 50, _startPosY + 80}; + Polygon triangle2 = new Polygon(xPoints2, yPoints2, 3); + g2D.drawPolygon(triangle2); + } + } +} diff --git a/src/DrawningObjectBulldozer.java b/src/DrawningObjectBulldozer.java new file mode 100644 index 0000000..0bd69da --- /dev/null +++ b/src/DrawningObjectBulldozer.java @@ -0,0 +1,31 @@ +public class DrawningObjectBulldozer implements IMoveableObject{ + private DrawningBulldozer drawningBulldozer = null; + public DrawningObjectBulldozer(DrawningBulldozer drawningBulldozer) { + this.drawningBulldozer = drawningBulldozer; + } + @Override + public ObjectParameters getObjectsPosition() { + if (drawningBulldozer == null || drawningBulldozer.getEntityBulldozer() == null) { + return null; + } + return new ObjectParameters(drawningBulldozer.getPosX(), drawningBulldozer.getPosY(), + drawningBulldozer.getWidth(), drawningBulldozer.getHeight()); + } + @Override + public int getStep() { + if (drawningBulldozer == null) + return 0; + return (int) ((drawningBulldozer.getEntityBulldozer() != null) ? drawningBulldozer.getEntityBulldozer().getStep() : 0); + } + @Override + public boolean checkCanMove(DirectionBulldozer direction) { + if (drawningBulldozer == null) + return false; + return drawningBulldozer.CanMove(direction); + } + @Override + public void moveObject(DirectionBulldozer direction) { + if (drawningBulldozer != null) + drawningBulldozer.MoveTransport(direction); + } +} diff --git a/src/DrawningWheels.java b/src/DrawningWheels.java index e8fc5b9..5d8151c 100644 --- a/src/DrawningWheels.java +++ b/src/DrawningWheels.java @@ -1,6 +1,11 @@ import java.awt.*; -public class DrawningWheels { +public class DrawningWheels implements IDrawningWheels { private WheelNumber wheelNumber; + @Override + public WheelNumber getWheelNumber() { + return wheelNumber; + } + @Override public void setWheelNumber(int number) { switch (number) { case 1: @@ -15,16 +20,17 @@ public class DrawningWheels { default: wheelNumber = WheelNumber.Four; } } - public void drawWheels(Graphics2D g2D, Color color, int _startPosX, int _startPosY) { + @Override + public void drawWheels(Graphics2D g2d, Color color, int startPosX, int startPosY) { switch (wheelNumber) { case Four: - drawFourWheels(g2D, color, _startPosX, _startPosY); + drawFourWheels(g2d, color, startPosX, startPosY); break; case Five: - drawFiveWheels(g2D, color, _startPosX, _startPosY); + drawFiveWheels(g2d, color, startPosX, startPosY); break; case Six: - drawSixWheels(g2D, color, _startPosX, _startPosY); + drawSixWheels(g2d, color, startPosX, startPosY); break; } } @@ -70,4 +76,4 @@ public class DrawningWheels { g2D.drawOval(_startPosX + 115, _startPosY + 54, wheelRadius, wheelRadius); g2D.fillOval(_startPosX + 115, _startPosY + 54, wheelRadius, wheelRadius); } -} \ No newline at end of file +} diff --git a/src/DrawningWheelsCircles.java b/src/DrawningWheelsCircles.java new file mode 100644 index 0000000..5e26678 --- /dev/null +++ b/src/DrawningWheelsCircles.java @@ -0,0 +1,98 @@ +import java.awt.*; +public class DrawningWheelsCircles implements IDrawningWheels { + private WheelNumber wheelNumber; + @Override + public WheelNumber getWheelNumber() { + return wheelNumber; + } + @Override + public void setWheelNumber(int number) { + switch (number) { + case 1: + wheelNumber = WheelNumber.Four; + break; + case 2: + wheelNumber = WheelNumber.Five; + break; + case 3: + wheelNumber = WheelNumber.Six; + break; + default: wheelNumber = WheelNumber.Four; + } + } + @Override + public void drawWheels(Graphics2D g2d, Color color, int startPosX, int startPosY) { + switch (wheelNumber) { + case Four: + drawFourWheels(g2d, color, startPosX, startPosY); + break; + case Five: + drawFiveWheels(g2d, color, startPosX, startPosY); + break; + case Six: + drawSixWheels(g2d, color, startPosX, startPosY); + break; + } + } + private void drawFourWheels(Graphics2D g2D, Color color, int _startPosX, int _startPosY) { + g2D.setColor(color); + int wheelRadius = 10; + g2D.drawOval(_startPosX + 30, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 30, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 30, _startPosY + 60); + g2D.drawOval(_startPosX + 56, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 56, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 56, _startPosY + 60); + g2D.drawOval(_startPosX + 84, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 84, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 84, _startPosY + 60); + g2D.drawOval(_startPosX + 110, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 110, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 110, _startPosY + 60); + } + private void drawFiveWheels(Graphics2D g2D, Color color, int _startPosX, int _startPosY) { + g2D.setColor(color); + int wheelRadius = 10; + g2D.drawOval(_startPosX + 34, _startPosY + 55, wheelRadius, wheelRadius); + g2D.fillOval(_startPosX + 34, _startPosY + 55, wheelRadius, wheelRadius); + g2D.drawOval(_startPosX + 45, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 45, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 45, _startPosY + 65); + g2D.drawOval(_startPosX + 69, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 69, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 69, _startPosY + 65); + g2D.drawOval(_startPosX + 94, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 94, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 94, _startPosY + 65); + g2D.drawOval(_startPosX + 115, _startPosY + 55, wheelRadius, wheelRadius); + g2D.fillOval(_startPosX + 115, _startPosY + 55, wheelRadius, wheelRadius); + } + private void drawSixWheels(Graphics2D g2D, Color color, int _startPosX, int _startPosY) { + g2D.setColor(color); + int wheelRadius = 10; + g2D.drawOval(_startPosX + 34, _startPosY + 54, wheelRadius, wheelRadius); + g2D.fillOval(_startPosX + 34, _startPosY + 54, wheelRadius, wheelRadius); + g2D.drawOval(_startPosX + 35, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 35, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 35, _startPosY + 65); + g2D.drawOval(_startPosX + 58, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 58, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 58, _startPosY + 65); + g2D.drawOval(_startPosX + 82, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 82, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 82, _startPosY + 65); + g2D.drawOval(_startPosX + 105, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 105, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 105, _startPosY + 65); + g2D.drawOval(_startPosX + 115, _startPosY + 54, wheelRadius, wheelRadius); + g2D.fillOval(_startPosX + 115, _startPosY + 54, wheelRadius, wheelRadius); + } + private void drawPattern(Graphics2D g2D, int x, int y){ + g2D.setColor(Color.WHITE); + g2D.setStroke(new BasicStroke(1)); + g2D.drawOval(x + 6, y + 6, 8, 8); + g2D.setStroke(new BasicStroke(1)); + g2D.drawOval(x + 3, y + 3, 14, 14); + g2D.setColor(Color.BLACK); + } +} diff --git a/src/DrawningWheelsStar.java b/src/DrawningWheelsStar.java new file mode 100644 index 0000000..12bc286 --- /dev/null +++ b/src/DrawningWheelsStar.java @@ -0,0 +1,97 @@ +import java.awt.*; +public class DrawningWheelsStar implements IDrawningWheels { + private WheelNumber wheelNumber; + @Override + public WheelNumber getWheelNumber() { + return wheelNumber; + } + @Override + public void setWheelNumber(int number) { + switch (number) { + case 1: + wheelNumber = WheelNumber.Four; + break; + case 2: + wheelNumber = WheelNumber.Five; + break; + case 3: + wheelNumber = WheelNumber.Six; + break; + default: wheelNumber = WheelNumber.Four; + } + } + @Override + public void drawWheels(Graphics2D g2d, Color color, int startPosX, int startPosY) { + switch (wheelNumber) { + case Four: + drawFourWheels(g2d, color, startPosX, startPosY); + break; + case Five: + drawFiveWheels(g2d, color, startPosX, startPosY); + break; + case Six: + drawSixWheels(g2d, color, startPosX, startPosY); + break; + } + } + private void drawFourWheels(Graphics2D g2D, Color color, int _startPosX, int _startPosY) { + g2D.setColor(color); + int wheelRadius = 10; + g2D.drawOval(_startPosX + 30, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 30, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 30, _startPosY + 60); + g2D.drawOval(_startPosX + 56, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 56, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 56, _startPosY + 60); + g2D.drawOval(_startPosX + 84, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 84, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 84, _startPosY + 60); + g2D.drawOval(_startPosX + 110, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 110, _startPosY + 60, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 110, _startPosY + 60); + } + private void drawFiveWheels(Graphics2D g2D, Color color, int _startPosX, int _startPosY) { + g2D.setColor(color); + int wheelRadius = 10; + g2D.drawOval(_startPosX + 34, _startPosY + 55, wheelRadius, wheelRadius); + g2D.fillOval(_startPosX + 34, _startPosY + 55, wheelRadius, wheelRadius); + g2D.drawOval(_startPosX + 45, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 45, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 45, _startPosY + 65); + g2D.drawOval(_startPosX + 69, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 69, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 69, _startPosY + 65); + g2D.drawOval(_startPosX + 94, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 94, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 94, _startPosY + 65); + g2D.drawOval(_startPosX + 115, _startPosY + 55, wheelRadius, wheelRadius); + g2D.fillOval(_startPosX + 115, _startPosY + 55, wheelRadius, wheelRadius); + } + private void drawSixWheels(Graphics2D g2D, Color color, int _startPosX, int _startPosY) { + g2D.setColor(color); + int wheelRadius = 10; + g2D.drawOval(_startPosX + 34, _startPosY + 54, wheelRadius, wheelRadius); + g2D.fillOval(_startPosX + 34, _startPosY + 54, wheelRadius, wheelRadius); + g2D.drawOval(_startPosX + 35, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 35, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 35, _startPosY + 65); + g2D.drawOval(_startPosX + 58, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 58, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 58, _startPosY + 65); + g2D.drawOval(_startPosX + 82, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 82, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 82, _startPosY + 65); + g2D.drawOval(_startPosX + 105, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + g2D.fillOval(_startPosX + 105, _startPosY + 65, wheelRadius * 2, wheelRadius * 2); + drawPattern(g2D, _startPosX + 105, _startPosY + 65); + g2D.drawOval(_startPosX + 115, _startPosY + 54, wheelRadius, wheelRadius); + g2D.fillOval(_startPosX + 115, _startPosY + 54, wheelRadius, wheelRadius); + } + private void drawPattern(Graphics2D g2D, int x, int y){ + g2D.setColor(Color.WHITE); + g2D.setStroke(new BasicStroke(2)); + g2D.drawLine(x + 10, y + 3, x + 10, y + 17); + g2D.drawLine(x + 3, y + 10, x + 17, y + 10); + g2D.setColor(Color.BLACK); + } +} diff --git a/src/EntityBulldozer.java b/src/EntityBulldozer.java index 9ad18d3..e8d71e7 100644 --- a/src/EntityBulldozer.java +++ b/src/EntityBulldozer.java @@ -8,34 +8,16 @@ public class EntityBulldozer { public double getWeight() { return Weight; } - private Color BulldozerColor; - public Color getBulldozerColor() { - return BulldozerColor; - } - private Color CabinColor; - public Color getCabinColor() { - return CabinColor; - } - private Color CovshColor; - public Color getCovshColor() {return CovshColor;} - private boolean HasMoldboardfront; - public boolean getHasMoldboardfront() { - return HasMoldboardfront; - } - private boolean HasRipper; - public boolean getHasRipper() { - return HasRipper; + private Color BodyColor; + public Color getBodyColor() { + return BodyColor; } public double getStep() { - return (double)Speed * 800 / Weight; + return (double)Speed * 100 / Weight; } - public void Init(int speed, double weight, Color bulldozerColor, Color cabinColor, Color covshColor, boolean hasMoldboardfront, boolean hasRipper) { + public EntityBulldozer(int speed, double weight, Color bodyColor) { Speed = speed; Weight = weight; - BulldozerColor = bulldozerColor; - CabinColor = cabinColor; - CovshColor = covshColor; - HasMoldboardfront = hasMoldboardfront; - HasRipper = hasRipper; + BodyColor = bodyColor; } } diff --git a/src/EntityFastBulldozer.java b/src/EntityFastBulldozer.java new file mode 100644 index 0000000..e66b6fb --- /dev/null +++ b/src/EntityFastBulldozer.java @@ -0,0 +1,26 @@ +import java.awt.*; +public class EntityFastBulldozer extends EntityBulldozer{ + private boolean Covsh; //передний ковш + public boolean getCovsh() { + return Covsh; + } + private boolean Rearbucket; // задний ковш + public boolean getRearbucket() { + return Rearbucket; + } + private Color CovshColor; + public Color getCovshColor() { + return CovshColor; + } + private Color RearbucketColor; + public Color getRearbucketColor() { + return RearbucketColor; + } + public EntityFastBulldozer(int speed, double weight, Color bodyColor, boolean covsh, boolean rearbucket, Color covshColor, Color rearbucketColor) { + super(speed, weight, bodyColor); + Covsh = covsh; + Rearbucket = rearbucket; + CovshColor = covshColor; + RearbucketColor = rearbucketColor; + } +} diff --git a/src/IDrawningWheels.java b/src/IDrawningWheels.java new file mode 100644 index 0000000..501b8c2 --- /dev/null +++ b/src/IDrawningWheels.java @@ -0,0 +1,6 @@ +import java.awt.*; +public interface IDrawningWheels { + void setWheelNumber(int number); + WheelNumber getWheelNumber(); + void drawWheels(Graphics2D g2d, Color color, int startPosX, int startPosY); +} diff --git a/src/IMoveableObject.java b/src/IMoveableObject.java new file mode 100644 index 0000000..d7cc0d8 --- /dev/null +++ b/src/IMoveableObject.java @@ -0,0 +1,6 @@ +public interface IMoveableObject { + ObjectParameters getObjectsPosition(); + int getStep(); + boolean checkCanMove(DirectionBulldozer direction); + void moveObject(DirectionBulldozer direction); +} diff --git a/src/MoveToBorder.java b/src/MoveToBorder.java new file mode 100644 index 0000000..92d32fd --- /dev/null +++ b/src/MoveToBorder.java @@ -0,0 +1,32 @@ +public class MoveToBorder extends AbstractStrategy { + @Override + protected boolean isTargetDestination() { + var objParams = getObjectParameters(); + if (objParams == null) { + return false; + } + return objParams.rightBorder() <= getFieldWidth() && + objParams.rightBorder() + getStep() >= getFieldWidth() && + objParams.downBorder() <= getFieldHeight() && + objParams.downBorder() + getStep() >= getFieldHeight(); + } + @Override + protected void moveToTarget() { + var objParams = getObjectParameters(); + if (objParams == null) { + return; + } + var diffX = objParams.objectMiddleHorizontal() - getFieldWidth(); + if (Math.abs(diffX) > getStep()) { + if (diffX < 0) { + moveRight(); + } + } + var diffY = objParams.objectMiddleVertical() - getFieldHeight(); + if (Math.abs(diffY) > getStep()) { + if (diffY < 0) { + moveDown(); + } + } + } +} diff --git a/src/MoveToCenter.java b/src/MoveToCenter.java new file mode 100644 index 0000000..bffa6d3 --- /dev/null +++ b/src/MoveToCenter.java @@ -0,0 +1,36 @@ +public class MoveToCenter extends AbstractStrategy { + @Override + protected boolean isTargetDestination() { + var objParams = getObjectParameters(); + if (objParams == null) { + return false; + } + return objParams.objectMiddleHorizontal() <= getFieldWidth() / 2 && + objParams.objectMiddleHorizontal() + getStep() >= getFieldWidth() / 2 && + objParams.objectMiddleVertical() <= getFieldHeight() / 2 && + objParams.objectMiddleVertical() + getStep() >= getFieldHeight() / 2; + } + @Override + protected void moveToTarget() { + var objParams = getObjectParameters(); + if (objParams == null) { + return; + } + var diffX = objParams.objectMiddleHorizontal() - getFieldWidth() / 2; + if (Math.abs(diffX) > getStep()) { + if (diffX > 0) { + moveLeft(); + } else { + moveRight(); + } + } + var diffY = objParams.objectMiddleVertical() - getFieldHeight() / 2; + if (Math.abs(diffY) > getStep()) { + if (diffY > 0) { + moveUp(); + } else { + moveDown(); + } + } + } +} diff --git a/src/ObjectParameters.java b/src/ObjectParameters.java new file mode 100644 index 0000000..57f0e9d --- /dev/null +++ b/src/ObjectParameters.java @@ -0,0 +1,30 @@ +public class ObjectParameters { + private final int x; + private final int y; + private final int width; + private final int height; + public int leftBorder() { + return x; + } + public int topBorder() { + return y; + } + public int rightBorder() { + return x + width; + } + public int downBorder() { + return y + height; + } + public int objectMiddleHorizontal() { + return x + width / 2; + } + public int objectMiddleVertical() { + return y + height / 2; + } + public ObjectParameters(int x, int y, int width, int height) { + this.x = x; + this.y = y; + this.width = width; + this.height = height; + } +} diff --git a/src/PictureBoxBulldozer.java b/src/PictureBoxBulldozer.java index 15b932e..7a1a05d 100644 --- a/src/PictureBoxBulldozer.java +++ b/src/PictureBoxBulldozer.java @@ -4,29 +4,54 @@ import java.awt.event.ActionListener; import java.util.Random; public class PictureBoxBulldozer extends JPanel { private DrawningBulldozer drawningBulldozer; + private AbstractStrategy abstractStrategy; private JButton buttonLeft; private JButton buttonUp; private JButton buttonRight; private JButton buttonDown; + private JButton buttonCreateFastBulldozer; private JButton buttonCreateBulldozer; + private JComboBox comboBoxStrategy; + private JButton buttonStep; public PictureBoxBulldozer() { setLayout(null); setBounds(0, 0, 800, 450); - buttonCreateBulldozer = new JButton("Создать"); + buttonCreateBulldozer = new JButton("Создать трактор"); buttonCreateBulldozer.setFocusable(false); - buttonCreateBulldozer.setBounds(12, 415, 100, 30); + buttonCreateBulldozer.setBounds(12, 415, 150, 30); add(buttonCreateBulldozer); buttonCreateBulldozer.addActionListener(e -> { Random random = new Random(); - drawningBulldozer = new DrawningBulldozer(); - drawningBulldozer.Init(random.nextInt(100)+100, - random.nextInt(2000)+1000, - new Color(random.nextInt(256), random.nextInt(256), random.nextInt(256)), - new Color(random.nextInt(256), random.nextInt(256), random.nextInt(256)), - new Color(random.nextInt(256), random.nextInt(256), random.nextInt(256)), + drawningBulldozer = new DrawningBulldozer((random.nextInt(200, 300)), + random.nextInt(1000, 3000), + new Color(random.nextInt(0, 256), random.nextInt(0, 256), + random.nextInt(0, 256)), random.nextBoolean(), random.nextBoolean(), - this.getWidth(), this.getHeight(), random.nextInt(3) + 1); - drawningBulldozer.SetPosition(random.nextInt(90) + 10, random.nextInt(90) + 10); + new Color(random.nextInt(0, 256), random.nextInt(0, 256), + random.nextInt(0, 256)), + new Color(random.nextInt(0, 256), random.nextInt(0, 256), + random.nextInt(0, 256)), + this.getWidth(), this.getHeight(), random.nextInt(2, 5)); + drawningBulldozer.SetPosition(random.nextInt(10, 100), random.nextInt(10, 100)); + repaint(); + }); + buttonCreateFastBulldozer = new JButton("Создать трактор с ковшами"); + buttonCreateFastBulldozer.setFocusable(false); + buttonCreateFastBulldozer.setBounds(180, 415, 200, 30); + add(buttonCreateFastBulldozer); + buttonCreateFastBulldozer.addActionListener(e -> { + Random random = new Random(); + drawningBulldozer = new DrawningFastBulldozer((random.nextInt(200, 300)), + random.nextInt(1000, 3000), + new Color(random.nextInt(0, 256), random.nextInt(0, 256), + random.nextInt(0, 256)), + random.nextBoolean(), random.nextBoolean(), + new Color(random.nextInt(0, 256), random.nextInt(0, 256), + random.nextInt(0, 256)), + new Color(random.nextInt(0, 256), random.nextInt(0, 256), + random.nextInt(0, 256)), + this.getWidth(), this.getHeight(), random.nextInt(2, 5)); + drawningBulldozer.SetPosition(random.nextInt(10, 100), random.nextInt(10, 100)); repaint(); }); ActionListener buttonMoveListener = e -> { @@ -84,6 +109,46 @@ public class PictureBoxBulldozer extends JPanel { buttonUp.addActionListener(buttonMoveListener); buttonUp.setBounds(722, 372, 30, 30); add(buttonUp); + String[] items = { + "0", + "1" + }; + comboBoxStrategy = new JComboBox(items); + comboBoxStrategy.setBounds(667, 10, 120, 25); + buttonStep = new JButton("Шаг"); + buttonStep.setFocusable(false); + buttonStep.setBounds(710, 40, 75, 30); + buttonStep.addActionListener(e -> { + if (drawningBulldozer == null) { + return; + } + if (comboBoxStrategy.isEnabled()) { + abstractStrategy = switch (comboBoxStrategy.getSelectedIndex()) { + case 0 -> new MoveToCenter(); + case 1 -> new MoveToBorder(); + default -> null; + }; + if (abstractStrategy == null) + { + return; + } + abstractStrategy.setData(new DrawningObjectBulldozer(drawningBulldozer), this.getWidth(), this.getHeight()); + } + if (abstractStrategy == null) + { + return; + } + comboBoxStrategy.setEnabled(false); + abstractStrategy.makeStep(); + repaint(); + if (abstractStrategy.getStatus() == Status.Finish) + { + comboBoxStrategy.setEnabled(true); + abstractStrategy = null; + } + }); + add(comboBoxStrategy); + add(buttonStep); setPreferredSize(new Dimension(800, 450)); } @Override @@ -95,4 +160,4 @@ public class PictureBoxBulldozer extends JPanel { Graphics2D g2d = (Graphics2D) g; drawningBulldozer.DrawTransport(g2d); } -} \ No newline at end of file +} diff --git a/src/Status.java b/src/Status.java new file mode 100644 index 0000000..6467ed7 --- /dev/null +++ b/src/Status.java @@ -0,0 +1,5 @@ +public enum Status { + NotInit, + InProgress, + Finish +} diff --git a/src/WheelNumber.java b/src/WheelNumber.java index aec5819..92b4e03 100644 --- a/src/WheelNumber.java +++ b/src/WheelNumber.java @@ -2,4 +2,4 @@ public enum WheelNumber { Four, Five, Six -} \ No newline at end of file +}