From 5f4683c45d8d91f98a4c96df55e4561663061be6 Mon Sep 17 00:00:00 2001
From: Tim <70119791+journich@users.noreply.github.com>
Date: Sat, 20 Feb 2021 13:29:14 +1030
Subject: [PATCH] Java version of Bombardment

---
 11 Bombardment/java/Bombardment.iml          |  11 +
 11 Bombardment/java/src/Bombardment.java     | 372 +++++++++++++++++++
 11 Bombardment/java/src/BombardmentGame.java |   8 +
 3 files changed, 391 insertions(+)
 create mode 100644 11 Bombardment/java/Bombardment.iml
 create mode 100644 11 Bombardment/java/src/Bombardment.java
 create mode 100644 11 Bombardment/java/src/BombardmentGame.java

diff --git a/11 Bombardment/java/Bombardment.iml b/11 Bombardment/java/Bombardment.iml
new file mode 100644
index 00000000..c90834f2
--- /dev/null
+++ b/11 Bombardment/java/Bombardment.iml	
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file
diff --git a/11 Bombardment/java/src/Bombardment.java b/11 Bombardment/java/src/Bombardment.java
new file mode 100644
index 00000000..06a3043c
--- /dev/null
+++ b/11 Bombardment/java/src/Bombardment.java	
@@ -0,0 +1,372 @@
+import java.util.HashSet;
+import java.util.Scanner;
+
+/**
+ * Game of Bombardment
+ *
+ * Based on the Basic game of Bombardment here
+ * https://github.com/coding-horror/basic-computer-games/blob/main/11%20Bombardment/bombardment.bas
+ *
+ * Note:  The idea was to create a version of this 1970's Basic game in Java, without introducing
+ *        new features - no additional text, error checking, etc has been added.
+ */
+public class Bombardment {
+
+    public static final int MAX_GRID_SIZE = 25;
+    public static final int PLATOONS = 4;
+
+    private enum GAME_STATE {
+        STARTING,
+        DRAW_BATTLEFIELD,
+        GET_PLAYER_CHOICES,
+        PLAYERS_TURN,
+        COMPUTER_TURN,
+        PLAYER_WON,
+        PLAYER_LOST,
+        GAME_OVER
+    }
+
+    private GAME_STATE gameState;
+
+    public static final String[] PLAYER_HIT_MESSAGES = { "ONE DOWN, THREE TO GO.",
+            "TWO DOWN, TWO TO GO.", "THREE DOWN, ONE TO GO." };
+
+    public static final String[] COMPUTER_HIT_MESSAGES = {"YOU HAVE ONLY THREE OUTPOSTS LEFT.",
+            "YOU HAVE ONLY TWO OUTPOSTS LEFT.", "YOU HAVE ONLY ONE OUTPOST LEFT." };
+
+    private HashSet<Integer> computersPlatoons;
+    private HashSet<Integer> playersPlatoons;
+
+    private HashSet<Integer> computersGuesses;
+
+    // Used for keyboard input
+    private final Scanner kbScanner;
+
+    public Bombardment() {
+
+        this.gameState = GAME_STATE.STARTING;
+
+        // Initialise kb scanner
+        kbScanner = new Scanner(System.in);
+    }
+
+    /**
+     * Main game loop
+     */
+    public void play() {
+
+        do {
+            switch (this.gameState) {
+
+                // Show an introduction the first time the game is played.
+                case STARTING:
+                    init();
+                    intro();
+                    this.gameState = GAME_STATE.DRAW_BATTLEFIELD;
+                    break;
+
+                // Enter the players name
+                case DRAW_BATTLEFIELD:
+                    drawBattlefield();
+                    this.gameState = GAME_STATE.GET_PLAYER_CHOICES;
+                    break;
+
+                // Get the players 4 locations for their platoons
+                case GET_PLAYER_CHOICES:
+                    String playerChoices = displayTextAndGetInput("WHAT ARE YOUR FOUR POSITIONS? ");
+
+                    // Store the 4 player choices that were entered separated with commas
+                    for(int i=0; i<PLATOONS; i++) {
+                        playersPlatoons.add(getDelimitedValue(playerChoices,i));
+                    }
+
+                    this.gameState = GAME_STATE.PLAYERS_TURN;
+                    break;
+
+                // Players turn to pick a location
+                case PLAYERS_TURN:
+
+                    int firePosition = getDelimitedValue(
+                            displayTextAndGetInput("WHERE DO YOU WISH TO FIRE YOUR MISSILE? "),0);
+
+                    if(didPlayerHitComputerPlatoon(firePosition)) {
+                        // Player hit a player platoon
+                        int hits = updatePlayerHits(firePosition);
+                        // How many hits has the player made?
+                        if(hits != PLATOONS) {
+                            showPlayerProgress(hits);
+                            this.gameState = GAME_STATE.COMPUTER_TURN;
+                        } else {
+                            // Player has obtained 4 hits, they win
+                            this.gameState = GAME_STATE.PLAYER_WON;
+                        }
+                    } else {
+                        // Player missed
+                        System.out.println("HA, HA YOU MISSED. MY TURN NOW:");
+                        System.out.println();
+                        this.gameState = GAME_STATE.COMPUTER_TURN;
+                    }
+
+                    break;
+
+                // Computers time to guess a location
+                case COMPUTER_TURN:
+
+                    // Computer takes a guess of a location
+                    int computerFirePosition = uniqueComputerGuess();
+                    if(didComputerHitPlayerPlatoon(computerFirePosition)) {
+                        // Computer hit a player platoon
+                        int hits = updateComputerHits(computerFirePosition);
+                        // How many hits has the computer made?
+                        if(hits != PLATOONS) {
+                            showComputerProgress(hits, computerFirePosition);
+                            this.gameState = GAME_STATE.PLAYERS_TURN;
+                        } else {
+                            // Computer has obtained 4 hits, they win
+                            System.out.println("YOU'RE DEAD. YOUR LAST OUTPOST WAS AT " + computerFirePosition
+                                    + ". HA, HA, HA.");
+                            this.gameState = GAME_STATE.PLAYER_LOST;
+                        }
+                    } else {
+                        // Computer missed
+                        System.out.println("I MISSED YOU, YOU DIRTY RAT. I PICKED " + computerFirePosition
+                                + ". YOUR TURN:");
+                        System.out.println();
+                        this.gameState = GAME_STATE.PLAYERS_TURN;
+                    }
+
+                    break;
+
+                // The player won
+                case PLAYER_WON:
+                    System.out.println("YOU GOT ME, I'M GOING FAST. BUT I'LL GET YOU WHEN");
+                    System.out.println("MY TRANSISTO&S RECUP%RA*E!");
+                    this.gameState = GAME_STATE.GAME_OVER;
+                    break;
+
+                case PLAYER_LOST:
+                    System.out.println("BETTER LUCK NEXT TIME.");
+                    this.gameState = GAME_STATE.GAME_OVER;
+                    break;
+
+                // GAME_OVER State does not specifically have a case
+            }
+        } while (this.gameState != GAME_STATE.GAME_OVER);
+    }
+
+    /**
+     * Calculate computer guess.  Make that the computer does not guess the same
+     * location twice
+     *
+     * @return  location of the computers guess that has not been guessed previously
+     */
+    private int uniqueComputerGuess() {
+
+        boolean validGuess = false;
+        int computerGuess;
+        do
+        {
+            computerGuess = randomNumber();
+
+            if(!computersGuesses.contains(computerGuess)) {
+                validGuess = true;
+            }
+        } while(!validGuess);
+
+        computersGuesses.add(computerGuess);
+
+        return computerGuess;
+    }
+
+    /**
+     * Create four unique platoons locations for the computer
+     * We are using a hashset which guarantees uniqueness so
+     * all we need to do is keep trying to add a random number
+     * until all four are in the hashset
+     *
+     * @return 4 locations of computers platoons
+     *
+     */
+    private HashSet<Integer> computersChosenPlatoons() {
+
+        // Initialise contents
+        HashSet<Integer> tempPlatoons = new HashSet<>();
+
+        boolean allPlatoonsAdded = false;
+
+        do {
+            tempPlatoons.add(randomNumber());
+
+            // All four created?
+            if(tempPlatoons.size() == PLATOONS) {
+                // Exit when we have created four
+                allPlatoonsAdded = true;
+            }
+
+        } while(!allPlatoonsAdded);
+
+        return tempPlatoons;
+    }
+    /**
+     * Shows a different message for each number of hits
+     *
+     * @param hits  total number of hits by player on computer
+     */
+    private void showPlayerProgress(int hits) {
+
+        System.out.println("YOU GOT ONE OF MY OUTPOSTS!");
+        showProgress(hits, PLAYER_HIT_MESSAGES);
+    }
+
+    /**
+     * Shows a different message for each number of hits
+     *
+     * @param hits  total number of hits by computer on player
+     */
+    private void showComputerProgress(int hits, int lastGuess) {
+
+        System.out.println("I GOT YOU. IT WON'T BE LONG NOW. POST " + lastGuess + " WAS HIT.");
+        showProgress(hits, COMPUTER_HIT_MESSAGES);
+    }
+
+    /**
+     * Prints a message from the passed array based on the value of hits
+
+     * @param hits - number of hits the player or computer has made
+     * @param messages - an array of string with messages
+     */
+    private void showProgress(int hits, String[] messages) {
+        System.out.println(messages[hits-1]);
+    }
+
+    /**
+     *
+     * Update a player hit - adds a hit the player made on the computers platoon.
+     * @param fireLocation - computer location that got hit
+     * @return number of hits the player has inflicted on the computer in total
+     */
+    private int updatePlayerHits(int fireLocation) {
+
+        // N.B. only removes if present, so its redundant to check if it exists first
+        this.computersPlatoons.remove(fireLocation);
+
+        // return number of hits in total
+        return PLATOONS - this.computersPlatoons.size();
+    }
+
+    /**
+     *
+     * Update a computer hit - adds a hit the computer made on the players platoon.
+     * @param fireLocation - player location that got hit
+     * @return number of hits the player has inflicted on the computer in total
+     */
+    private int updateComputerHits(int fireLocation) {
+
+        // N.B. only removes if present, so its redundant to check if it exists first
+        this.playersPlatoons.remove(fireLocation);
+
+        // return number of hits in total
+        return PLATOONS - this.playersPlatoons.size();
+    }
+
+    /**
+     * Determine if the player hit one of the computers platoons
+     *
+     * @param fireLocation the players choice of location to fire on
+     * @return true if a computer platoon was at that position
+     */
+    private boolean didPlayerHitComputerPlatoon(int fireLocation) {
+        return this.computersPlatoons.contains(fireLocation);
+    }
+
+    /**
+     * Determine if the computer hit one of the players platoons
+     *
+     * @param fireLocation the computers choice of location to fire on
+     * @return true if a players platoon was at that position
+     */
+    private boolean didComputerHitPlayerPlatoon(int fireLocation) {
+        return this.playersPlatoons.contains(fireLocation);
+    }
+
+    /**
+     * Draw the battlefield grid
+     *
+     */
+    private void drawBattlefield() {
+        for(int i=1; i<MAX_GRID_SIZE+1; i+= 5) {
+            System.out.printf("%-2s %-2s %-2s %-2s %-2s %n", i, i+1, i+2, i+3, i+4);
+        }
+    }
+
+    /**
+     * Basic information about the game
+     *
+     */
+    private void intro() {
+        System.out.println("BOMBARDMENT");
+        System.out.println("CREATIVE COMPUTING  MORRISTOWN, NEW JERSEY");
+        System.out.println();
+        System.out.println("YOU ARE ON A BATTLEFIELD WITH 4 PLATOONS AND YOU");
+        System.out.println("HAVE 25 OUTPOSTS AVAILABLE WHERE THEY MAY BE PLACED.");
+        System.out.println("YOU CAN ONLY PLACE ONE PLATOON AT ANY ONE OUTPOST.");
+        System.out.println("THE COMPUTER DOES THE SAME WITH ITS FOUR PLATOONS.");
+        System.out.println();
+        System.out.println("THE OBJECT OF THE GAME IS TO FIRE MISSILES AT THE");
+        System.out.println("OUTPOSTS OF THE COMPUTER.  IT WILL DO THE SAME TO YOU.");
+        System.out.println("THE ONE WHO DESTROYS ALL FOUR OF THE ENEMY'S PLATOONS");
+        System.out.println("FIRST IS THE WINNER.");
+        System.out.println();
+        System.out.println("GOOD LUCK... AND TELL US WHERE YOU WANT THE BODIES SENT!");
+        System.out.println();
+        System.out.println("TEAR OFF MATRIX AND USE IT TO CHECK OFF THE NUMBERS.");
+        System.out.println();
+        System.out.println();
+    }
+
+    private void init() {
+
+        // Create four locations for the computers platoons.
+        this.computersPlatoons = computersChosenPlatoons();
+
+        // Players platoons.
+        this.playersPlatoons = new HashSet<>();
+
+        this.computersGuesses = new HashSet<>();
+    }
+
+    /**
+     * Accepts a string delimited by comma's and returns the nth delimited
+     * value (starting at count 0).
+     *
+     * @param text - text with values separated by comma's
+     * @param pos  - which position to return a value for
+     * @return the int representation of the value
+     */
+    private int getDelimitedValue(String text, int pos) {
+        String[] tokens = text.split(",");
+        return Integer.parseInt(tokens[pos]);
+    }
+
+
+    /*
+     * Print a message on the screen, then accept input from Keyboard.
+     *
+     * @param text message to be displayed on screen.
+     * @return what was typed by the player.
+     */
+    private String displayTextAndGetInput(String text) {
+        System.out.print(text);
+        return kbScanner.next();
+    }
+
+    /**
+     * Generate random number
+     *
+     * @return random number
+     */
+    private int randomNumber() {
+        return (int) (Math.random()
+                * (MAX_GRID_SIZE) + 1);
+    }
+}
\ No newline at end of file
diff --git a/11 Bombardment/java/src/BombardmentGame.java b/11 Bombardment/java/src/BombardmentGame.java
new file mode 100644
index 00000000..31f0edfe
--- /dev/null
+++ b/11 Bombardment/java/src/BombardmentGame.java	
@@ -0,0 +1,8 @@
+public class BombardmentGame {
+
+    public static void main(String[] args) {
+
+        Bombardment bombardment = new Bombardment();
+        bombardment.play();
+    }
+}