symbol-holic 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f7ba03bfbf0a27d6d8529ea8f6c7538f821c9ca7b08328fd9dca2de0ac8d803c
+  data.tar.gz: 7acd1c5ad2ebb6ab5869d6091687129d47d7df5e98bf2848a6c0c4678c294d26
+SHA512:
+  metadata.gz: 5332ec3c505c5270194f07beef3d9324756f06511024e23b660780de4867ca20804150963b239e21907865581a9752c4f1e1a9aaedffc99a64cdb6572e4bda5a
+  data.tar.gz: 5c3efa0b5c6f589de8cac9255484efd7aa82bab433556ade8208068ad8dce0820bbf16631cf655d29c181017b6d14c66700c7a5e6129fd4bb6de6d12c146183c

data/bin/symbol_holic

@@ -0,0 +1,40 @@
+#!/usr/bin/ruby
+require 'optparse'
+require_relative '../lib/menu'
+require_relative '../lib/typing_statistics'
+
+# create an instance to display the menu
+@symbolic = Menu.new
+
+# Display the menu if there in no arguments passed to the command-line
+@symbolic.display_menu if ARGV.empty?
+
+# Set the options for the OptionParser
+parser = OptionParser.new do |opts|
+  # Print banner for users
+  opts.banner = 'Welcome to Symbol-holic! To run the program type: symbolic [options]'
+  # If user passes in -h or --help then display the help menu
+  opts.on('-h', '--help', 'Display the help menu') do
+    puts opts
+    exit
+  end
+  # If user passes in -d or --display then display their statistics
+  opts.on('-d', '--display', 'Displays the users statistics to the terminal') do
+    @symbolic.display_statistics
+  end
+  # If user passes in -r or --run then start the standard typing game
+  opts.on('-r', '--run', 'Run the standard typing game') do
+    @symbolic.run_game
+  end
+  # If user passes in -t or --targeted then start the targeted typing game
+  opts.on('-t', '--targeted', 'Run the targeted typing game') do
+    @symbolic.targeted_game
+  end
+end
+
+# Execute the parser
+begin
+  parser.parse!
+rescue OptionParser::InvalidOption
+  puts 'That is an invalid option. Please type -h or --help to see a list of valid options.'
+end

data/lib/menu.rb

@@ -0,0 +1,90 @@
+require 'tty-prompt'
+require 'json'
+require 'colorize'
+require 'tty-pie'
+require_relative 'typing_game'
+require_relative 'typing_statistics'
+
+class Menu
+  def initialize
+    @typing_statistics = TypingStatistics.new
+  end
+
+  def menu_selection
+    # Choices for the user to select at the menu
+    menu_choices = [
+      { name: 'Start typing', value: '1' },
+      { name: 'Start targeted typing practice', value: '2' },
+      { name: 'Display your typing statistics', value: '3' },
+      { name: 'Reset your typing statistics', value: '4' },
+      { name: 'Exit', value: '5' }
+    ]
+    # TTY prompt with the menu choices, users can select one of these items
+    TTY::Prompt.new.select('Welcome to Symbol-holic!', menu_choices)
+  end
+
+  # This is the loop which runs and displays the menu to the user
+  def display_menu
+    loop do
+      choice = menu_selection.to_i
+      # Start typing game if user selects 'Start Typing'
+      if choice == 1
+        run_game
+      # Start the targeted typing game if user selects 'Start targeted typing practice'
+      elsif choice == 2
+        targeted_game
+      # Display the users statistics if they select 'Display your typing statistics'
+      elsif choice == 3
+        display_statistics
+      # Reset users statistics if they want to
+      elsif choice == 4
+        reset_statistics
+        # Exit the program if the user selects 'Exit'
+      elsif choice == 5
+        exit
+      end
+    end
+  end
+
+  # Added in for the command line arguments. We can call display_statistics on menu and not create a new TypingStatistics instance
+  def display_statistics
+    # If the user hasn't played a game yet, there is no need to display their typing scores
+    # It throws a JSON::ParserError as the file is empty and cannot be parsed
+    @typing_statistics.display_statistics
+    # If it is not empty, display their statistics
+    # If it is empty, display a prompt and let them choose another menu item
+  rescue JSON::ParserError
+    puts
+    puts "You haven't played a game yet. Please play one game and then try again.".colorize(:red)
+    puts
+  end
+
+  # Method for running the game
+  def run_game
+    @typing_game = TypingGame.new
+    @scores = @typing_game.run_game
+    # @scores eg {";"=>[1, 1, 51.413921326711545], ":"=>[1, 0, 79.55781654849564], "#"=>[2, 0, 164.6563074129133]}
+    @typing_statistics.statistics(@scores)
+  end
+
+  # Method for running the targeted typing game
+  def targeted_game
+    @typing_game = TypingGame.new
+    @scores = @typing_game.targeted_game
+    @typing_statistics.statistics(@scores)
+  end
+
+  # Menu option and TTY prompt for deleting all typing statistics
+  def reset_statistics
+    reset_choices = [
+      { name: 'Yes', value: '1' },
+      { name: 'No', value: '2' }
+    ]
+    choice = TTY::Prompt.new.select('Are you sure?', reset_choices).to_i
+    if choice == 1
+      @typing_statistics.wipe_file
+    elsif choice == 2
+      display_menu
+    end
+  end
+end

