PlayRockPaperScissorsGame 1.7.3 → 1.7.4

Sign up to get free protection for your applications and to get access to all the features.
Files changed (7) hide show
  1. checksums.yaml +4 -4
  2. data/bin/PlayRockPaperScissorsGame +69 -76
  3. data/bin/rps +72 -77
  4. data/lib/rps.rb +48 -53
  5. data/rps.gemspec +1 -1
  6. data/test/test_rps.rb +70 -75
  7. metadata +1 -1
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: f720e2c442cb0ac988fa41f46941db0b0a3290f4
4
- data.tar.gz: eed0321a0f3073909de6fe0c925e0c5309d59fbc
3
+ metadata.gz: 2fce8c420198c19a1b5cc1bb1326ab45e88064f1
4
+ data.tar.gz: 17cd148ee059571d6aae118dc1e76c6e61ba26fa
5
5
  SHA512:
6
- metadata.gz: 381771cd9ae8a77e36f235f9b83e0407aba21139e98ef743ef1ebbf038449b5948217537c8a0107882b223f96830d5ce7c6df6fbb3b694a5bd0540602c8a87e2
7
- data.tar.gz: 5a8d6d8a395102098d92cfa2c2581f59e50c207dc7b12d9fd8a291980be8ec950ac5ec41f560f62cc5951e1eebcdab857d654ec7a61cba7b586b9c291ab13c45
6
+ metadata.gz: f41bf9cf1afafa4c482a68c4343eb8074a04a29b50570454f735cea9c2fc215a616d90bcef458822253410fdf2fe37a422bd70258caa1de19e7d38b7858fea3a
7
+ data.tar.gz: 7e6e7e3ad9712f1d32c18ca3144c80f17cec9dda3c60444f227086f22c386f8d9e41ccc5eb97c73b51b5c84e0645ff1726bedb9bd2732710c44c14b279da8428
data/bin/PlayRockPaperScissorsGame CHANGED
@@ -15,89 +15,82 @@ class PlayRockPaperScissorsGame
15
15
  ColorizedString.colors;
16
16
  ColorizedString.modes;
17
17
 
18
- class RPS
18
+ module Constants
19
+ NTRY_TO_SYM = { 'p' => :PAPER, 'r' => :ROCK, 's' => :SCISSORS };
20
+ VALID_ENTRIES = NTRY_TO_SYM.keys;
21
+ COMPUTER_CHOICES = NTRY_TO_SYM.values;
22
+ WINNERS = [[:SCISSORS, :PAPER], [:PAPER, :ROCK], [:ROCK, :SCISSORS]]; # format: player choice, computer choice
23
+ LOSERS = WINNERS.map { |i,j| [j,i] }; # this will take the original WINNERS array and flip the symbols, thus returning a loss for the user/player
24
+ INIT_STRINGS = ["You are about to enter a rock-paper-scissors best of 3 match.", "Press the return/enter key to continue...", ""];
25
+ end;
19
26
 
20
- protected;
21
- module Constants
22
- NTRY_TO_SYM = { 'p' => :PAPER, 'r' => :ROCK, 's' => :SCISSORS };
23
- VALID_ENTRIES = NTRY_TO_SYM.keys;
24
- COMPUTER_CHOICES = NTRY_TO_SYM.values;
25
- WINNERS = [[:SCISSORS, :PAPER], [:PAPER, :ROCK], [:ROCK, :SCISSORS]]; # format: player choice, computer choice
26
- LOSERS = WINNERS.map { |i,j| [j,i] }; # this will take the original WINNERS array and flip the symbols, thus returning a loss for the user/player
27
- INIT_STRINGS = ["You are about to enter a rock-paper-scissors best of 3 match.", "Press the return/enter key to continue...", ""];
27
+ class << self
28
+ def continue(str1, str2, str3)
29
+ puts ColorizedString[str1].colorize(:color => :green);
30
+ print ColorizedString[str2].colorize(:color => :green);
31
+ gets;
32
+ puts ColorizedString[str3].colorize(:color => :green);
33
+ end;
34
+ end;
35
+ continue(Constants::INIT_STRINGS[0], Constants::INIT_STRINGS[1], Constants::INIT_STRINGS[2]);
36
+ def initialize
37
+ @player_score = @computer_score = @ties = 0;
38
+ end;
39
+ def play(winning_score)
40
+ while @player_score < winning_score && @computer_score < winning_score
41
+ puts ColorizedString["Player score: #{@player_score}, "].colorize(:blue) +
42
+ ColorizedString["Computer score: #{@computer_score}, Ties: #{@ties}"].colorize(:blue);
43
+ player = PrivateMethods.player_choice;
44
+ computer = Constants::COMPUTER_CHOICES.sample;
45
+ puts ColorizedString["\nPlayer chooses #{player.to_s.downcase}"].colorize(:blue);
46
+ puts ColorizedString["Computer chooses #{computer.to_s.downcase}"].colorize(:blue);
47
+ case PrivateMethods.player_outcome [player, computer]
48
+ when :WIN
49
+ puts ColorizedString["#{player.to_s.capitalize} beats #{computer.to_s.downcase}, player wins the round"].colorize(:red);
50
+ @player_score += 1;
51
+ when :LOSE
52
+ puts ColorizedString["#{computer.to_s.capitalize} beats #{player.to_s.downcase}, computer wins the round"].colorize(:red);
53
+ @computer_score += 1;
54
+ else
55
+ puts ColorizedString["Tie, choose again"].colorize(:red);
56
+ @ties += 1;
57
+ end;
28
58
  end;
