LorenzHohmann
/
tims
1
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Merge commit '353c68c35867e57d918907c9d8d86edbeb0890e1' into HEAD

gameexplorer_gui
Jenkins 3 years ago
parent
8b4389e2d6 353c68c358
commit
61e1035bb1
9 changed files with 1425 additions and 5 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 227
      src/main/java/de/tims/fleetstorm/ai/Logic.java
  2. 268
      src/main/java/de/tims/fleetstorm/gui/GameLogic.java
  3. 61
      src/main/java/de/tims/fleetstorm/matchfield/Coordinate.java
  4. 113
      src/main/java/de/tims/fleetstorm/matchfield/Matchfield.java
  5. 366
      src/test/java/de/tims/fleetstorm/ai/LogicTest.java
  6. 36
      src/test/java/de/tims/fleetstorm/gui/LogicTest.java
  7. 82
      src/test/java/de/tims/fleetstorm/matchfield/CoordinateTest.java
  8. 144
      src/test/java/de/tims/fleetstorm/matchfield/MatchfieldCreationTest.java
  9. 133
      src/test/java/de/tims/fleetstorm/matchfield/MatchfieldShipTest.java

227
src/main/java/de/tims/fleetstorm/ai/Logic.java
View File

@ -1,9 +1,232 @@
package de.tims.fleetstorm.ai; package de.tims.fleetstorm.ai;
import java.util.ArrayList;
import java.util.Random;
import de.tims.fleetstorm.matchfield.Coordinate;
import de.tims.fleetstorm.matchfield.Matchfield;
public class Logic { public class Logic {
public int[] chooseField() {
return new int[] {};
private Matchfield matchfield;
private ArrayList<Coordinate> everySecondField;
private Coordinate lastShot;
private Coordinate target;
private boolean foundShip;
private boolean clearedAbove;
private boolean clearedBelow;
private boolean clearedRight;
private boolean clearedLeft;
public Logic() {
foundShip = false;
clearedAbove = false;
clearedBelow = false;
clearedRight = false;
clearedLeft = false;
}
public Coordinate chooseField() {
Coordinate out;
if (foundShip) {
// Clear Y-Axis
if (!clearedAbove) {
target = matchfield.getAbove(target);
out = target;
if (target == null || target.getState() == Coordinate.EMPTY) {
clearedAbove = true;
target = lastShot;
}
return out;
}
if (!clearedBelow) {
target = matchfield.getBelow(target);
out = target;
if (target == null || target.getState() == Coordinate.EMPTY) {
clearedBelow = true;
target = lastShot;
}
isShipOnYAxis();
return out;
}
// Clear x-Axis
if (!clearedRight) {
target = matchfield.getRight(target);
out = target;
if (target == null || target.getState() == Coordinate.EMPTY) {
clearedRight = true;
target = lastShot;
}
return out;
}
if (!clearedLeft) {
target = matchfield.getLeft(target);
out = target;
if (target == null || target.getState() == Coordinate.EMPTY) {
clearedLeft = true;
target = lastShot;
}
sinkShip();
return out;
}
}
ArrayList<Coordinate> possibleFields = new ArrayList<Coordinate>();
for (int i = 0; i < everySecondField.size(); i++) {
if (everySecondField.get(i).getState() != Coordinate.SHOT
&& everySecondField.get(i).getState() != Coordinate.HIT) {
possibleFields.add(everySecondField.get(i));
}
}
Random randy = new Random();
lastShot = possibleFields.get(randy.nextInt(possibleFields.size()));
target = possibleFields.get(randy.nextInt(possibleFields.size()));
if (lastShot.getState() == Coordinate.SHIP) {
foundShip = true;
}
return lastShot;
}
public void isShipOnYAxis() {
if ((clearedAbove && clearedBelow) && ((matchfield.getAbove(lastShot) == null
|| (matchfield.getAbove(lastShot).getState() == Coordinate.HIT))
|| (matchfield.getBelow(lastShot) == null
|| (matchfield.getBelow(lastShot).getState() == Coordinate.HIT)))) {
clearedLeft = true;
clearedRight = true;
sinkShip();
}
}
public ArrayList<Coordinate> getEverySecondField() {
ArrayList<Coordinate> out = new ArrayList<Coordinate>();
for (int x = 0; x < Math.sqrt(this.matchfield.getSize()); x++) {
for (int y = 0; y < Math.sqrt(this.matchfield.getSize()); y++) {
if ((x % 2 == 0 && y % 2 == 0) || (x % 2 == 1 && y % 2 == 1)) {
out.add(this.matchfield.getField(x, y));
}
}
}
return out;
} }
public void findShip() {
if (lastShot.getState() == Coordinate.HIT) {
foundShip = true;
}
}
public void sinkShip() {
if (foundShip && clearedAbove && clearedBelow && clearedLeft && clearedRight) {
this.foundShip = false;
this.clearedAbove = false;
this.clearedBelow = false;
this.clearedLeft = false;
this.clearedRight = false;
}
}
public void clearAbove(Coordinate shot) {
target = matchfield.getAbove(shot);
if (target.getState() == Coordinate.EMPTY) {
clearedAbove = true;
}
}
public void clearBelow(Coordinate shot) {
target = matchfield.getBelow(shot);
if (target.getState() == Coordinate.EMPTY) {
clearedBelow = true;
}
}
public void clearRight(Coordinate shot) {
target = matchfield.getRight(shot);
if (target.getState() == Coordinate.EMPTY) {
clearedRight = true;
}
}
public void clearLeft(Coordinate shot) {
target = matchfield.getLeft(shot);
if (target.getState() == Coordinate.EMPTY) {
clearedLeft = true;
}
}
// Getter And Setter
public void setEverySecondField(ArrayList<Coordinate> everySecondField) {
this.everySecondField = everySecondField;
}
public void setLastShot(Coordinate coordinate) {
lastShot = this.matchfield.getField(coordinate);
}
public Coordinate getLastShot() {
return lastShot;
}
public void setFoundShip(boolean b) {
this.foundShip = b;
}
public boolean getFoundShip() {
return this.foundShip;
}
public void setClearedAbove(boolean b) {
this.clearedAbove = b;
}
public boolean getClearedAbove() {
return this.clearedAbove;
}
public void setClearedBelow(boolean b) {
this.clearedBelow = b;
}
public boolean getClearedBelow() {
return this.clearedBelow;
}
public void setClearedRight(boolean b) {
this.clearedRight = b;
}
public boolean getClearedRight() {
return this.clearedRight;
}
public void setClearedLeft(boolean b) {
this.clearedLeft = b;
}
public boolean getClearedLeft() {
return this.clearedLeft;
}
public void setTarget(Coordinate target) {
this.target = target;
}
public Coordinate getTarget() {
return target;
}
public void setMatchfield(Matchfield matchfield) {
this.matchfield = matchfield;
this.everySecondField = getEverySecondField();
}
public Matchfield getMatchfield() {
return matchfield;
}
} }