data/lib/statistics_helper.rb

@@ -0,0 +1,52 @@
+require_relative 'typing_statistics'
+
+module StatisticsHelper
+  # An array of all the symbols to be availble to the user
+  SYMBOLS = ['#', '`', '%', '&', '[', '{', '}', '(', '=', '*', ')', '+', ']', '!', '|', '-', '_', '@', '^', '/', '?', '<', '>', '$', '~', ';', ':'].freeze
+
+  # create a randomized array of symbols to guess
+  def self.create_symbol_array
+    randomized_array = []
+    # choose a random symbol out of the array and append to a new array.
+    15.times do
+      randomized_array << SYMBOLS.sample
+    end
+    # ensure that all elements in the array are unique
+    randomized_array
+  end
+
+  # This is a method to get the last 8 keys from the user to make into a new array for targeted practice
+  def self.create_targeted_array
+    worst_key_array = []
+    # Read the users statistics from the file, if there is no data in the file, create an object with 0 as values
+    begin
+      typing_statistics = TypingStatistics.new.read_statistics
+    rescue JSON::ParserError
+      typing_statistics = add_symbols_to_hash
+    end
+    # Get the last 8 hash elements (The users worst keys), by revesing hash and getting the first 8 elements
+    worst_keys = typing_statistics.reverse_each.to_h.first(8)
+    worst_keys.each do |key|
+      worst_key_array << key[0]
+    end
+    worst_key_array
+  end
+
+  # This method creates a randomized array with the worst 8 keys, all represented 3 times and shuffled.
+  def self.randomized_targeted_array
+    randomized_array = []
+    3.times do
+      randomized_array << create_targeted_array.shuffle
+    end
+    randomized_array.flatten
+  end
+
+  # This is called when there is no data stored in the JSON file. It outputs a hash with all the symbols and sets all values to 0
+  def self.add_symbols_to_hash
+    typing_statistics = {}
+    SYMBOLS.each do |item|
+      typing_statistics[item] = [0, 0, 0, 0, 0]
+    end
+    typing_statistics
+  end
+end

data/lib/typing_game.rb

@@ -0,0 +1,81 @@
+require 'colorize'
+require 'json'
+require 'io/console'
+require_relative 'statistics_helper'
+
+class TypingGame
+  # Bring in the StatisticsHelper module
+  # include StatisticsHelper
+
+  # Initialize the typing game
+  def initialize
+    @symbol_array = StatisticsHelper.create_symbol_array
+    @targeted_array = StatisticsHelper.randomized_targeted_array
+    @keypress_statistics = {}
+  end
+
+  # Run the stardard typing game
+  def run_game
+    # Print each item from the generated symbol array
+    @symbol_array.each do |item|
+      game_logic(item)
+    end
+    @keypress_statistics
+  end
+
+  # Run the targeted typing game
+  def targeted_game
+    @targeted_array.each do |item|
+      game_logic(item)
+    end
+    @keypress_statistics
+  end
+
+  # Calculate the words per minute of each keypress the user types
+  def words_per_min(first_time, second_time)
+    words_per_min = 60 / (second_time - first_time)
+    words_per_min
+  end
+
+  # Calculate the statistics to put into the hash, need to add the values each loop now that you can do multiple keys each run
+  def calculate_statistics(item, wrong_keys, words_per_min)
+    # If there is no value for the key in the hash, then add the current values in
+    if @keypress_statistics[item].nil?
+      # add the words per min, accuracy and 1 (for the amount of times the symbol has been shown)
+      @keypress_statistics[item] = [1, wrong_keys, words_per_min]
+    else
+      # Get the values in the hash and add the values to make a total to pass to the statistics
+      symbol_count = @keypress_statistics[item][0] + 1
+      wrong_keys_count = @keypress_statistics[item][1] + wrong_keys
+      wpm_total = @keypress_statistics[item][2] + words_per_min
+
+      @keypress_statistics[item] = [symbol_count, wrong_keys_count, wpm_total]
+    end
+  end
+
+  # The logic for running the game
+  def game_logic(item)
+    wrong_keys = 0
+    print "#{item}  --->   "
+
+    # Get the time at the start of each loop
+    first_time = Time.new.to_f
+    # Get the current user input key, without having to press enter
+    current_input = STDIN.getch
+
+    # Until the user gets the right key, keep prompting them, add keep a total for the amount of wrong keys hit before the correct one
+    while current_input != item
+      print "#{current_input.colorize(:red)}, "
+      current_input = STDIN.getch
+      wrong_keys += 1
+    end
+
+    # Get the time when the user types the correct key
+    second_time = Time.new.to_f if current_input == item
+    puts current_input
+
+    # Call and return the words per minute of each symbol
+    # The game logic returns the calculated statistics of each key each loop
+    calculate_statistics(item, wrong_keys, words_per_min(first_time, second_time))
+  end
+end