29
-
30
- class RockPaperScissors
31
- class << self
32
- def continue(str1, str2, str3)
33
- puts ColorizedString[str1].colorize(:color => :green);
34
- print ColorizedString[str2].colorize(:color => :green);
35
- gets;
36
- puts ColorizedString[str3].colorize(:color => :green);
59
+ puts ColorizedString["\nFinal score: player: #{@player_score}, "].colorize(:blue) +
60
+ ColorizedString["computer: #{@computer_score} (ties: #{@ties})"].colorize(:blue);
61
+ case PrivateMethods.final_outcome(@player_score, @computer_score)
62
+ when :WIN
63
+ puts ColorizedString["Player wins!"].colorize(:red);
64
+ when :LOSE
65
+ puts ColorizedString["Computer wins!"].colorize(:red);
66
+ else
67
+ puts ColorizedString["It's a tie!"].colorize(:red);
68
+ end;
69
+ gets;
70
+ end;
71
+ module PrivateMethods
72
+ class << self
73
+ def player_choice
74
+ loop do
75
+ print ColorizedString["Choose rock (r), paper (p) or scissors (s): "].colorize(:green);
76
+ choice = gets.chomp.downcase;
77
+ return Constants::NTRY_TO_SYM[choice] if Constants::NTRY_TO_SYM.key?(choice);
78
+ puts ColorizedString["That entry is invalid. Please re-enter."].colorize(:green);
37
79
  end;
38
80
  end;
39
- continue(Constants::INIT_STRINGS[0], Constants::INIT_STRINGS[1], Constants::INIT_STRINGS[2]);
40
- def initialize
41
- @player_score = @computer_score = @ties = 0;
81
+ def player_outcome(plays)
82
+ return :WIN if Constants::WINNERS.include?(plays);
83
+ return :LOSE if Constants::LOSERS.include?(plays);
84
+ return :TIE if (!:WIN || !:LOSE);
42
85
  end;
43
- def play(winning_score)
44
- while @player_score < winning_score && @computer_score < winning_score
45
- puts ColorizedString["Player score: #{@player_score}, "].colorize(:blue) +
46
- ColorizedString["Computer score: #{@computer_score}, Ties: #{@ties}"].colorize(:blue);
47
- player = PrivateMethods.player_choice;
48
- computer = Constants::COMPUTER_CHOICES.sample;
49
- puts ColorizedString["\nPlayer chooses #{player.to_s.downcase}"].colorize(:blue);
50
- puts ColorizedString["Computer chooses #{computer.to_s.downcase}"].colorize(:blue);
51
- case PrivateMethods.player_outcome [player, computer]
52
- when :WIN
53
- puts ColorizedString["#{player.to_s.capitalize} beats #{computer.to_s.downcase}, player wins the round"].colorize(:red);
54
- @player_score += 1;
55
- when :LOSE
56
- puts ColorizedString["#{computer.to_s.capitalize} beats #{player.to_s.downcase}, computer wins the round"].colorize(:red);
57
- @computer_score += 1;
58
- else
59
- puts ColorizedString["Tie, choose again"].colorize(:red);
60
- @ties += 1;
61
- end;
62
- end;
63
- puts ColorizedString["\nFinal score: player: #{@player_score}, "].colorize(:blue) +
64
- ColorizedString["computer: #{@computer_score} (ties: #{@ties})"].colorize(:blue);
65
- case PrivateMethods.final_outcome(@player_score, @computer_score)
66
- when :WIN
67
- puts ColorizedString["Player wins!"].colorize(:red);
68
- when :LOSE
69
- puts ColorizedString["Computer wins!"].colorize(:red);
70
- else
71
- puts ColorizedString["It's a tie!"].colorize(:red);
72
- end;
73
- gets;
86
+ def final_outcome(pl, co)
87
+ return :WIN if pl > co;
88
+ return :LOSE if pl < co;
89
+ return :TIE if pl = co;
74
90
  end;