268
src/main/java/de/tims/fleetstorm/gui/GameLogic.java
View File

@ -0,0 +1,268 @@
package de.tims.fleetstorm.gui;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SwingConstants;
import javax.swing.border.MatteBorder;
import de.tims.fleetstorm.ai.Logic;
import de.tims.fleetstorm.matchfield.Coordinate;
import de.tims.fleetstorm.matchfield.Matchfield;
public class GameLogic extends JPanel {
// GameManager stuff
private int gameState;
private Matchfield matchfield;
private Matchfield enemyMatchfield;
private int matchfieldSize = 10;
private boolean playerMove;
private Logic aiLogic;
public static final int PREPARATION = 1;
public static final int RUNNING = 2;
public static final int GAME_OVER = 3;
// GUI stuff
private ArrayList<JPanel> playerFields;
private ArrayList<JPanel> enemyFields;
public GameLogic(int gapToFrameBorderX, int gapToFrameBorderY, int fieldWidth, int spaceBetween) {
this.playerFields = new ArrayList<>();
this.enemyFields = new ArrayList<>();
setSize(640, 480);
fieldWrapper = new JPanel();
fieldWrapper.setBounds(10, 11, 305, 458);
fieldWrapper.setLayout(null);
setLayout(null);
add(fieldWrapper);
enemyFieldWrapper = new JPanel();
enemyFieldWrapper.setLayout(null);
enemyFieldWrapper.setBounds(326, 11, 305, 458);
add(enemyFieldWrapper);
this.generateFieldsForGUI(gapToFrameBorderX, gapToFrameBorderY, fieldWidth, spaceBetween, fieldWrapper,
this.playerFields, false);
JLabel ownFieldLabel = new JLabel("Eigenes Spielfeld");
ownFieldLabel.setBounds(10, 11, 114, 14);
fieldWrapper.add(ownFieldLabel);
this.generateFieldsForGUI(gapToFrameBorderX, gapToFrameBorderY, fieldWidth, spaceBetween, enemyFieldWrapper,
this.enemyFields, true);
JLabel enemyFieldLabel = new JLabel("Gegnerisches Spielfeld");
enemyFieldLabel.setBounds(10, 11, 168, 14);
enemyFieldWrapper.add(enemyFieldLabel);
}
private void generateFieldsForGUI(int gapToFrameBorderX, int gapToFrameBorderY, int fieldWidth, int spaceBetween,
JPanel panel, ArrayList<JPanel> fields, boolean registerMouseListener) {
for (int x = 0; x < this.matchfieldSize; x++) {
for (int y = 0; y < this.matchfieldSize; y++) {
JPanel field = new JPanel();
int xPos = gapToFrameBorderX + x * fieldWidth + (x * spaceBetween);
int yPos = gapToFrameBorderY + y * fieldWidth + (y * spaceBetween);
field.setBounds(xPos, yPos, fieldWidth, fieldWidth);
field.setBorder(new MatteBorder(1, 1, 1, 1, (Color) new Color(0, 0, 0)));
field.setName(x + ":" + y);
fields.add(field);
panel.add(field);
if (!registerMouseListener)
continue;
field.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
int[] coords = getCoordinateFromLabel(field);
int coordX = coords[0];
int coordY = coords[1];
Coordinate chosenField = enemyMatchfield.getField(coordX, coordY);
boolean shotSuccess = chosenField.shoot();
boolean areAllShipsHit = enemyMatchfield.areAllShipsHit();
if (areAllShipsHit) {
gameOver(true);
return;
}
if (shotSuccess && chosenField.getState() != Coordinate.HIT) {
nextMove(false);
} else {
nextMove(true);
}
}
});
}
}
}
private JLabel getXLabel() {
JLabel x = new JLabel("x");
x.setForeground(Color.WHITE);
return x;
}
private int[] getCoordinateFromLabel(JPanel panel) {
String panelName = panel.getName();
String[] panelNameSplit = panelName.split(":");
int coordX = Integer.parseInt(panelNameSplit[0]);
int coordY = Integer.parseInt(panelNameSplit[1]);
return new int[] { coordX, coordY };
}
private void updateFields() {
this.updateField(enemyMatchfield, this.enemyFields);
this.updateField(matchfield, this.playerFields);
}
private void updateField(Matchfield matchfield, ArrayList<JPanel> fields) {
for (JPanel coordinatePanel : fields) {
int[] coords = getCoordinateFromLabel(coordinatePanel);
int coordX = coords[0];
int coordY = coords[1];
// reset field
coordinatePanel.setBackground(null);
coordinatePanel.removeAll();
int state = matchfield.getField(coordX, coordY).getState();
switch (state) {
case Coordinate.SHIP:
if (playerMove)
coordinatePanel.setBackground(new Color(91, 58, 41));
break;
case Coordinate.SHOT:
coordinatePanel.setBackground(new Color(0, 94, 184));
break;
case Coordinate.HIT:
coordinatePanel.setBackground(new Color(91, 58, 41));
coordinatePanel.add(getXLabel());
break;
}
coordinatePanel.revalidate();
coordinatePanel.repaint();
}
}
/**
* This function is only for testing
*/
private static GameLogic gui;
private JPanel fieldWrapper;
private JPanel enemyFieldWrapper;
public static void main(String[] args) {
JFrame frame = new JFrame("Test GUI");
gui = new GameLogic(12, 35, 25, 1);
frame.setContentPane(gui);
frame.setSize(640, 480);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setResizable(true);
frame.setVisible(true);
gui.start(false);
}
public void start(boolean test) {
this.gameState = GameLogic.PREPARATION;
this.playerMove = true;
// create player matchfield and set ships
this.matchfield = new Matchfield(matchfieldSize);
this.matchfield.createMatchfield();
this.matchfield.setShip(new Coordinate(4, 6), 2, 0);
this.matchfield.setShip(new Coordinate(1, 3), 3, 0);
this.matchfield.setShip(new Coordinate(9, 1), 4, 1);
this.matchfield.setShip(new Coordinate(0, 0), 5, 0);
this.aiLogic = new Logic();
this.aiLogic.setMatchfield(this.matchfield);
// create enemy matchfield, set ships and initialize AI (with player's
// matchfield)
this.enemyMatchfield = new Matchfield(matchfieldSize);
this.enemyMatchfield.createMatchfield();
this.enemyMatchfield.setShip(new Coordinate(8, 9), 2, 0);
this.enemyMatchfield.setShip(new Coordinate(0, 2), 3, 1);
this.enemyMatchfield.setShip(new Coordinate(7, 0), 4, 1);
this.enemyMatchfield.setShip(new Coordinate(3, 6), 5, 0);
// enter game loop
this.gameState = GameLogic.RUNNING;
if (!test)
this.nextMove(true);
}
public void nextMove(boolean playerMove) {
this.playerMove = playerMove;
if (this.playerMove) {
gui.updateFields();
// waiting here for mouse click event....
} else {
Coordinate aiChosenField = null;
while (aiChosenField == null) {
aiChosenField = this.aiLogic.chooseField();
}
aiChosenField.shoot();
gui.updateFields();
boolean areAllShipsHit = this.matchfield.areAllShipsHit();
if (areAllShipsHit) {
this.gameOver(false);
return;
}
boolean aiHasNextMove = aiChosenField.getState() != Coordinate.HIT;
this.nextMove(aiHasNextMove);
}
}
protected void gameOver(boolean playerWinner) {
this.gameState = GameLogic.GAME_OVER;
this.removeAll();
this.setLayout(new BorderLayout());
JLabel wonLabel = new JLabel(playerWinner ? "Du hast gewonnen!" : "Du hast verloren!");
wonLabel.setHorizontalAlignment(SwingConstants.CENTER);
wonLabel.setVerticalAlignment(SwingConstants.CENTER);
wonLabel.setFont(new Font("Tahoma", Font.BOLD, 18));
this.add(wonLabel, SwingConstants.CENTER);
this.revalidate();
this.repaint();
}
public int getGameState() {
return gameState;
}
}