data/lib/typing_statistics.rb

@@ -0,0 +1,128 @@
+require 'json'
+require 'terminal-table'
+require 'tty-pie'
+require 'colorize'
+require 'colorized_string'
+require_relative 'typing_game'
+require_relative 'statistics_helper'
+require 'byebug'
+class TypingStatistics
+  # The method for taking in the score of the game that the user just played
+  # It then inputs the score into the average statistics for the user
+  # include StatisticsHelper
+  def statistics(scores)
+    # If there is already a hash in the JSON File, then read it or else create a new blank hash (Will only be first time user runs game)
+    begin
+      read_statistics
+    rescue JSON::ParserError
+      # Create an instanced empty hash so the score can be appended to it, as it will be nil otherwise and throw an error
+      @averaged_statistics = StatisticsHelper.add_symbols_to_hash if @averaged_statistics.nil?
+    end
+
+    # Take the scores hash of the last completed typing game and append them to the averaged_statistics hash
+    scores.each do |key, val|
+      # Storing the amount of times each symbol has been displayed to the averaged hash
+      @averaged_statistics[key][0] = total_count(@averaged_statistics[key][0], val[0])
+      # Storing the total amount of errors the user has made
+      @averaged_statistics[key][1] = total_count(@averaged_statistics[key][1], val[1])
+      # Storing the average accuracy for the user
+      @averaged_statistics[key][2] = average_accuracy(@averaged_statistics[key][0], @averaged_statistics[key][1])
+      # Storing the total wpm
+      @averaged_statistics[key][3] = total_count(@averaged_statistics[key][3], val[2])
+      # Storing the average WPM to the averaged hash
+      @averaged_statistics[key][4] = average_wpm(@averaged_statistics[key][3], @averaged_statistics[key][0])
+    end
+    # Write the statistics at the end of each game into the JSON file
+    write_statistics(sort_averaged_statistics(@averaged_statistics))
+  end
+
+  # Total counter method to assist with setting the key values
+  def total_count(total, addition)
+    total += addition
+    total
+  end
+
+  # Average accuracy method to assist with setting the key values
+  def average_accuracy(total_symbol_count, total_error_count)
+    ((total_symbol_count / (total_symbol_count + total_error_count).to_f) * 100).round(1)
+  end
+
+  # Average Words Per Minute method to assist with setting the key values
+  def average_wpm(total_wpm, total_symbol_count)
+    (total_wpm / total_symbol_count).round(1)
+  end
+
+  # Sort the users average scores by adding the average speed and accuracy, this is the indication of a good key
+  def sort_averaged_statistics(averaged_statistics)
+    # This converts the hash into a sorted array
+    sorted_array = averaged_statistics.sort_by { |_key, val| -(val[2] + val[4]) }
+    # Convert the array back to a hash for processing
+    @averaged_statistics = sorted_array.to_h
+  end
+
+  # Used for getting the absolute file path, wherever the user is. For when the user runs program from anywhere.
+  def file_path
+    path = File.dirname(__FILE__).split('/')
+    path.pop
+    json_file = "#{path.join('/')}/public/key_scores.json"
+    json_file
+  end
+
+  # Read and parse the averaged_statistics hash from the JSON file
+  def read_statistics
+    file = File.read(file_path)
+    @averaged_statistics = JSON.parse(file)
+  end
+
+  # Write the averaged_statistics hash to the JSON file
+  def write_statistics(averaged_statistics)
+    File.write(file_path, JSON.pretty_generate(averaged_statistics))
+  end
+
+  # Make a pie chart for the hit and miss count
+  def make_pie_chart(total_hit, total_miss)
+    data = [
+      { value: total_hit, color: :bright_green, fill: '•' },
+      { value: total_miss, color: :bright_red, fill: '•' }
+    ]
+    # Create the pie chart
+    pie_chart = TTY::Pie.new(data: data, radius: 2)
+    pie_chart.render
+    # It will throw a type error for nil values, in that case return a string
+  rescue TypeError
+    'no data yet'
+  end
+
+  # Display the statistics in a terminal table, for the users to read.
+  def display_statistics
+    # Read the current JSON file to get the averaged_statistics hash
+    read_statistics
+    # Make a terminal table and add in values from averaged_statistics hash
+    @rows = []
+    counter = 0
+    @averaged_statistics.each do |key, val|
+      # Set the color of the accuracy to red if the users accuracy is less than 60
+      val[2] = val[2].to_s.colorize(:red) if val[2].positive? && val[2] < 60
+      # Set the color of the WPM if the user WPM is under 50
+      val[4] = val[4].to_s.colorize(:yellow) if val[4] < 40 && val[4] != 0
+
+      # Add each symbol and associated data to the terminal-table row
+      @rows << [key, val[4], val[2], val[0], make_pie_chart(val[0], val[1])]
+      counter += 1
+      # Print a seperator for each symbol apart from the last
+      @rows << :separator if counter < @averaged_statistics.size
+    end
+    table = Terminal::Table.new title: 'Your Typing Statistics', headings: ['Symbol', 'Average WPM', 'Average Accuracy %', 'Symbol Count', 'Hit/Miss'], rows: @rows
+    table.align_column(0, :center)
+    table.align_column(1, :center)
+    table.align_column(2, :center)
+    table.align_column(3, :center)
+    puts table
+  end
+
+  # The method for wiping the JSON file if the user wants to.
+  def wipe_file
+    File.truncate(file_path, 0)
+    @averaged_statistics = StatisticsHelper.add_symbols_to_hash
+  end
+end