75
- private;
76
- module PrivateMethods
77
- class << self
78
- def player_choice
79
- loop do
80
- print ColorizedString["Choose rock (r), paper (p) or scissors (s): "].colorize(:green);
81
- choice = gets.chomp.downcase;
82
- return Constants::NTRY_TO_SYM[choice] if Constants::NTRY_TO_SYM.key?(choice);
83
- puts ColorizedString["That entry is invalid. Please re-enter."].colorize(:green);
84
- end;
85
- end;
86
- def player_outcome(plays)
87
- return :WIN if Constants::WINNERS.include?(plays);
88
- return :LOSE if Constants::LOSERS.include?(plays);
89
- return :TIE if (!:WIN || !:LOSE);
90
- end;
91
- def final_outcome(pl, co)
92
- return :WIN if pl > co;
93
- return :LOSE if pl < co;
94
- return :TIE if pl = co;
95
- end;
96
- end;
97
- end;
98
- end;
91
+ end;
99
92
  end;
100
93
  end;
101
94
 
102
- PlayRockPaperScissorsGame::RPS::RockPaperScissors.new.play(2); # best of 3
95
+ PlayRockPaperScissorsGame.new.play(2); # best of 3
103
96
 
data/bin/rps CHANGED
@@ -8,94 +8,89 @@
8
8
  |====================================|
9
9
  =end
10
10
 
11
+
11
12
  class PlayRockPaperScissorsGame
12
13
 
13
14
  require "colorized_string";
14
- ColorizedString.colors;
15
- ColorizedString.modes;
15
+ ColorizedString.colors;
16
+ ColorizedString.modes;
16
17
 
17
- class RPS
18
+ module Constants
19
+ NTRY_TO_SYM = { 'p' => :PAPER, 'r' => :ROCK, 's' => :SCISSORS };
20
+ VALID_ENTRIES = NTRY_TO_SYM.keys;
21
+ COMPUTER_CHOICES = NTRY_TO_SYM.values;
22
+ WINNERS = [[:SCISSORS, :PAPER], [:PAPER, :ROCK], [:ROCK, :SCISSORS]]; # format: player choice, computer choice
23
+ LOSERS = WINNERS.map { |i,j| [j,i] }; # this will take the original WINNERS array and flip the symbols, thus returning a loss for the user/player
24
+ INIT_STRINGS = ["You are about to enter a rock-paper-scissors best of 3 match.", "Press the return/enter key to continue...", ""];
25
+ end;
18
26
 