61
src/main/java/de/tims/fleetstorm/matchfield/Coordinate.java
View File

@ -0,0 +1,61 @@
package de.tims.fleetstorm.matchfield;
public class Coordinate {
private int x;
private int y;
private int state;
public static final int EMPTY = 0;
public static final int SHIP = 1;
public static final int SHOT = 2;
public static final int HIT = 3;
public Coordinate(int x, int y) {
this.x = x;
this.y = y;
this.state = 0;
}
public Integer getX() {
return x;
}
public Integer getY() {
return y;
}
public int getState() {
return this.state;
}
public void setState(int state) {
this.state = state;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Coordinate)) {
return false;
}
return this.x == ((Coordinate) obj).getX() && this.y == ((Coordinate) obj).getY();
}
public void print() {
System.out.println("X = " + this.x + ", Y = " + this.y + ", State = " + this.state);
}
public boolean shoot() {
if (this.state == Coordinate.SHOT || this.state == Coordinate.HIT)
return false;
if (this.state == Coordinate.SHIP) {
this.state = Coordinate.HIT;
return true;
}
this.state = Coordinate.SHOT;
return true;
}
}

113
src/main/java/de/tims/fleetstorm/matchfield/Matchfield.java
View File

@ -0,0 +1,113 @@
package de.tims.fleetstorm.matchfield;
public class Matchfield {
private Coordinate[][] matchfield;
private int size;
public Matchfield(int size) {
this.size = size;
this.matchfield = new Coordinate[this.size][this.size];
}
public Coordinate[][] createMatchfield() {
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
this.matchfield[i][j] = new Coordinate(i, j);
}
}
return this.matchfield;
}
public int getSize() {
return this.matchfield.length * this.matchfield[0].length;
}
public int getState(int x, int y) {
return this.matchfield[x][y].getState();
}
public void setState(int x, int y, int state) {
this.matchfield[x][y].setState(state);
}
public void setState(Coordinate coordinate, int state) {
this.matchfield[coordinate.getX()][coordinate.getY()].setState(state);
}
public Coordinate getField(Coordinate coordinate) {
return matchfield[coordinate.getX()][coordinate.getY()];
}
public Coordinate getField(int x, int y) {
return this.matchfield[x][y];
}
public Coordinate getRight(Coordinate center) {
if (center.getX() == matchfield.length - 1) {
return null;
}
return this.matchfield[center.getX() + 1][center.getY()];
}
public Coordinate getLeft(Coordinate center) {
if (center.getX() == 0) {
return null;
}
return this.matchfield[center.getX() - 1][center.getY()];
}
public Coordinate getAbove(Coordinate center) {
if (center.getY() == matchfield.length - 1) {
return null;
}
return matchfield[center.getX()][center.getY() + 1];
}
public Coordinate getBelow(Coordinate center) {
if (center.getY() == 0) {
return null;
}
return matchfield[center.getX()][center.getY() - 1];
}
/**
* direction 0 => x axis (to the right) direction 1 => y axis (to the bottom)
*/
public boolean setShip(Coordinate coordinate, int length, int direction) {
for (int i = 0; i < length; i++) {
Coordinate field = this.getField(coordinate);
if (field.getState() == Coordinate.SHIP)
return false;
field.setState(Coordinate.SHIP);
if (direction == 0)
coordinate = this.getRight(coordinate);
if (direction == 1)
coordinate = this.getAbove(coordinate);
if (coordinate == null)
return false;
}
return true;
}
public boolean areAllShipsHit() {
int shipCounter = 0;
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
int fieldState = this.matchfield[i][j].getState();
if (fieldState == Coordinate.SHIP)
shipCounter++;
}
}
return shipCounter == 0;
}
}