data/public/key_scores.json

@@ -0,0 +1,191 @@
+{
+  "]": [
+    1,
+    0,
+    100.0,
+    80.65385007368056,
+    80.7
+  ],
+  "+": [
+    1,
+    0,
+    100.0,
+    80.44000343932484,
+    80.4
+  ],
+  "=": [
+    1,
+    0,
+    100.0,
+    70.5913716690042,
+    70.6
+  ],
+  ":": [
+    1,
+    0,
+    100.0,
+    69.76731497920217,
+    69.8
+  ],
+  "?": [
+    1,
+    0,
+    100.0,
+    65.65189953827343,
+    65.7
+  ],
+  "!": [
+    1,
+    0,
+    100.0,
+    61.146865271855916,
+    61.1
+  ],
+  "~": [
+    2,
+    0,
+    100.0,
+    121.33804636798443,
+    60.7
+  ],
+  "<": [
+    1,
+    1,
+    50.0,
+    74.72060190202465,
+    74.7
+  ],
+  "[": [
+    1,
+    1,
+    50.0,
+    48.07993942871095,
+    48.1
+  ],
+  "#": [
+    1,
+    1,
+    50.0,
+    43.6055298977032,
+    43.6
+  ],
+  ";": [
+    1,
+    1,
+    50.0,
+    35.173707560569056,
+    35.2
+  ],
+  "-": [
+    1,
+    1,
+    50.0,
+    33.937701778754736,
+    33.9
+  ],
+  "|": [
+    2,
+    3,
+    40.0,
+    58.942454911783514,
+    29.5
+  ],
+  "`": [
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  "%": [
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  "&": [
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  "{": [
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  "}": [
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  "(": [
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  "*": [
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  ")": [
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  "_": [
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  "@": [
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  "^": [
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  "/": [
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  ">": [
+    0,
+    0,
+    0,
+    0,
+    0
+  ],
+  "$": [
+    0,
+    0,
+    0,
+    0,
+    0
+  ]
+}

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: symbol-holic
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Rory Musinskas
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-10-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: tty-pie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+- !ruby/object:Gem::Dependency
+  name: tty-reader
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+description: A simple symbol typing game
+email:
+executables:
+- symbol_holic
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/symbol_holic
+- lib/menu.rb
+- lib/statistics_helper.rb
+- lib/typing_game.rb
+- lib/typing_statistics.rb
+- public/key_scores.json
+homepage:
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+- public
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: Symbolic!
+test_files: []