19
- protected;
20
- module Constants
21
- NTRY_TO_SYM = { 'p' => :PAPER, 'r' => :ROCK, 's' => :SCISSORS };
22
- VALID_ENTRIES = NTRY_TO_SYM.keys;
23
- COMPUTER_CHOICES = NTRY_TO_SYM.values;
24
- WINNERS = [[:SCISSORS, :PAPER], [:PAPER, :ROCK], [:ROCK, :SCISSORS]]; # format: player choice, computer choice
25
- LOSERS = WINNERS.map { |i,j| [j,i] }; # this will take the original WINNERS array and flip the symbols, thus returning a loss for the user/player
26
- INIT_STRINGS = ["You are about to enter a rock-paper-scissors best of 3 match.", "Press the return/enter key to continue...", ""];
27
+ class << self
28
+ def continue(str1, str2, str3)
29
+ puts ColorizedString[str1].colorize(:color => :green);
30
+ print ColorizedString[str2].colorize(:color => :green);
31
+ gets;
32
+ puts ColorizedString[str3].colorize(:color => :green);
33
+ end;
34
+ end;
35
+ continue(Constants::INIT_STRINGS[0], Constants::INIT_STRINGS[1], Constants::INIT_STRINGS[2]);
36
+ def initialize
37
+ @player_score = @computer_score = @ties = 0;
38
+ end;
39
+ def play(winning_score)
40
+ while @player_score < winning_score && @computer_score < winning_score
41
+ puts ColorizedString["Player score: #{@player_score}, "].colorize(:blue) +
42
+ ColorizedString["Computer score: #{@computer_score}, Ties: #{@ties}"].colorize(:blue);
43
+ player = PrivateMethods.player_choice;
44
+ computer = Constants::COMPUTER_CHOICES.sample;
45
+ puts ColorizedString["\nPlayer chooses #{player.to_s.downcase}"].colorize(:blue);
46
+ puts ColorizedString["Computer chooses #{computer.to_s.downcase}"].colorize(:blue);
47
+ case PrivateMethods.player_outcome [player, computer]
48
+ when :WIN
49
+ puts ColorizedString["#{player.to_s.capitalize} beats #{computer.to_s.downcase}, player wins the round"].colorize(:red);
50
+ @player_score += 1;
51
+ when :LOSE
52
+ puts ColorizedString["#{computer.to_s.capitalize} beats #{player.to_s.downcase}, computer wins the round"].colorize(:red);
53
+ @computer_score += 1;
54
+ else
55
+ puts ColorizedString["Tie, choose again"].colorize(:red);
56
+ @ties += 1;
57
+ end;
27
58
  end;
28
-
29
- class RockPaperScissors
30
- class << self
31
- def continue(str1, str2, str3)
32
- puts ColorizedString[str1].colorize(:color => :green);
33
- print ColorizedString[str2].colorize(:color => :green);
34
- gets;
35
- puts ColorizedString[str3].colorize(:color => :green);
59
+ puts ColorizedString["\nFinal score: player: #{@player_score}, "].colorize(:blue) +
60
+ ColorizedString["computer: #{@computer_score} (ties: #{@ties})"].colorize(:blue);
61
+ case PrivateMethods.final_outcome(@player_score, @computer_score)
62
+ when :WIN
63
+ puts ColorizedString["Player wins!"].colorize(:red);
64
+ when :LOSE
65
+ puts ColorizedString["Computer wins!"].colorize(:red);
66
+ else
67
+ puts ColorizedString["It's a tie!"].colorize(:red);
68
+ end;
69
+ gets;
70
+ end;
71
+ module PrivateMethods
72
+ class << self
73
+ def player_choice
74
+ loop do
75
+ print ColorizedString["Choose rock (r), paper (p) or scissors (s): "].colorize(:green);
76
+ choice = gets.chomp.downcase;
77
+ return Constants::NTRY_TO_SYM[choice] if Constants::NTRY_TO_SYM.key?(choice);
78
+ puts ColorizedString["That entry is invalid. Please re-enter."].colorize(:green);
36
79
  end;
37
80
  end;
38
- continue(Constants::INIT_STRINGS[0], Constants::INIT_STRINGS[1], Constants::INIT_STRINGS[2]);
39
- def initialize
40
- @player_score = @computer_score = @ties = 0;
81
+ def player_outcome(plays)
82
+ return :WIN if Constants::WINNERS.include?(plays);
83
+ return :LOSE if Constants::LOSERS.include?(plays);
84
+ return :TIE if (!:WIN || !:LOSE);
41
85
  end;
42
- def play(winning_score)
43
- while @player_score < winning_score && @computer_score < winning_score
44
- puts ColorizedString["Player score: #{@player_score}, "].colorize(:blue) +
45
- ColorizedString["Computer score: #{@computer_score}, Ties: #{@ties}"].colorize(:blue);
46
- player = PrivateMethods.player_choice;
47
- computer = Constants::COMPUTER_CHOICES.sample;
48
- puts ColorizedString["\nPlayer chooses #{player.to_s.downcase}"].colorize(:blue);
49
- puts ColorizedString["Computer chooses #{computer.to_s.downcase}"].colorize(:blue);
50
- case PrivateMethods.player_outcome [player, computer]
51
- when :WIN
52
- puts ColorizedString["#{player.to_s.capitalize} beats #{computer.to_s.downcase}, player wins the round"].colorize(:red);
53
- @player_score += 1;
54
- when :LOSE
55
- puts ColorizedString["#{computer.to_s.capitalize} beats #{player.to_s.downcase}, computer wins the round"].colorize(:red);
56
- @computer_score += 1;
57
- else
58
- puts ColorizedString["Tie, choose again"].colorize(:red);
59
- @ties += 1;
60
- end;
61
- end;
62
- puts ColorizedString["\nFinal score: player: #{@player_score}, "].colorize(:blue) +
63
- ColorizedString["computer: #{@computer_score} (ties: #{@ties})"].colorize(:blue);
64
- case PrivateMethods.final_outcome(@player_score, @computer_score)
65
- when :WIN
66
- puts ColorizedString["Player wins!"].colorize(:red);
67
- when :LOSE
68
- puts ColorizedString["Computer wins!"].colorize(:red);
69
- else
70
- puts ColorizedString["It's a tie!"].colorize(:red);
71
- end;
72
- gets;
86
+ def final_outcome(pl, co)
87
+ return :WIN if pl > co;
88
+ return :LOSE if pl < co;
89
+ return :TIE if pl = co;
73
90
  end;