366
src/test/java/de/tims/fleetstorm/ai/LogicTest.java
View File

@ -1,16 +1,376 @@
package de.tims.fleetstorm.ai; package de.tims.fleetstorm.ai;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotNull;
import java.util.ArrayList;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import de.tims.fleetstorm.matchfield.Coordinate;
import de.tims.fleetstorm.matchfield.Matchfield;
class LogicTest { class LogicTest {
Logic logic = new Logic();
@Test @Test
void testFielIsNotNull() {
int[] calcResult = logic.chooseField();
void testFieldIsNotNull() {
Logic logic = new Logic();
Matchfield matchfield;
int size = 5;
matchfield = new Matchfield(size);
matchfield.createMatchfield();
logic.setMatchfield(matchfield);
// ArrayList<Coordinate> everySecondField = logic.getEverySecondField();
Coordinate calcResult = logic.chooseField();
assertNotNull(calcResult); assertNotNull(calcResult);
} }
@Test
void testChoosenFieldHasNotStateShot() {
Logic logic = new Logic();
Matchfield matchfield;
int size = 5;
matchfield = new Matchfield(size);
matchfield.createMatchfield();
logic.setMatchfield(matchfield);
ArrayList<Coordinate> everySecondField = logic.getEverySecondField();
for (int i = 0; i < everySecondField.size(); i++) {
everySecondField.get(i).setState(Coordinate.SHOT);
}
matchfield.setState(2, 2, Coordinate.EMPTY);
logic.setEverySecondField(everySecondField);
int calcState = logic.chooseField().getState();
assertNotEquals(calcState, Coordinate.SHOT);
}
@Test
void testGetEverySecondField() {
Logic logic = new Logic();
Matchfield matchfield;
int size = 4;
matchfield = new Matchfield(size);
matchfield.createMatchfield();
logic.setMatchfield(matchfield);
ArrayList<Coordinate> everySecondField = logic.getEverySecondField();
ArrayList<Coordinate> expectedResult = new ArrayList<Coordinate>();
expectedResult.add(new Coordinate(0, 0));
expectedResult.add(new Coordinate(0, 2));
expectedResult.add(new Coordinate(1, 1));
expectedResult.add(new Coordinate(1, 3));
expectedResult.add(new Coordinate(2, 0));
expectedResult.add(new Coordinate(2, 2));
expectedResult.add(new Coordinate(3, 1));
expectedResult.add(new Coordinate(3, 3));
assertEquals(everySecondField, expectedResult);
}
@Test
void testGetAndSetLastShot() {
Logic logic = new Logic();
Matchfield matchfield;
int size = 4;
matchfield = new Matchfield(size);
matchfield.createMatchfield();
logic.setMatchfield(matchfield);
Coordinate expectedResult = new Coordinate(2, 2);
logic.setLastShot(expectedResult);
Coordinate result = logic.getLastShot();
assertEquals(result, expectedResult);
}
@Test
void testSetMatchfield() {
Logic logic = new Logic();
Matchfield matchfield;
int size = 4;
matchfield = new Matchfield(size);
matchfield.createMatchfield();
Matchfield result = logic.getMatchfield();
assertEquals(result, null);
logic.setMatchfield(matchfield);
result = logic.getMatchfield();
assertNotNull(result);
}
@Test
void testFindShip() {
Logic logic = new Logic();
Matchfield matchfield;
int size = 4;
matchfield = new Matchfield(size);
matchfield.createMatchfield();
logic.setMatchfield(matchfield);
logic.setLastShot(new Coordinate(2, 2));
logic.getLastShot().setState(Coordinate.HIT);
logic.findShip();
assertEquals(logic.getFoundShip(), true);
}
@Test
void testGetAndsetFoundShip() {
Logic logic = new Logic();
logic.setFoundShip(true);
assertEquals(logic.getFoundShip(), true);
}
@Test
void testClearAbove() {
Logic logic = new Logic();
Matchfield matchfield;
Coordinate shot = new Coordinate(2, 2);
int size = 4;
matchfield = new Matchfield(size);
matchfield.createMatchfield();
logic.setMatchfield(matchfield);
logic.setLastShot(shot);
matchfield.getField(shot).setState(Coordinate.EMPTY);
logic.clearAbove(shot);
assertEquals(logic.getClearedAbove(), true);
}
@Test
void testClearBelow() {
Logic logic = new Logic();
Matchfield matchfield;
Coordinate shot = new Coordinate(2, 2);
int size = 4;
matchfield = new Matchfield(size);
matchfield.createMatchfield();
logic.setMatchfield(matchfield);
logic.setLastShot(shot);
matchfield.getField(shot).setState(Coordinate.EMPTY);
logic.clearBelow(shot);
assertEquals(logic.getClearedBelow(), true);
}
@Test
void testClearRight() {
Logic logic = new Logic();
Matchfield matchfield;
Coordinate shot = new Coordinate(2, 2);
int size = 4;
matchfield = new Matchfield(size);
matchfield.createMatchfield();
logic.setMatchfield(matchfield);
logic.setLastShot(shot);
matchfield.getField(shot).setState(Coordinate.EMPTY);
logic.clearRight(shot);
assertEquals(logic.getClearedRight(), true);
}
@Test
void testClearLeft() {
Logic logic = new Logic();
Matchfield matchfield;
Coordinate shot = new Coordinate(2, 2);
int size = 4;
matchfield = new Matchfield(size);
matchfield.createMatchfield();
logic.setMatchfield(matchfield);
logic.setLastShot(shot);
matchfield.getField(shot).setState(Coordinate.EMPTY);
logic.clearLeft(shot);
assertEquals(logic.getClearedLeft(), true);
}
@Test
void testConstructor() {
Logic logic = new Logic();
assertEquals(logic.getFoundShip(), false);
assertEquals(logic.getClearedAbove(), false);
assertEquals(logic.getClearedBelow(), false);
assertEquals(logic.getClearedLeft(), false);
assertEquals(logic.getClearedRight(), false);
}
@Test
void testSetterClearedAbove() {
Logic logic = new Logic();
logic.setClearedAbove(true);
assertEquals(logic.getClearedAbove(), true);
}
@Test
void testSetterClearedBelow() {
Logic logic = new Logic();
logic.setClearedBelow(true);
assertEquals(logic.getClearedBelow(), true);
}
@Test
void testSetterClearedRight() {
Logic logic = new Logic();
logic.setClearedRight(true);
assertEquals(logic.getClearedRight(), true);
}
@Test
void testSetterClearedLeft() {
Logic logic = new Logic();
logic.setClearedLeft(true);
assertEquals(logic.getClearedLeft(), true);
}
@Test
void testSinkShip() {
Logic logic = new Logic();
logic.setFoundShip(true);
logic.setClearedAbove(true);
logic.setClearedBelow(true);
logic.setClearedRight(true);
logic.setClearedLeft(true);
logic.sinkShip();
assertEquals(logic.getFoundShip(), false);
assertEquals(logic.getClearedAbove(), false);
assertEquals(logic.getClearedBelow(), false);
assertEquals(logic.getClearedLeft(), false);
assertEquals(logic.getClearedRight(), false);
}
@Test
void testChooseFieldAboveAfterHit() {
Logic logic = new Logic();
int size = 4;
Coordinate center = new Coordinate(2, 2);
Coordinate expectedResult = new Coordinate(2, 3);
Matchfield matchfield = new Matchfield(size);
matchfield.createMatchfield();
matchfield.setState(center, Coordinate.HIT);
matchfield.setState(expectedResult, Coordinate.HIT);
logic.setMatchfield(matchfield);
logic.setLastShot(center);
logic.setTarget(center);
logic.setFoundShip(true);
Coordinate result = logic.chooseField();
assertEquals(result, expectedResult);
}
@Test
void testChooseFieldBelowAfterHit() {
Logic logic = new Logic();
int size = 4;
Coordinate center = new Coordinate(2, 2);
Coordinate expectedResult = new Coordinate(2, 1);
Matchfield matchfield = new Matchfield(size);
matchfield.createMatchfield();
matchfield.setState(center, Coordinate.HIT);
matchfield.setState(expectedResult, Coordinate.HIT);
logic.setMatchfield(matchfield);
logic.setLastShot(center);
logic.setTarget(center);
logic.setFoundShip(true);
logic.chooseField();// first Shot
Coordinate result = logic.chooseField(); // second Shot
assertEquals(result, expectedResult);
}
@Test
void testChooseFieldRightAfterHit() {
Logic logic = new Logic();
int size = 4;
Coordinate center = new Coordinate(2, 2);
Coordinate expectedResult = new Coordinate(3, 2);
Matchfield matchfield = new Matchfield(size);
matchfield.createMatchfield();
matchfield.setState(center, Coordinate.HIT);
matchfield.setState(expectedResult, Coordinate.HIT);
logic.setMatchfield(matchfield);
logic.setLastShot(center);
logic.setTarget(center);
logic.setFoundShip(true);
logic.chooseField(); // first Shot
logic.chooseField(); // second Shot
Coordinate result = logic.chooseField();
assertEquals(result, expectedResult);
}
@Test
void testChooseFieldLeftAfterHit() {
Logic logic = new Logic();
int size = 4;
Coordinate center = new Coordinate(2, 2);
Coordinate expectedResult = new Coordinate(1, 2);
Matchfield matchfield = new Matchfield(size);
matchfield.createMatchfield();
matchfield.setState(center, Coordinate.HIT);
matchfield.setState(expectedResult, Coordinate.HIT);
logic.setMatchfield(matchfield);
logic.setLastShot(center);
logic.setTarget(center);
logic.setFoundShip(true);
logic.chooseField(); // first Shot
logic.chooseField(); // second Shot
logic.chooseField(); // third Shot Coordinate
Coordinate result = logic.chooseField();
assertEquals(result, expectedResult);
}
@Test
void testShipIsOnYAxis() {
int size = 10;
Logic logic = new Logic();
Matchfield matchfield = new Matchfield(size);
Coordinate s1 = new Coordinate(5, 4);
Coordinate s2 = new Coordinate(5, 5);
Coordinate s3 = new Coordinate(5, 6);
matchfield.createMatchfield();
matchfield.setState(s1, Coordinate.SHIP);
matchfield.setState(s2, Coordinate.HIT);
matchfield.setState(s3, Coordinate.SHIP);
logic.setMatchfield(matchfield);
logic.setLastShot(s2);
logic.setTarget(s2);
logic.setFoundShip(true);
logic.chooseField(); // First shot (s3)
logic.getMatchfield().setState(s3, Coordinate.HIT); //
logic.chooseField(); // Second Shot
logic.getMatchfield().setState(new Coordinate(5, 7), Coordinate.SHOT);
logic.chooseField(); // Third Shot (s1)
logic.getMatchfield().setState(s1, Coordinate.HIT); //
logic.chooseField(); // fourth Shot
assertEquals(logic.getFoundShip(), false);
assertEquals(logic.getClearedAbove(), false);
assertEquals(logic.getClearedBelow(), false);
assertEquals(logic.getClearedLeft(), false);
assertEquals(logic.getClearedRight(), false);
}
} }

