https://git.spwbk.site/swatson/battleship-perl/raw/master/battleship.pl
___________________________________
#!/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++;

}

You are viewing proxied material from chate.io. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.