74
- private;
75
- module PrivateMethods
76
- class << self
77
- def player_choice
78
- loop do
79
- print ColorizedString["Choose rock (r), paper (p) or scissors (s): "].colorize(:green);
80
- choice = gets.chomp.downcase;
81
- return Constants::NTRY_TO_SYM[choice] if Constants::NTRY_TO_SYM.key?(choice);
82
- puts ColorizedString["That entry is invalid. Please re-enter"].colorize(:green);
83
- end;
84
- end;
85
- def player_outcome(plays)
86
- return :WIN if Constants::WINNERS.include?(plays);
87
- return :LOSE if Constants::LOSERS.include?(plays);
88
- return :TIE if (!:WIN || !:LOSE);
89
- end;
90
- def final_outcome(pl, co)
91
- return :WIN if pl > co;
92
- return :LOSE if pl < co;
93
- return :TIE if pl = co;
94
- end;
95
- end;
96
- end;
97
91
  end;
98
92
  end;
99
93
  end;
100
94
 
101
- PlayRockPaperScissorsGame::RPS::RockPaperScissors.new.play(2); # best of 3
95
+ PlayRockPaperScissorsGame.new.play(2); # best of 3
96
+
data/lib/rps.rb CHANGED
@@ -12,60 +12,55 @@ class PlayRockPaperScissorsGame
12
12
  ColorizedString.colors;
13
13
  ColorizedString.modes;
14
14
 
15
- class RPS
16
- protected;
17
- require "ref/Constants.rb";
15
+ require "ref/Constants.rb";
18
16
 