36
src/test/java/de/tims/fleetstorm/gui/LogicTest.java
View File

@ -0,0 +1,36 @@
package de.tims.fleetstorm.gui;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
class LogicTest {
GameLogic guiLogic = new GameLogic(0, 0, 0, 0);
@BeforeEach
void setup() {
guiLogic.start(true);
}
@Test
void testIfGameStateIsRunningAfterStart() {
int expectedState = GameLogic.RUNNING;
int calculatedState = guiLogic.getGameState();
assertEquals(expectedState, calculatedState);
}
@Test
void testIfGameStateIsGameOverAfterGameOverFunction() {
int expectedState = GameLogic.GAME_OVER;
guiLogic.gameOver(true);
int calculatedState = guiLogic.getGameState();
assertEquals(expectedState, calculatedState);
}
}

82
src/test/java/de/tims/fleetstorm/matchfield/CoordinateTest.java
View File

@ -0,0 +1,82 @@
package de.tims.fleetstorm.matchfield;
import static org.junit.jupiter.api.Assertions.*;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
class CoordinateTest {
int x = 1;
int y = 3;
Coordinate coordinate = new Coordinate(x, y);
@Test
void testGetCorrectValuesForXY() {
assertEquals(coordinate.getX(), x);
assertEquals(coordinate.getY(), y);
}
@Test
void testCoordinatehasDefaultStates() {
assertEquals(coordinate.getState(), Coordinate.EMPTY);
assertEquals(coordinate.getState(), 0);
}
@ParameterizedTest(name = "All Getters/Setters are working")
@MethodSource("AllGettersAreWorking")
void testGetAndSetForAllStates(String testName, int state, int stateCode, int expectedResult) {
coordinate.setState(state);
int result = coordinate.getState();
assertThat(result).describedAs(testName).isEqualTo(expectedResult);
}
static Stream<Arguments> AllGettersAreWorking() {
return Stream.of(Arguments.of("State = SHIP", 1, Coordinate.SHIP, Coordinate.SHIP),
Arguments.of("State = SHOT", 2, Coordinate.SHOT, Coordinate.SHOT),
Arguments.of("State = HIT", 3, Coordinate.HIT, Coordinate.HIT),
Arguments.of("State = EMPTY", 0, Coordinate.EMPTY, Coordinate.EMPTY));
}
@ParameterizedTest(name = "test if shoot function sets correct field states")
@MethodSource("ShootFunctionFieldStates")
void testShootFunctionSetsCorrectFieldStates(String testName, Coordinate coordinateToTest, int expectedState) {
Matchfield matchfield = new Matchfield(10);
matchfield.createMatchfield();
// set dummy ship
matchfield.setShip(new Coordinate(0, 0), 5, 0);
Coordinate realCoordinate = matchfield.getField(coordinateToTest);
realCoordinate.shoot();
int calculatedResult = realCoordinate.getState();
assertThat(calculatedResult).describedAs(testName).isEqualTo(expectedState);
}
static Stream<Arguments> ShootFunctionFieldStates() {
return Stream.of(Arguments.of("Field State is HIT", new Coordinate(0, 0), Coordinate.HIT),
Arguments.of("Field State is SHOT", new Coordinate(0, 1), Coordinate.SHOT));
}
@Test
void testIfShootCheckWhenFieldIsAlreadyShot() {
Matchfield matchfield = new Matchfield(10);
matchfield.createMatchfield();
// set dummy ship
matchfield.setShip(new Coordinate(3, 3), 4, 1);
assertTrue(matchfield.getField(0, 0).shoot());
assertFalse(matchfield.getField(0, 0).shoot());
matchfield.getField(3, 4).shoot();
assertFalse(matchfield.getField(3, 4).shoot());
}
}

