Initial recommit

battleship.pl

@@ -0,0 +1,882 @@
+#!/usr/bin/perl
+
+# TODO: More work on AI, make it smarter and less random
+# 	** Keep track of where it's already missed and whether or not opponent moves
+# TODO: Handle situation where player or AI can place ships that 'wrap' around the map, ie coordinates
+# 	like 20,21,22 which would place the end of a cruiser in the first row, and the next two sections of it
+# 	in the second row. This doesn't really break the game at all, but it does look weird on the map and doesn't seem
+# 	to be a mature implimentation if it exists
+# TODO: Handle the fact that player can input random coordinates so that they could potentially have 1 third
+# 	of a ship in 3 different coordinates, or just have a ship occupy 1 tile by entering the same coordinate 
+# TODO: 'Productionize' the code: error handling, more input sanitation, etc
+# 	** Optimze placement so we dont have to check it each time, ie check at placement
+# 	** Consolidate redundant subs
+# TODO: Improve readability, game play feel
+#
+# KNOWN BUGS:
+# TODO: &clearUnocTiles issue -- see sub comment
+# 	** Not sure this is really an issue, but leaving it here to remind myself anyways
+
+# Basic implimentation of 'battleship' to teach myself more about programming
+# I don't know the actual rules of the game, this is my stab at
+# something in the 'spirit' of it
+#
+# Player takes turns against computer trying to hit one of their ships.
+# Can only perform 1 action per turn:
+# 	- Move
+# 	- Attack
+#
+# Three types of ships:
+# 	* Cruiser 
+# 		- Hull Points: 2
+# 		- Size: 3x1
+# 		- Attack Power: 1
+# 	* Carrier 
+# 		- Hull Points: 3
+# 		- Size: 5x1
+# 		- Attack Power: 2
+# 	* Submarine 
+# 		- Hull Points: 1
+# 		- Size 2x1
+# 		- Attack Power: 3
+#
+# 5x5 map grid for each player
+# Cruiser = *
+# Carrier = @
+# Submarine = ~
+# Ocean/Empty Space = .
+
+use strict;
+use warnings;
+use lib "/home/swatson/Repos/battleship-perl";
+#use MapTools;
+use Term::ANSIColor qw(:constants);
+
+my $version = 0.1;
+if ( $ARGV[0] && $ARGV[0] =~ /version/ ) {
+	print "$version\n";
+	exit 0;
+}
+
+# Maps
+my %p1map;
+my %p2map;
+
+# Stats trackers
+my @p1Attacks;
+my @p2Attacks;
+
+# Ships - surely there is a better way to do this
+my %p1cruiser = ( 'hp' => '2', 'size' => '3', 'ap' => '1', 'loc' => '', 'sym' => '*', 'mc' => 0 );
+my %p1carrier = ( 'hp' => '3', 'size' => '5', 'ap' => '2', 'loc' => '', 'sym' => '@', 'mc' => 0 );
+my %p1subm    = ( 'hp' => '1', 'size' => '2', 'ap' => '3', 'loc' => '', 'sym' => '~', 'mc' => 0 );
+
+my %p1ships = ( 'cru' => \%p1cruiser, 'car' => \%p1carrier, 'subm' => \%p1subm );
+
+my %p2cruiser = ( 'hp' => '2', 'size' => '3', 'ap' => '1', 'loc' => '', 'sym' => '*', 'mc' => 0 );
+my %p2carrier = ( 'hp' => '3', 'size' => '5', 'ap' => '2', 'loc' => '', 'sym' => '@', 'mc' => 0 );
+my %p2subm    = ( 'hp' => '1', 'size' => '2', 'ap' => '3', 'loc' => '', 'sym' => '~', 'mc' => 0 );
+
+my %p2ships = ( 'cru' => \%p2cruiser, 'car' => \%p2carrier, 'subm' => \%p2subm );
+
+sub initMap {
+
+        foreach my $number ( 1 .. 50 ) {
+                
+		$p1map{$number} = ".";
+		$p2map{$number} = ".";
+	}
+
+}
+
+sub clearUnocTiles {
+
+	# Bug where sometimes after a ship is moved one of the old tiles it was on
+	# is not reset despite the &shipPosition function reporting that it is
+	# Thus far, I've been unable to figure out why that is happening, so
+	# for now am providing this function, which will check the location of all ships
+	# and reset any incorrect tiles for both the player and the AI
+	
+	my @p1usedTiles;
+	my @p2usedTiles;
+
+	# Get in use tiles for ship hashes
+	foreach my $ship ( keys %p1ships ) {
+
+		if ( ! $p1ships{$ship} ) {
+			next;
+		}
+		my $shipRef = $p1ships{$ship};
+		my $location = ${$shipRef}{loc};
+		my @inUseTiles = split(",", $location);
+		foreach my $iut ( @inUseTiles ) {
+			push(@p1usedTiles, $iut);
+		}
+	
+	}
+
+	# Clean the tiles
+	foreach my $key ( keys %p1map ) {
+		if ( grep { $_ eq $key } @p1usedTiles ) {
+			next;
+		} else {
+			$p1map{$key} = ".";
+		}
+	
+	}
+
+	# Now the same for the AI map
+	foreach my $ship ( keys %p2ships ) {
+	
+		if ( ! $p2ships{$ship} ) {
+			next;
+		}
+		my $shipRef = $p2ships{$ship};
+		my $location = ${$shipRef}{loc};
+		my @inUseTiles = split(",", $location);
+		foreach my $iut ( @inUseTiles ) {
+			push(@p2usedTiles, $iut);
+		}
+	
+	}
+
+	# Clean the tiles
+	foreach my $key ( keys %p2map ) {
+		if ( grep { $_ eq $key } @p2usedTiles ) {
+			next;
+		} else {
+			$p2map{$key} = ".";
+		}
+	}
+}
+
+sub printMap {
+
+        my $count = 1;
+        print "^ Player Map ^\n";
+        foreach my $key ( sort { $a <=> $b } keys %p1map ) {
+                # Probably a better way to do this
+                if ( $count != 10 && $count != 20 && $count != 30 && $count != 40 && $count != 50 ) {
+                        if ( $p1map{$key} eq "*" ) {
+                                print YELLOW, "$p1map{$key}", RESET;
+                        } elsif ( $p1map{$key} eq "@"  ) {
+                                print RED, "$p1map{$key}", RESET;
+                        } elsif ( $p1map{$key} eq "~"  ) {
+                                print CYAN, "$p1map{$key}", RESET;
+                        } else {
+                                print "$p1map{$key}";
+                        }
+                } else {
+                        if ( $p1map{$key} eq "*" ) {
+                                print YELLOW, "$p1map{$key}\n", RESET;
+                        } elsif ( $p1map{$key} eq "@"  ) {
+                                print RED, "$p1map{$key}\n", RESET;
+                        } elsif ( $p1map{$key} eq "~"  ) {
+                                print CYAN, "$p1map{$key}\n", RESET;
+                        } else {
+                                print "$p1map{$key}\n";
+                        }
+                }
+                $count++;
+
+        }
+
+}
+	
+sub printPlayerStats {
+
+	# Print stats from main turn menu
+
+	print "\n";
+
+	foreach my $key ( keys %p1ships ) {
+		my $shipHref = $p1ships{$key};
+		if ( ! defined $p1ships{$key} ) {
+			print MAGENTA, "^^^ Ship: $key ^^^ \n", RESET;
+			print RED, "| SUNK! | \n", RESET;
+		} else {
+			print MAGENTA, "^^^ Ship: $key ^^^ \n", RESET;
+			print RED, "| HP: ${$shipHref}{hp} | AP: ${$shipHref}{ap} | Location: ${$shipHref}{loc} |\n", RESET;
+		}
+	}
+
+	print MAGENTA, "Coordinates attacked since last AI move:\n", RESET;
+	my $atkArSize = scalar @p1Attacks;
+	if ( $atkArSize > 0 ) {
+		foreach my $coor ( @p1Attacks ) {
+			print RED, "$coor ", RESET;
+		}
+	} else {
+		print "No attacks since last AI move";
+	}
+
+	print "\n";
+
+}
+
+sub shipPosition {
+
+	# Map ship to position via grid mapping
+	#   1  2  3  4  5  6  7  8  9  10
+	#   .  .  .  .  .  .  .  .  .  .
+	#   11 12 13 14 15 16 17 18 19 20
+	#   .  .  .  .  .  .  .  .  .  .
+	#   Etc.
+	
+	# Function should recieve ship hashRef and new grid location as input
+	my $shipHref = shift;
+
+	my $newLocation = shift;
+	my $currentLocation = ${$shipHref}{loc};
+
+	my @currentLoc = split(/,/, $currentLocation);
+	my @newLoc = split(/,/, $newLocation);
+
+	# This ended up working better than old loop
+	&clearUnocTiles;
+	
+
+	# Now update new positon
+	foreach my $tile ( @newLoc ) {
+		$p1map{$tile} = ${$shipHref}{sym};
+	}
+
+	# Update shipHref with valid location
+	${$shipHref}{loc} = join(',', @newLoc);
+	
+	# Update move counter -- CANT DO THIS HERE AS WE USE THIS SUB IN INIT
+	# ${$shipHref}{mc} = 1;
+
+
+}
+
+# TODO: Consolidate with above sub
+sub AiShipPosition {
+
+	# Map ship to position via grid mapping
+	#   1  2  3  4  5  6  7  8  9  10
+	#   .  .  .  .  .  .  .  .  .  .
+	#   11 12 13 14 15 16 17 18 19 20
+	#   .  .  .  .  .  .  .  .  .  .
+	#   Etc.
+	
+	# Function should recieve ship hashRef and new grid location as input
+	my $shipHref = shift;
+
+	my $newLocation = shift;
+	my $currentLocation = ${$shipHref}{loc};
+
+	my @currentLoc = split(/,/, $currentLocation);
+	my @newLoc = split(/,/, $newLocation);
+
+	# This ended up working better than old loop
+	&clearUnocTiles;
+
+	# Now update new positon
+	foreach my $tile ( @newLoc ) {
+		$p2map{$tile} = ${$shipHref}{sym};
+	}
+
+	# Update shipHref with valid location
+	${$shipHref}{loc} = join(',', @newLoc);
+
+	# Update move counter -- CANT DO THIS HERE AS WE USE THIS SUB IN INIT
+	# ${$shipHref}{mc} = 1;
+
+
+}
+
+sub updateMap {
+
+	foreach my $key ( keys %p1ships ) {
+		my $shipHref = $p1ships{$key};
+		my @mapPoints = split(/,/, ${$shipHref}{loc});
+		foreach my $mpoint ( @mapPoints ) {
+			my $symbol = ${$shipHref}{sym};
+			$p1map{$mpoint} = $symbol;
+
+		}
+	}	
+	
+	foreach my $key ( keys %p2ships ) {
+		my $shipHref = $p2ships{$key};
+		my @mapPoints = split(/,/, ${$shipHref}{loc});
+		foreach my $mpoint ( @mapPoints ) {
+			my $symbol = ${$shipHref}{sym};
+			$p1map{$mpoint} = $symbol;
+		}
+	}
+}
+
+sub checkLocation {
+
+	# Given a set of coordinates, determine if they are already occupied
+	my $taken = 0;
+	my $coordinates = shift;
+	if ( $coordinates !~ /^[0-9]*,[0-9]*$/ && $coordinates !~ /^[0-9]*,[0-9]*,[0-9]*$/ && $coordinates !~ /^[0-9]*,[0-9]*,[0-9]*,[0-9]*,[0-9]*$/ ) {
+		print "These coordinates look incorrect, you shouldnt see this error...\n";
+		$taken = $taken + 1;
+	}
+
+	my @coors = split(/,/, $coordinates);
+	foreach my $coor ( @coors ) {
+		if ( $p1map{$coor} ne "." ) {
+			print "coordinate $coor contains $p1map{$coor}\n";
+			$taken = $taken + 1;
+		}
+	}
+
+	if ( $taken >= 1 ) {
+		return 1;
+	} else {
+		return 0;
+	}
+
+
+}
+
+sub placeShips {
+
+	while() {
+
+		# Init map at the top as failure will kick you back here
+		&initMap;
+
+		print "Where do you want to place your cruiser? : ";
+		my $cruLoc = <STDIN>;
+		chomp $cruLoc;
+		
+		###
+		### TODO : Not actually checking location on any of the below blocks
+		### For whatever reason, it doesn't work as expected, and return coordinates that
+		### are taken despite them being empty. I don't understand the behavior, and need to revisit this
+		###
+
+		if ( $cruLoc !~ /^[0-9]*,[0-9]*,[0-9]*$/ ) {
+			#|| ! eval &checkLocation($cruLoc) ) {
+			print "Input looks wrong, or coordinates are taken, try again\n";
+			next;
+		}
+
+		print "Where do you want to place your carrier? : ";
+		my $carLoc = <STDIN>;
+		chomp $carLoc;
+		if ( $carLoc !~ /^[0-9]*,[0-9]*,[0-9]*,[0-9]*,[0-9]*$/ ) {
+			# || ! eval &checkLocation($carLoc) ) {
+			print "Input looks wrong, or coordiantes are taken, try again\n";
+			next;
+		}
+
+		print "Where do you want to place your submarine? : ";
+		my $submLoc = <STDIN>;
+		chomp $submLoc;
+		if ( $submLoc !~ /^[0-9]*,[0-9]*$/ ) {
+			# || ! eval &checkLocation($submLoc) ) {
+			print "Input looks wrong, I need 2 comma seperated coordinates, try again\n";
+			next;
+		} 
+
+		print "Coordinates are:\n";
+		print "Cruiser:   $cruLoc\n";
+		print "Carrier:   $carLoc\n";
+		print "Submarine: $submLoc\n";
+		print GREEN, "Type yes to confirm or type redo to redo: ", RESET;
+		my $confirm = <STDIN>;
+		chomp $confirm;
+		if ( $confirm eq "redo" ) {
+			next;
+		} elsif ( $confirm eq "yes" ) {
+
+			my $cruRef = $p1ships{cru};
+			my $carRef = $p1ships{car};
+			my $submRef = $p1ships{subm};
+
+			if ( ! eval &checkLocation($cruLoc) ) { 
+				&shipPosition($cruRef, $cruLoc);
+			} else {
+				print "Cruiser eval check failed\n";
+				&printMap;
+				next;
+			}
+			if ( ! eval &checkLocation($carLoc) ) {
+				&shipPosition($carRef, $carLoc);
+			} else {
+				print "Carrier eval check failed\n";
+				&printMap;
+				next;
+			}
+			if ( ! eval &checkLocation($submLoc) ) {
+				&shipPosition($submRef, $submLoc);
+			} else {
+				print "Submarine eval check failed\n";
+				&printMap;
+				next;
+			}
+
+			last;
+		}
+	}
+
+}
+
+sub randomLocation {
+
+	# Used by AI
+	# Pass in ship type and come up with a random location
+	my $shipType = shift;
+	my $size;
+	if ( $shipType eq "cru" ) { $size = 3; }
+	if ( $shipType eq "car" ) { $size = 5; }
+	if ( $shipType eq "subm" ) { $size = 2; }
+
+	# Where to randomly look in the map index ( keys %p2map ) - between 1 and 50
+	my @fakeMap = ( 1 .. 50 );
+	my $random_num = int(1 + rand(50 - 1));
+	# Need to use splice so that numbers are sequential
+	# TODO: Can still cause a situation where ships 'wrap' around edges of the map
+	my @newLocs = splice(@fakeMap, $random_num, $size);
+	# Make sure we don't end up with an empty/short location set
+	while ( scalar(@newLocs) < $size ) {
+		print "Re-rolling AI ship position due to conflict\n";
+		$random_num = int(1 + rand(50 - 1));
+		@newLocs = splice(@fakeMap, $random_num, $size);
+	}
+	
+	my $newLocs = join(",", @newLocs);
+
+	return $newLocs;
+
+}
+
+# TODO: This is stupid, main subroutine should be adjusted to take player map arg
+sub checkAILocation {
+	my $coor = shift;
+	my @coors = split(/,/, $coor);
+	my $taken = 0;
+	foreach my $coor ( @coors ) {
+		if ( $p2map{$coor} ne "." ) {
+			print "coordinate $coor contains $p2map{$coor}\n";
+			$taken = $taken + 1;
+		}
+	}
+	if ( $taken >= 1 ) {
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+
+sub initAI {
+
+	print MAGENTA, "Initialzing opponent..\n", RESET;
+	# AI equivelant of placeShips()
+	my $cruLoc = &randomLocation("cru");
+	my $carLoc = &randomLocation("car");
+	my $submLoc = &randomLocation("subm");
+	
+	#print "AI cru loc = $cruLoc\n";
+	#print "AI car loc = $carLoc\n";
+	#print "AI subm loc = $submLoc\n";
+
+	# Hash refs for ships
+	my $cruHref = $p2ships{cru};
+	my $carHref = $p2ships{car};
+	my $submHref = $p2ships{subm};
+
+	# Update Locations with new locations
+	if ( ! eval &checkAILocation($cruLoc) ) {
+		${$cruHref}{loc} = $cruLoc;
+	} else { print "Something went wrong with AI init, exiting\n"; exit 0; }
+	if ( ! eval &checkAILocation($carLoc) ) {
+		${$carHref}{loc} = $carLoc;
+	} else { print "Something went wrong with AI init, exiting\n"; exit 0; }
+	if ( ! eval &checkAILocation($carLoc) ) {
+		${$submHref}{loc} = $submLoc;
+	} else { print "Something went wrong with AI init, exiting\n"; exit 0; }
+
+	print "Done\n";
+
+}
+
+sub AiTurn {
+
+	# General subroute to have the AI do something after the player takes their turn
+	# Main AI turn logic lives here -- extremely basic to start
+	# Should not take any arguments
+
+	print MAGENTA, "Starting AI's turn\n", RESET;
+	sleep 1;
+	# This used to be 50/50, but testing has found having the AI
+	# constantly moving around makes the game pretty boring, so make it less likely the AI will move
+	my @outcomes = (0,1,2,3,4);
+	my $randomNum = int(rand(@outcomes));
+	#my $randomNum = 1;
+
+	# Get random ship key and href
+	my @availShips;
+	foreach my $key ( keys %p2ships ) {
+		if ( ! defined $p2ships{$key} ) {
+			next;
+		} else {
+			push(@availShips,$key);
+		}
+	}
+	my $randomShipKey = $availShips[rand @availShips];
+	#print "AI's random ship is : $randomShipKey\n";
+	my $shipHref = $p2ships{$randomShipKey};
+
+	# Make sure AI doesn't try to 'move' if it has no available moves left
+	print "Checking available AI moves\n";
+	my @availMovers;
+	foreach my $key ( keys %p2ships ) {
+		my $shipRef = $p2ships{$key};
+		if ( ! defined $p2ships{$key} ) {
+			next;
+		} elsif ( ${$shipRef}{mc}  == 1 ) {
+			next;
+		} else {
+			push(@availMovers, $key);
+		}
+	}
+
+	my $availM = scalar @availMovers;
+	if ( $availM == 0 ) {
+		#print "Bumping random number because we're out of moves\n";
+		$randomNum = 1;
+	}
+
+	if ( $randomNum == 0 ) {
+		# Move
+		print MAGENTA, "AI is moving!\n", RESET;
+
+		# Get new random location
+		my $newRandomLocation = &randomLocation($randomShipKey);
+		while ( eval &checkAILocation($newRandomLocation) ) {
+			#print "Conflict in AI random location, rerolling\n";
+			$newRandomLocation = &randomLocation($randomShipKey);
+		}
+		
+		#print "AI's new random location is : $newRandomLocation\n";
+
+		# Move ship to that location
+		if ( ! eval &checkAILocation($newRandomLocation) ) {
+			#print "Setting AI's new location to $newRandomLocation\n";
+			${$shipHref}{loc} = $newRandomLocation;
+			${$shipHref}{mc} = 1;
+			print "Updating/cleaning maps\n";
+			@p1Attacks = ("Coors: ");
+			&clearUnocTiles;
+		}
+	} else {
+		# Attack
+		# Same logic copy and pasted from player attack sub, with vars changed
+		print RED, "AI is attacking!\n", RESET;
+		my $randomCoor = int(1 + rand(50 - 1));
+		print RED, "AI's chosen attack coordinate is $randomCoor\n", RESET;
+		my $ap = ${$shipHref}{ap};
+		foreach my $key ( keys %p1ships ) {
+			if ( ! $p1ships{$key} ) {
+				next;
+			}
+			my $playerShipRef = $p1ships{$key};
+			my $playerShipLocation = ${$playerShipRef}{loc};
+			my @playerShipCoors = split(",", $playerShipLocation);
+			if ( grep { $_ eq $randomCoor } @playerShipCoors ) {
+				# Hit !
+				print RED, "Hit!\n", RESET;
+				print RED, "The AI hit your $key for $ap !\n", RESET;
+				# Deterime damage to hull
+				my $playerShipHp = ${$playerShipRef}{hp};
+				my $newPlayerHullValue = $playerShipHp - $ap;
+				if ( $newPlayerHullValue <= 0 ) {
+					print RED, "The AI sunk your $key !\n", RESET;
+					# Clear player map of ship and then set ship key to undef
+					my @sunkenLocation = split(",", ${$playerShipRef}{loc});
+					foreach my $tile (@sunkenLocation) {
+						$p1map{$tile} = ".";
+					}
+					$p1ships{$key} = undef;
+				} else {
+					${$playerShipRef}{hp} = $newPlayerHullValue;
+					print RED, "Your $key now has ${$playerShipRef}{hp} hp !\n", RESET;
+				}
+				
+				last;
+
+			} else {
+				# Miss
+				print GREEN, "AI Miss\n", RESET;
+			}
+		}
+
+	}
+	print "\n";
+
+}
+
+sub playerAttackAI {
+
+	# Perform attack against AI. Takes a coordinate, and ship hashRef as an arg
+	# atkCoor is the coordinate to attack
+	# $shipHref is a href to the ship that * is attacking *
+	#
+	# NOTE: This was a more generalized &attack subroutine, but perl
+	# didn't like me trying to iterate over a scalar hash dereference, so 
+	# figured seperate subroutes for each player attack would be the 'easiest' way to 
+	# do this, as opposed to building a working hash and then repopulating
+	# the real map/ships hashes with the updated values from the working hash
+	# ... open to suggestions for better ways to do this
+	#
+
+	my $atkCoor = shift;
+	my $shipHref = shift;
+
+	# Grab attack power
+	my $ap = ${$shipHref}{ap};
+
+	# Look at opponents ships and figure out where they are -- 
+	# if the supplied coordinate matches any ship location, start the 'hit' logic, else, miss
+	foreach my $key ( keys %p2ships ) {
+		if ( ! $p2ships{$key} ) {
+			next;
+		}
+		my $aiShipRef = $p2ships{$key};
+		my $aiShipLocation = ${$aiShipRef}{loc};
+		my @AiShipCoors = split(",", $aiShipLocation);
+		if ( grep { $_ eq $atkCoor } @AiShipCoors ) {
+			# Hit !
+			print GREEN, "Hit!\n", RESET;
+			print "You hit the AI's $key for $ap !\n";
+			# Deterime damage to hull
+			my $aiShipHp = ${$aiShipRef}{hp};
+			my $newAiHullValue = $aiShipHp - $ap;
+			if ( $newAiHullValue <= 0 ) {
+				print "You sunk the AI's $key !\n";
+				$p2ships{$key} = undef;
+			} else {
+				${$aiShipRef}{hp} = $newAiHullValue;
+				print "AI's $key now has ${$aiShipRef}{hp} hp !\n";
+			}
+
+			last;
+
+
+		} else {
+			# Miss
+			print RED, "Player Miss\n", RESET;
+		}
+	}
+
+
+}
+
+sub printMenu {
+
+	print <<EOF
+Swatson Battleship
+Type 'start','help', or 'quit'
+
+EOF
+
+}
+
+sub printHelp {
+	print <<EOF
+
+How To Play:
+This is a turn based battleship game. Your objective is to destory the AI ships.
+Each turn you can either attack with 1 ship or move 1 ship.
+To attack type: attack
+To move type: move
+To see stats type: stats
+Press Ctrl+C to exit any time.
+
+You have 3 ships:
+* Cruiser   - Hull Points 2, Size 3, Attack Power 1
+* Carrier   - Hull Points 3, Size 5, Attack Power 2
+* Submarine - Hull Points 1, Size 2, Attack Power 3
+
+Each turn you will be prompted to either move or attack.
+* When attacking, provide a coordinate number ( 1 - 50 ) to fire at
+* When moving, provide a comma seperated list of coordinates to move to
+* * For cruiser,   provide 3 coordinates
+* * For carrier,   provide 5 coordinates
+* * For submarine, provide 2 coordinates
+
+EOF
+
+}
+
+
+&initMap;
+&printMap;
+&updateMap;
+&printMap;
+
+# Menu loop
+while () {
+
+	my $count = 0;
+	if ( $count == 0 ) {
+		&printMenu;
+	}
+	print "Select option: ";
+	my $input = <STDIN>;
+	chomp $input;
+	if ( $input eq "quit" ) {
+		print "Quitting\n";
+		exit 0;
+	}
+	if ( $input eq "help" ) {
+		&printHelp;
+	}
+	if ( $input eq "start" ) {
+		my $gameCounter = 0;
+		my $aiCounter = 1;
+		while () {
+			print "\n\n";
+			# Main game loop
+			if ( $gameCounter == 0 ) {
+				&initAI;
+				&placeShips;
+				&clearUnocTiles;
+				$gameCounter++;
+				next;
+			} 
+
+			if ( ! defined $p2ships{cru} && ! defined $p2ships{subm} && ! defined $p2ships{car} ) {
+				print "You won! Exiting...\n";
+				exit 0;
+			} elsif ( ! defined $p1ships{cru} && ! defined $p1ships{subm} && ! defined $p1ships{car} ) {
+				print "The brain dead AI beat you! Exiting...\n";
+				exit 0;
+			}
+			print GREEN, "! TURN: $gameCounter !\n", RESET;
+			sleep 1;
+			my @opponentRemaining;
+			foreach my $key ( keys %p2ships ) { 
+				if ( defined $p2ships{$key} ) 
+					{ push(@opponentRemaining, $key) 
+				} 
+			}
+
+			# Make sure the AI doesn't take an additional turn if
+			# the player makes a typing mistake or calls the stats sub
+			if ( $aiCounter == $gameCounter ) {
+				&AiTurn;
+				$aiCounter++;
+			}
+
+			my $opShipsLeft = scalar @opponentRemaining;
+			print "\n";
+			print GREEN, "--AI has $opShipsLeft ships left--\n", RESET;
+			&printMap;
+			print "Move or attack: ";
+			my $gameInput = <STDIN>;
+			chomp $gameInput;
+			if ( $gameInput eq "quit" ) {
+				print "Are you sure? : ";
+				my $answer = <STDIN>;
+				chomp $answer;
+				if ( $answer eq "yes" ) {
+					exit 0;
+				} else {
+					next;
+				}
+			}
+			if ( $gameInput eq "move" ) {
+				print "What ship do you want to move? : ";
+				my $shipInput = <STDIN>;
+				chomp $shipInput;
+
+				my @validInputs;
+				foreach my $key ( keys %p1ships ) {
+					my $shipHref = $p1ships{$key};
+					my $moveCounter = ${$shipHref}{mc};
+					if ( ! defined $p1ships{$key} ) {
+						next;
+					} elsif ( $moveCounter == 1 ) {
+						next;
+					} else {
+						push(@validInputs,$key);
+					}
+				}
+				if ( ! grep { $_ eq $shipInput } @validInputs ) {
+					print "That input looks wrong, try again\n";
+					next;
+				} else {
+					print "New coordinates: ";
+					my $newCoor = <STDIN>;
+					chomp $newCoor;
+					if ( $shipInput eq "cru" && $newCoor !~ /^[0-9]*,[0-9]*,[0-9]*$/ ) {
+						print "Bad coordinates, try again\n";
+						next;
+					} elsif ( $shipInput eq "car" && $newCoor !~ /^[0-9]*,[0-9]*,[0-9]*,[0-9]*,[0-9]*$/ ) {
+						print "Bad coordiantes, try again\n";
+						next;
+					} elsif ( $shipInput eq "subm" && $newCoor !~ /^[0-9]*,[0-9]*$/ ) {
+						print "Bad coordinates, try again\n";
+						next;
+					}
+					if ( eval &checkLocation($newCoor) ) {
+						print "Coordinates occupied, try again\n";
+						next;
+					}
+
+					my $shipHref = $p1ships{$shipInput};
+					&shipPosition($shipHref, $newCoor);
+					${$shipHref}{mc} = 1;
+					&clearUnocTiles;
+					print "\n";
+
+				}
+
+			} elsif ( $gameInput eq "attack" ) {
+				print "What ship do you want to attack with? : ";
+				my $attackShip = <STDIN>;
+				chomp $attackShip;
+
+				my @validInputs;
+				foreach my $key ( keys %p1ships ) {
+					if ( ! defined $p1ships{$key} ) {
+						next;
+					} else {
+						push(@validInputs,$key);
+					}
+				}
+
+				if ( ! grep { $_ eq $attackShip } @validInputs ) {
+					print "That input looks wrong, try again\n";
+					next;
+				} else {
+					print "Select a single coordinate to attack: ";
+					my $atkCoor = <STDIN>;
+					chomp $atkCoor;
+					my @validCoors = ( 0 .. 50 );
+					if ( ! grep { $_ eq $atkCoor } @validCoors ) {
+						print "That doesn't look like a real coordinate, try again\n";
+						next;
+					} else {
+						&playerAttackAI($atkCoor,$p1ships{$attackShip});
+						push(@p1Attacks,$atkCoor);
+						print "\n";
+					}
+				}
+			} elsif ( $gameInput eq "stats" ) {
+				&printPlayerStats;
+				next;
+			} elsif ( $gameInput eq "help" ) {
+				&printHelp;
+				print "\n";
+				next;
+			} else {
+				next;
+			}
+			$gameCounter++;
+		}
+	}
+
+	$count++;
+
+}