19
- class RockPaperScissors
20
- class << self
21
- def continue(str1, str2, str3)
22
- puts ColorizedString[str1].colorize(:color => :green);
23
- print ColorizedString[str2].colorize(:color => :green);
24
- gets;
25
- puts ColorizedString[str3].colorize(:color => :green);
26
- end;
27
- end;
28
- continue(Constants::INIT_STRINGS[0], Constants::INIT_STRINGS[1], Constants::INIT_STRINGS[2]);
29
- def initialize
30
- @player_score = @computer_score = @ties = 0;
31
- end;
32
- def play(winning_score)
33
- while @player_score < winning_score && @computer_score < winning_score
34
- puts ColorizedString["Player score: #{@player_score}, "].colorize(:blue) +
35
- ColorizedString["Computer score: #{@computer_score}, Ties: #{@ties}"].colorize(:blue);
36
- player = PrivateMethods.player_choice;
37
- computer = Constants::COMPUTER_CHOICES.sample;
38
- puts ColorizedString["\nPlayer chooses #{player.to_s.downcase}"].colorize(:blue);
39
- puts ColorizedString["Computer chooses #{computer.to_s.downcase}"].colorize(:blue);
40
- case PrivateMethods.player_outcome [player, computer]
41
- when :WIN
42
- puts ColorizedString["#{player.to_s.capitalize} beats #{computer.to_s.downcase}, player wins the round"].colorize(:red);
43
- @player_score += 1;
44
- when :LOSE
45
- puts ColorizedString["#{computer.to_s.capitalize} beats #{player.to_s.downcase}, computer wins the round"].colorize(:red);
46
- @computer_score += 1;
47
- else
48
- puts ColorizedString["Tie, choose again"].colorize(:red);
49
- @ties += 1;
50
- end;
51
- end;
52
- puts ColorizedString["\nFinal score: player: #{@player_score}, "].colorize(:blue) +
53
- ColorizedString["computer: #{@computer_score} (ties: #{@ties})"].colorize(:blue);
54
- case PrivateMethods.final_outcome(@player_score, @computer_score)
55
- when :WIN
56
- puts ColorizedString["Player wins!"].colorize(:red);
57
- when :LOSE
58
- puts ColorizedString["Computer wins!"].colorize(:red);
59
- else
60
- puts ColorizedString["It's a tie!"].colorize(:red);
61
- end;
62
- gets;
63
- end;
64
- private;
65
- require "ref/PrivateMethods.rb";
17
+ class << self
18
+ def continue(str1, str2, str3)
19
+ puts ColorizedString[str1].colorize(:color => :green);
20
+ print ColorizedString[str2].colorize(:color => :green);
21
+ gets;
22
+ puts ColorizedString[str3].colorize(:color => :green);
23
+ end;
24
+ end;
25
+ continue(Constants::INIT_STRINGS[0], Constants::INIT_STRINGS[1], Constants::INIT_STRINGS[2]);
26
+ def initialize
27
+ @player_score = @computer_score = @ties = 0;
28
+ end;
29
+ def play(winning_score)
30
+ while @player_score < winning_score && @computer_score < winning_score
31
+ puts ColorizedString["Player score: #{@player_score}, "].colorize(:blue) +
32
+ ColorizedString["Computer score: #{@computer_score}, Ties: #{@ties}"].colorize(:blue);
33
+ player = PrivateMethods.player_choice;
34
+ computer = Constants::COMPUTER_CHOICES.sample;
35
+ puts ColorizedString["\nPlayer chooses #{player.to_s.downcase}"].colorize(:blue);
36
+ puts ColorizedString["Computer chooses #{computer.to_s.downcase}"].colorize(:blue);
37
+ case PrivateMethods.player_outcome [player, computer]
38
+ when :WIN
39
+ puts ColorizedString["#{player.to_s.capitalize} beats #{computer.to_s.downcase}, player wins the round"].colorize(:red);
40
+ @player_score += 1;
41
+ when :LOSE
42
+ puts ColorizedString["#{computer.to_s.capitalize} beats #{player.to_s.downcase}, computer wins the round"].colorize(:red);
43
+ @computer_score += 1;
44
+ else
45
+ puts ColorizedString["Tie, choose again"].colorize(:red);
46
+ @ties += 1;
47
+ end;
66
48
  end;
67
- end;
68
- end;
49
+ puts ColorizedString["\nFinal score: player: #{@player_score}, "].colorize(:blue) +
50
+ ColorizedString["computer: #{@computer_score} (ties: #{@ties})"].colorize(:blue);
51
+ case PrivateMethods.final_outcome(@player_score, @computer_score)
52
+ when :WIN
53
+ puts ColorizedString["Player wins!"].colorize(:red);
54
+ when :LOSE
55
+ puts ColorizedString["Computer wins!"].colorize(:red);
56
+ else
57
+ puts ColorizedString["It's a tie!"].colorize(:red);
58
+ end;
59
+ gets;
60
+ end;
61
+ require "ref/PrivateMethods.rb";
62
+ end;
69
63
 
70
- PlayRockPaperScissorsGame::RPS::RockPaperScissors.new.play(2); # best of 3
64
+
65
+ PlayRockPaperScissorsGame.new.play(2); # best of 3
71
66
 
data/rps.gemspec CHANGED
@@ -1,6 +1,6 @@
1
1
  Gem::Specification.new do |spec|
2
2
  spec.name = "PlayRockPaperScissorsGame"
3
- spec.version = "1.7.3"
3
+ spec.version = "1.7.4"
4
4
  spec.date = "2017-04-01"
5
5
  spec.summary = "A Rock Paper Scissors Ruby Gem"
6
6
  spec.description = "A Ruby-programmed rock paper scissors game. To install: gem install PlayRockPaperScissorsGame; To run: rps; or: PlayRockPaperScissorsGame; For issues: https://github.com/bag3318/RockPaperScissors/issues"
data/test/test_rps.rb CHANGED
@@ -6,93 +6,88 @@
6
6
  |====================================|
7
7
  =end
8
8
 
9
- class Test
9
+ class RakeTest
10
10
 
11
11
  require "colorized_string";
12
12
  ColorizedString.colors;
13
13
  ColorizedString.modes;
14
14
 