144
src/test/java/de/tims/fleetstorm/matchfield/MatchfieldCreationTest.java
View File

@ -0,0 +1,144 @@
package de.tims.fleetstorm.matchfield;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
class MatchfieldCreationTest {
@Test
void testMatchfieldCreateNotEmpty() {
Matchfield matchfield = new Matchfield(0);
Coordinate[][] calcResult = matchfield.createMatchfield();
assertNotNull(calcResult);
}
@ParameterizedTest(name = "matchfield creation has correct size")
@MethodSource("testMatchfieldSize")
void testMatchfieldCreationHasCorrectSize(String testName, int size, int expectedResult) {
Matchfield matchfield = new Matchfield(size);
matchfield.createMatchfield();
int calcResult = matchfield.getSize();
assertThat(calcResult).describedAs(testName).isEqualTo(expectedResult);
}
static Stream<Arguments> testMatchfieldSize() {
return Stream.of(Arguments.of("field size 10x10", 10, 100), Arguments.of("field size 15x15", 15, 225));
}
@ParameterizedTest(name = "matchfield get field is correct")
@MethodSource("testMatchfieldGetFieldState")
void testMatchfieldGetCorrectState(String testName, int x, int y, int expectedResult) {
Matchfield matchfield = new Matchfield(10);
matchfield.createMatchfield();
int calcResult = matchfield.getState(x, y);
assertThat(calcResult).describedAs(testName).isEqualTo(expectedResult);
}
static Stream<Arguments> testMatchfieldGetFieldState() {
return Stream.of(Arguments.of("field x:0 y:0 has empty state", 0, 0, Coordinate.EMPTY));
}
@ParameterizedTest(name = "matchfield change field is correct")
@MethodSource("testMatchfieldSetStateIsCorrect")
void testMatchfieldGetCorrectState(String testName, int x, int y, int state, int expectedResult) {
Matchfield matchfield = new Matchfield(10);
matchfield.createMatchfield();
matchfield.setState(x, y, state);
int calcResult = matchfield.getState(x, y);
assertThat(calcResult).describedAs(testName).isEqualTo(expectedResult);
}
static Stream<Arguments> testMatchfieldSetStateIsCorrect() {
return Stream.of(
Arguments.of("field x:0 y:0 has state SHIP after setState()", 0, 0, Coordinate.SHIP, Coordinate.SHIP));
}
@ParameterizedTest(name = "Get the Coordinate right")
@MethodSource("getCoordinateRight")
void testGetRight(String testName, Matchfield matchfield, Coordinate center, Coordinate expectedResult) {
Coordinate result = matchfield.getRight(center);
assertThat(result).describedAs(testName).isEqualTo(expectedResult);
}
static Stream<Arguments> getCoordinateRight() {
Matchfield matchfield = new Matchfield(10);
return Stream.of(
Arguments.of("right from (5/5) - should be (6,5)", matchfield, new Coordinate(5, 5),
matchfield.getField(6, 5)),
Arguments.of("right from (9/5) - should be null", matchfield, new Coordinate(9, 5), null));
}
@ParameterizedTest(name = "Get the Coordinate left")
@MethodSource("getCoordinateLeft")
void testGetLeft(String testName, Matchfield matchfield, Coordinate center, Coordinate expectedResult) {
Coordinate result = matchfield.getLeft(center);
assertThat(result).describedAs(testName).isEqualTo(expectedResult);
}
static Stream<Arguments> getCoordinateLeft() {
Matchfield matchfield = new Matchfield(10);
return Stream.of(
Arguments.of("left from (5/5) - should be (4,5)", matchfield, new Coordinate(5, 5),
matchfield.getField(4, 5)),
Arguments.of("left from (0/5) - should be null", matchfield, new Coordinate(0, 5), null));
}
@ParameterizedTest(name = "Get the Coordinate above")
@MethodSource("getCoordinateAbove")
void testGetAbove(String testName, Matchfield matchfield, Coordinate center, Coordinate expectedResult) {
Coordinate result = matchfield.getAbove(center);
assertThat(result).describedAs(testName).isEqualTo(expectedResult);
}
static Stream<Arguments> getCoordinateAbove() {
Matchfield matchfield = new Matchfield(10);
return Stream.of(
Arguments.of("above from (5/5) - should be (5,6)", matchfield, new Coordinate(5, 5),
matchfield.getField(5, 6)),
Arguments.of("above from (5/9) - should be null", matchfield, new Coordinate(5, 5), null));
}
@ParameterizedTest(name = "Get the Coordinate below")
@MethodSource("getCoordinateBelow")
void testGetBelow(String testName, Matchfield matchfield, Coordinate center, Coordinate expectedResult) {
Coordinate result = matchfield.getBelow(center);
assertThat(result).describedAs(testName).isEqualTo(expectedResult);
}
static Stream<Arguments> getCoordinateBelow() {
Matchfield matchfield = new Matchfield(10);
return Stream.of(
Arguments.of("below from (5/5) - should be (5,4)", matchfield, new Coordinate(5, 5),
matchfield.getField(5, 4)),
Arguments.of("below from (5/0) - should be null", matchfield, new Coordinate(5, 0), null));
}
@Test
void testsetStateOverloaded() {
Matchfield matchfield = new Matchfield(10);
matchfield.createMatchfield();
int x = 3;
int y = 3;
matchfield.setState(new Coordinate(x, y), Coordinate.SHIP);
int result = matchfield.getState(x, y);
assertEquals(result, Coordinate.SHIP);
}
}

