/**

* @author Richard_Rivera
* CST 338 - Software Design
* Final Project - Strategy Game
*
*/
import java.util.*;

public class StrategyGame

{

public static void main(String[] args)

{
RedArmy cronus = new RedArmy("cronus",001);
RedArmy hyperion = new RedArmy("hyperion", 002);
BlueArmy zeus = new BlueArmy("white", 1, "zeus");
BlueArmy poseidon = new BlueArmy("blue", 2, "poseidon");

System.out.println("Blue army gods: " + BlueArmy.getTroopCount());

System.out.println("Red army titans: " + RedArmy.getTroopCount());

zeus.setMarchSpeed(10.0);
cronus.setMarchSpeed(12.0);

HashMap<String, List<Soldier>> army = new HashMap<>();

Soldier.addToUnit(army, zeus);
Soldier.addToUnit(army, cronus);
Soldier.addToUnit(army, poseidon);
Soldier.addToUnit(army, hyperion);

System.out.println(army);
Random rand = new Random();

for (String unit: army.keySet()) {

for (Soldier s: army.get(unit)) {
System.out.println(s);
System.out.println(s + " Marched " + s.march(10) + " meters");
for (String unit2: army.keySet()) {
for (Soldier u: army.get(unit2)) {
System.out.println(s.attack(u, rand.nextInt(20) + 1)?
"Hit!": "Miss!");
}
}
}
}
}

*************************************************************************
*************************************
/**
* Soldier class
 */
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

public abstract class Soldier

{
private String unit;
private int number;
public String armyKind;
public double marchSpeed;
public double marchModifier;

Soldier()
{
this.unit = "AA";
this.number = 0;
}

public Soldier(String unit, int number)

{
setUnit(unit);
setNumber(number);
marchSpeed = 6;
}

public static void addToUnit(HashMap<String, List<Soldier>> units,

Soldier s)
{
boolean value = false;
Set<Map.Entry<String, List<Soldier>>> soldier = units.entrySet();
Iterator<Map.Entry<String, List<Soldier>>> soldiers =
soldier.iterator();

while(soldiers.hasNext()) {
Map.Entry<String, List<Soldier>> unit = soldiers.next();
String key = unit.getKey();

if(s.getUnit().equals(key)) {
value = true;
List<Soldier> values = unit.getValue();
values.add(s);
unit.setValue(values);
}
}
if(!value) {
List<Soldier> t = new ArrayList<>();
t.add(s);
units.put(s.getUnit(), t);
}
}

public abstract double march(double duration);

public boolean attack(Soldier target, int roll) {

if (this == target || roll == 1) {

System.out.println(toString() + " is attatcking " +
getUnit().toString());
System.out.println(toString() + " rolled a " + roll);
System.out.println(toString() + " a solider is targeting
themselve...");
System.out.println(toString() + " rolled a " + roll + " and took
damage itself");
return true;
}
if (getArmyKind().equals("titans") &&
target.getArmyKind().equals("gods")) {
System.out.println("rolled out " + roll + " against the gods.");
if (roll > 10 && roll % 2 == 0) {
return true;
}
}
else if (getArmyKind().equals("titans") &&
target.getArmyKind().equals("titans")) {
System.out.println("No traitors are here");
return false;
}
else if (getArmyKind().equals("titans")) {
System.out.println("Acceptable Collateral Damage!");
if (roll > 10 && roll % 2 == 0) {
return true;
}
}
else if (getArmyKind().equals("gods") &&
target.getArmyKind().equals("gods")) {
System.out.println("Olympus spy");
return false;
}
else if (getArmyKind().equals("gods") &&
target.getArmyKind().equals("titans")) {
System.out.println("rolled a " + roll + " a against the titans");
if (roll > 5 || roll % 2 != 0) {
return true;
}
}
else if (getArmyKind().equals("gods")) {
System.out.println("The gods killed a mortal bystander");
if (roll > 18 && roll % 2 == 0) {
return true;
}
}
return false;
}
public String getUnit() {
return unit;
}

public void setUnit(String unit) {

this.unit = unit;
}

public int getNumber() {

return number;
}

public void setNumber(int number) {

this.number = number;
}

public String getArmyKind() {

return armyKind;
}

public void setArmyKind(String armyKind) {

this.armyKind = armyKind;
}

public double getMarchSpeed() {

return marchSpeed;
}

public void setMarchSpeed(double marchSpeed) {

this.marchSpeed = marchSpeed;
}

public boolean equals(Object o) {

if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Soldier soldier = (Soldier) o;
return getNumber() == soldier.getNumber() &&
Double.compare(soldier.getMarchSpeed(), getMarchSpeed()) == 0 &&
Double.compare(soldier.marchModifier, marchModifier) == 0 &&
Objects.equals(getUnit(), soldier.getUnit()) &&
Objects.equals(getArmyKind(), soldier.getArmyKind());
}
@Override
public int hashCode() {
return Objects.hash(getUnit(), getNumber(), getArmyKind(),
getMarchSpeed(), marchModifier);
}

@Override
public String toString() {
return getUnit() + getNumber() + ":";
}
}

*************************************************************************
*************************************************************************
*************************************************************************
*********************
/**
* RedArmy class
*/
import java.util.*;

public class RedArmy extends Soldier

{
private String name = "underworld";
private static int troopCount = 0;
public double marchModifier;

public RedArmy(String name, int count) {

super(name, count);
this.name = name;
setTroopCount(count + 1);
setArmyKind("Titans");
marchModifier = 1.45;
}

public double march(double duration) {

duration = duration * marchModifier * marchSpeed;
return duration;
}

public String getName() {

return name;
}

public void setName(String name) {

this.name = name;
}

public static int getTroopCount() {

return troopCount;
}

public static void setTroopCount(int troopCount) {

RedArmy.troopCount = troopCount;
}

public String toString() {

return name + "(" + super.toString() + ") a " + getArmyKind();
}
}
*************************************************************************
***************************************
/**
* BlueArmy class
*/

import java.util.*;

public class BlueArmy extends Soldier

{
private String name = "Olympus";
private static int troopCount = 0;

public BlueArmy(String armyKind, int counter, String nameCreate) {

setTroopCount(counter + 1);
setArmyKind("Gods");
this.marchModifier = 1.10;
this.name = armyKind;
}

public double march(double duration) {

duration = duration * marchModifier * marchSpeed;
return duration;
}

public String getName() {

return name;
}

public void setName(String name) {

this.name = name;
}

public static int getTroopCount() {

return troopCount;
}

public void setTroopCount(int troopCount) {

this.troopCount = troopCount;
}

public String toString() {

return name + "(" + super.toString() + ") a " + getArmyKind();
}
}

*************************************************************************
*******************************
/**
* SoldierTest class
*/

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;

import java.util.HashMap;
import java.util.List;

import org.junit.Test;

public class SoldierTest

{

@Test
public void testAddToUnit() {
HashMap<String, List<Soldier>> units = new HashMap<>();
BlueArmy zeus = new BlueArmy("white", 1, "zeus");
RedArmy crius = new RedArmy("crius", 003);

assertFalse(units.containsKey(crius.getUnit()));
Soldier.addToUnit(units, crius);
assertTrue(units.containsKey(crius.getUnit()));

assertFalse(units.containsKey(zeus.getUnit()));
Soldier.addToUnit(units, zeus);
assertTrue(units.containsKey(zeus.getUnit()));
}

@Test
public void testAttack() {
BlueArmy zeus = new BlueArmy("white", 1, "zeus");
RedArmy crius = new RedArmy("crius", 003);

assertTrue(zeus.attack(zeus, 10));
assertTrue(crius.attack(zeus, 1));

assertTrue(zeus.attack(zeus, 12));
assertFalse(zeus.attack(zeus, 11));

assertFalse(crius.attack(new RedArmy("cronus", 001), 12));

assertFalse(zeus.attack(new BlueArmy("white", 1, "zeus"), 8));

assertTrue(zeus.attack(crius, 6));
assertTrue(zeus.attack(crius, 3));
assertTrue(zeus.attack(crius, 2));
}

@Test
public void testGetUnit() {
RedArmy crius = new RedArmy("crius", 003);
assertEquals("crius", crius.getUnit());
}

@Test
public void testSetUnit() {
 RedArmy crius = new RedArmy("crius", 003);
assertEquals("crius", crius.getUnit());
crius.setUnit("cronus");
assertEquals("cronus", crius.getUnit());
assertEquals("crius", crius.getUnit());
}

@Test
public void testGetNumber() {
BlueArmy hades = new BlueArmy("black", 3, "hades");
assertEquals(3, hades.getNumber());
}

@Test
public void testSetNumber() {
BlueArmy hades = new BlueArmy("black", 3, "hades");
assertEquals(3, hades.getNumber());
hades.setNumber(42);
assertEquals(42, hades.getNumber());
assertNotEquals(2, hades.getNumber());
}

@Test
public void testMarch() {
BlueArmy hades = new BlueArmy("red", 4, "hades");
RedArmy hyperion = new RedArmy("hyperion", 002);

assertEquals(Math.ceil(45.75), hades.march(15));
assertEquals(Math.floor(65.50), hyperion.march(15));
}

@Test
public void getTroopCount() {
for(int i = 0; i < 10; i++) {
if(i < 5) {
new RedArmy("hyperion", i);
} else {
new BlueArmy("red", i, "hades" + i);
}
}
assertEquals(5, RedArmy.getTroopCount());
assertEquals(5, BlueArmy.getTroopCount());
}
}

*************************************************************************
***********************************
Output:
Blue army gods: 3
Red army titans: 3
{AA=[white(AA0:) a Gods, blue(AA0:) a Gods],
hyperion=[hyperion(hyperion2:) a Titans], cronus=[cronus(cronus1:) a
Titans]}
white(AA0:) a Gods
white(AA0:) a Gods Marched 110.0 meters
white(AA0:) a Gods is attatcking AA
white(AA0:) a Gods rolled a 16
white(AA0:) a Gods a solider is targeting themselve...
white(AA0:) a Gods rolled a 16 and took damage itself
Hit!
Miss!
Miss!
Miss!
blue(AA0:) a Gods
blue(AA0:) a Gods Marched 0.0 meters
Miss!
blue(AA0:) a Gods is attatcking AA
blue(AA0:) a Gods rolled a 12
blue(AA0:) a Gods a solider is targeting themselve...
blue(AA0:) a Gods rolled a 12 and took damage itself
Hit!
Miss!
Miss!
hyperion(hyperion2:) a Titans
hyperion(hyperion2:) a Titans Marched 87.0 meters
Miss!
Miss!
hyperion(hyperion2:) a Titans is attatcking hyperion
hyperion(hyperion2:) a Titans rolled a 12
hyperion(hyperion2:) a Titans a solider is targeting themselve...
hyperion(hyperion2:) a Titans rolled a 12 and took damage itself
Hit!
Miss!
cronus(cronus1:) a Titans
cronus(cronus1:) a Titans Marched 174.0 meters
Miss!
Miss!
Miss!
cronus(cronus1:) a Titans is attatcking cronus
cronus(cronus1:) a Titans rolled a 19
cronus(cronus1:) a Titans a solider is targeting themselve...
cronus(cronus1:) a Titans rolled a 19 and took damage itself
Hit!