15
- class Rake < Test
16
- protected;
17
- module Constants
18
- NTRY_TO_SYM = { 'p' => :PAPER, 'r' => :ROCK, 's' => :SCISSORS };
19
- VALID_ENTRIES = NTRY_TO_SYM.keys;
20
- COMPUTER_CHOICES = NTRY_TO_SYM.values;
21
- WINNERS = [[:SCISSORS, :PAPER], [:PAPER, :ROCK], [:ROCK, :SCISSORS]]; # format: player choice, computer choice
22
- LOSERS = WINNERS.map { |i,j| [j,i] }; # this will take the original WINNERS array and flip the symbols, thus returning a loss for the user/player
23
- INIT_STRINGS = ["You are about to enter a rock-paper-scissors best of 3 match.", "Press the return/enter key to continue...", ""];
15
+ module Constants
16
+ NTRY_TO_SYM = { 'p' => :PAPER, 'r' => :ROCK, 's' => :SCISSORS };
17
+ VALID_ENTRIES = NTRY_TO_SYM.keys;
18
+ COMPUTER_CHOICES = NTRY_TO_SYM.values;
19
+ WINNERS = [[:SCISSORS, :PAPER], [:PAPER, :ROCK], [:ROCK, :SCISSORS]]; # format: player choice, computer choice
20
+ LOSERS = WINNERS.map { |i,j| [j,i] }; # this will take the original WINNERS array and flip the symbols, thus returning a loss for the user/player
21
+ INIT_STRINGS = ["You are about to enter a rock-paper-scissors best of 3 match.", "Press the return/enter key to continue...", ""];
22
+ end;
23
+
24
+ class << self
25
+ def continue(str1, str2, str3)
26
+ puts ColorizedString[str1].colorize(:color => :green);
27
+ print ColorizedString[str2].colorize(:color => :green);
28
+ gets;
29
+ puts ColorizedString[str3].colorize(:color => :green);
30
+ end;
31
+ end;
32
+ continue(Constants::INIT_STRINGS[0], Constants::INIT_STRINGS[1], Constants::INIT_STRINGS[2]);
33
+ def initialize
34
+ @player_score = @computer_score = @ties = 0;
35
+ end;
36
+ def testPlay(winning_score)
37
+ while @player_score < winning_score && @computer_score < winning_score
38
+ puts ColorizedString["Player score: #{@player_score}, "].colorize(:blue) +
39
+ ColorizedString["Computer score: #{@computer_score}, Ties: #{@ties}"].colorize(:blue);
40
+ player = PrivateMethods.player_choice;
41
+ computer = Constants::COMPUTER_CHOICES.sample;
42
+ puts ColorizedString["\nPlayer chooses #{player.to_s.downcase}"].colorize(:blue);
43
+ puts ColorizedString["Computer chooses #{computer.to_s.downcase}"].colorize(:blue);
44
+ case PrivateMethods.player_outcome [player, computer]
45
+ when :WIN
46
+ puts ColorizedString["#{player.to_s.capitalize} beats #{computer.to_s.downcase}, player wins the round"].colorize(:red);
47
+ @player_score += 1;
48
+ when :LOSE
49
+ puts ColorizedString["#{computer.to_s.capitalize} beats #{player.to_s.downcase}, computer wins the round"].colorize(:red);
50
+ @computer_score += 1;
51
+ else
52
+ puts ColorizedString["Tie, choose again"].colorize(:red);
53
+ @ties += 1;
54
+ end;
24
55
  end;
25
- class RockPaperScissorsTest
26
- class << self
27
- def continue(str1, str2, str3)
28
- puts ColorizedString[str1].colorize(:color => :green);
29
- print ColorizedString[str2].colorize(:color => :green);
30
- gets;
31
- puts ColorizedString[str3].colorize(:color => :green);
56
+ puts ColorizedString["\nFinal score: player: #{@player_score}, "].colorize(:blue) +
57
+ ColorizedString["computer: #{@computer_score} (ties: #{@ties})"].colorize(:blue);
58
+ case PrivateMethods.final_outcome(@player_score, @computer_score)
59
+ when :WIN
60
+ puts ColorizedString["Player wins!"].colorize(:red);
61
+ when :LOSE
62
+ puts ColorizedString["Computer wins!"].colorize(:red);
63
+ else
64
+ puts ColorizedString["It's a tie!"].colorize(:red);
65
+ end;
66
+ gets;
67
+ end;
68
+ module PrivateMethods
69
+ class << self
70
+ def player_choice
71
+ loop do
72
+ print ColorizedString["Choose rock (r), paper (p) or scissors (s): "].colorize(:green);
73
+ choice = gets.chomp.downcase;
74
+ return Constants::NTRY_TO_SYM[choice] if Constants::NTRY_TO_SYM.key?(choice);
75
+ puts ColorizedString["That entry is invalid. Please re-enter"].colorize(:green);
32
76
  end;