133
src/test/java/de/tims/fleetstorm/matchfield/MatchfieldShipTest.java
View File

@ -0,0 +1,133 @@
package de.tims.fleetstorm.matchfield;
import static org.junit.jupiter.api.Assertions.*;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.stream.Stream;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
class MatchfieldShipTest {
@ParameterizedTest(name = "ship was set on the correct positions")
@MethodSource("testShipPositioning")
void testMatchfieldShipSetHasCorrectPositions(String testName, int matchfieldSize, Coordinate coordinate,
int direction, int length, Coordinate[] coordinatesWithShip) {
Matchfield matchfield = new Matchfield(matchfieldSize);
matchfield.createMatchfield();
matchfield.setShip(coordinate, length, direction);
int shipSetCounter = 0;
for (Coordinate toCheckCoordinate : coordinatesWithShip) {
if (matchfield.getField(toCheckCoordinate).getState() == Coordinate.SHIP)
shipSetCounter++;
}
assertThat(shipSetCounter).describedAs(testName).isEqualTo(length);
}
static Stream<Arguments> testShipPositioning() {
Coordinate[] coordinatesWithShip00_2_0 = new Coordinate[] { new Coordinate(0, 0), new Coordinate(1, 0) };
Coordinate[] coordinatesWithShip01_3_0 = new Coordinate[] { new Coordinate(0, 1), new Coordinate(1, 1),
new Coordinate(2, 1) };
Coordinate[] coordinatesWithShip02_4_1 = new Coordinate[] { new Coordinate(0, 2), new Coordinate(0, 3),
new Coordinate(0, 4), new Coordinate(0, 5) };
return Stream.of(
Arguments.of("set ship from 0:0, length 2, direction 0", 10, new Coordinate(0, 0), 0, 2,
coordinatesWithShip00_2_0),
Arguments.of("set ship from 0:1, length 3, direction 0", 10, new Coordinate(0, 1), 0, 3,
coordinatesWithShip01_3_0),
Arguments.of("set ship from 0:2, length 4, direction 1", 10, new Coordinate(0, 2), 1, 4,
coordinatesWithShip02_4_1));
}
@ParameterizedTest(name = "ship positioning on invalid or valid coordinates")
@MethodSource("testShipPositioningFailed")
void testMatchfieldShipSetWithInvalidOrValidCoordinates(String testName, int matchfieldSize, Coordinate coordinate,
int direction, int length, boolean expectedResult) {
Matchfield matchfield = new Matchfield(matchfieldSize);
matchfield.createMatchfield();
boolean calculatedResult = matchfield.setShip(coordinate, length, direction);
if (expectedResult)
assertThat(calculatedResult).describedAs(testName).isEqualTo(true);
if (!expectedResult)
assertThat(calculatedResult).describedAs(testName).isEqualTo(false);
}
static Stream<Arguments> testShipPositioningFailed() {
return Stream.of(
Arguments.of("invalid ship position from 9:0, length 2, direction 0", 10, new Coordinate(9, 0), 0, 2,
false),
Arguments.of("valid ship position from 8:0, length 5, direction 1", 10, new Coordinate(9, 0), 1, 5,
true));
}
@Test
void testShipPositionAlreadySetWithShip() {
Matchfield matchfield = new Matchfield(10);
matchfield.createMatchfield();
matchfield.setShip(new Coordinate(0, 0), 5, 1);
assertThat(matchfield.setShip(new Coordinate(0, 1), 5, 1)).describedAs("set ship on coordinate with ship")
.isEqualTo(false);
assertThat(matchfield.setShip(new Coordinate(1, 1), 4, 0)).describedAs("set ship on coordinate without ship")
.isEqualTo(true);
assertThat(matchfield.setShip(new Coordinate(4, 1), 2, 1))
.describedAs("set second ship on coordinate without ship").isEqualTo(false);
}
@Test
void testIfAllShipsHitReturnsFalseWhenNoShipIsHit() {
Matchfield matchfield = new Matchfield(10);
matchfield.createMatchfield();
matchfield.setShip(new Coordinate(0, 0), 5, 1);
boolean calulatedResult = matchfield.areAllShipsHit();
assertFalse(calulatedResult);
}
@Test
void testIfAllShipsHitReturnsTrueWhenAllShipsAreHit() {
Matchfield matchfield = new Matchfield(10);
matchfield.createMatchfield();
matchfield.setShip(new Coordinate(0, 0), 5, 1);
matchfield.getField(0, 0).setState(Coordinate.HIT);
matchfield.getField(0, 1).setState(Coordinate.HIT);
matchfield.getField(0, 2).setState(Coordinate.HIT);
matchfield.getField(0, 3).setState(Coordinate.HIT);
matchfield.getField(0, 4).setState(Coordinate.HIT);
boolean calulatedResult = matchfield.areAllShipsHit();
assertTrue(calulatedResult);
}
@Test
void testIfAllShipsHitReturnsFalseWhenTwoShipsAreNotFullyHit() {
Matchfield matchfield = new Matchfield(10);
matchfield.createMatchfield();
matchfield.setShip(new Coordinate(0, 0), 5, 1);
matchfield.getField(0, 0).setState(Coordinate.HIT);
matchfield.getField(0, 1).setState(Coordinate.HIT);
matchfield.getField(0, 2).setState(Coordinate.HIT);
matchfield.getField(0, 3).setState(Coordinate.HIT);
matchfield.getField(0, 4).setState(Coordinate.HIT);
matchfield.setShip(new Coordinate(3, 4), 2, 0);
matchfield.getField(4, 4).setState(Coordinate.HIT);
boolean calulatedResult = matchfield.areAllShipsHit();
assertFalse(calulatedResult);
}
}
Write Preview
Loading…
Cancel
Save