33
77
  end;
34
- continue(Constants::INIT_STRINGS[0], Constants::INIT_STRINGS[1], Constants::INIT_STRINGS[2]);
35
- def initialize
36
- @player_score = @computer_score = @ties = 0;
78
+ def player_outcome(plays)
79
+ return :WIN if Constants::WINNERS.include?(plays);
80
+ return :LOSE if Constants::LOSERS.include?(plays);
81
+ return :TIE if !:WIN | !:LOSE;
37
82
  end;
38
- def testPlay(winning_score)
39
- while @player_score < winning_score && @computer_score < winning_score
40
- puts ColorizedString["Player score: #{@player_score}, "].colorize(:blue) +
41
- ColorizedString["Computer score: #{@computer_score}, Ties: #{@ties}"].colorize(:blue);
42
- player = PrivateMethods.player_choice;
43
- computer = Constants::COMPUTER_CHOICES.sample;
44
- puts ColorizedString["\nPlayer chooses #{player.to_s.downcase}"].colorize(:blue);
45
- puts ColorizedString["Computer chooses #{computer.to_s.downcase}"].colorize(:blue);
46
- case PrivateMethods.player_outcome [player, computer]
47
- when :WIN
48
- puts ColorizedString["#{player.to_s.capitalize} beats #{computer.to_s.downcase}, player wins the round"].colorize(:red);
49
- @player_score += 1;
50
- when :LOSE
51
- puts ColorizedString["#{computer.to_s.capitalize} beats #{player.to_s.downcase}, computer wins the round"].colorize(:red);
52
- @computer_score += 1;
53
- else
54
- puts ColorizedString["Tie, choose again"].colorize(:red);
55
- @ties += 1;
56
- end;
57
- end;
58
- puts ColorizedString["\nFinal score: player: #{@player_score}, "].colorize(:blue) +
59
- ColorizedString["computer: #{@computer_score} (ties: #{@ties})"].colorize(:blue);
60
- case PrivateMethods.final_outcome(@player_score, @computer_score)
61
- when :WIN
62
- puts ColorizedString["Player wins!"].colorize(:red);
63
- when :LOSE
64
- puts ColorizedString["Computer wins!"].colorize(:red);
65
- else
66
- puts ColorizedString["It's a tie!"].colorize(:red);
67
- end;
68
- gets;
83
+ def final_outcome(pl, co)
84
+ return :WIN if pl > co;
85
+ return :LOSE if pl < co;
86
+ return :TIE if pl = co;
69
87
  end;
70
- private;
71
- module PrivateMethods
72
- class << self
73
- def player_choice
74
- loop do
75
- print ColorizedString["Choose rock (r), paper (p) or scissors (s): "].colorize(:green);
76
- choice = gets.chomp.downcase;
77
- return Constants::NTRY_TO_SYM[choice] if Constants::NTRY_TO_SYM.key?(choice);
78
- puts ColorizedString["That entry is invalid. Please re-enter"].colorize(:green);
79
- end;
80
- end;
81
- def player_outcome(plays)
82
- return :WIN if Constants::WINNERS.include?(plays);
83
- return :LOSE if Constants::LOSERS.include?(plays);
84
- return :TIE if !:WIN | !:LOSE;
85
- end;
86
- def final_outcome(pl, co)
87
- return :WIN if pl > co;
88
- return :LOSE if pl < co;
89
- return :TIE if pl = co;
90
- end;
91
- end;
92
- end;
93
88
  end;
94
89
  end;
95
90
  end;
96
91
 
97
- Test::Rake::RockPaperScissorsTest.new.testPlay(2); # best of 3
92
+ RakeTest.new.testPlay(2); # best of 3
98
93
 
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: PlayRockPaperScissorsGame
3
3
  version: !ruby/object:Gem::Version
4
- version: 1.7.3
4
+ version: 1.7.4
5
5
  platform: ruby
6
6
  authors:
7
7
  - bag3318