reachy 1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 08b598e9df22e627af1198a45436f0883644347b
+  data.tar.gz: c2005872367ba2345d1462c0a3bba7c046003cee
+SHA512:
+  metadata.gz: b7cd060809d5ef86258ca046328fd40cfe3ea75dbb08da932aa38eb1a842192f3e3f615b74a061ad80e613fe9169b33869c37abc79b62308381691ec2f4044ac
+  data.tar.gz: f8dc5d0ee3560fb31ee171e4954dfb9af7901f83164190e48228835b17df858b66ca1a815027d3de3e66907f67320645855ae615d6c474a4dc5518cd21c86944

data/bin/reachy

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/reachy.rb"
+
+Reachy.start_screen

data/lib/banner

@@ -0,0 +1,9 @@
+############################################
+###         RIICHI SCORE TRACKER         ###
+############################################
+By: Thao Truong (Kainu) & Joshua Tang
+Last Updated: 15 Jul 2016
+
+A demo program that helps you keep track of
+Japanese mahjong (Riichi) score as you play.
+____________________________________________

data/lib/reachy/defines.rb

@@ -0,0 +1,23 @@
+##############################################
+# Reachy constants
+##############################################
+module Reachy
+
+  # Scoreboard formatting
+  COL_SPACING = 15
+
+  # Round result types
+  T_TSUMO   = 1
+  T_RON     = 2
+  T_TENPAI  = 3
+  T_NOTEN   = 4
+  T_CHOMBO  = 5
+
+  # List of named hand values
+  L_HANDS   = ["mangan","haneman","baiman","sanbaiman","yakuman"]
+
+  # Special characters
+  L_NEWLINE = ["\r","\n","\r\n"]
+  SIGINT_CH = "\u0003"
+  EOF_CH = "\u0004"
+end

data/lib/reachy/game.rb

@@ -0,0 +1,222 @@
+require 'json'
+require 'date'
+require 'pp'
+
+require_relative 'round'
+
+##############################################
+# Scoreboard record class
+##############################################
+module Reachy
+  class Game
+
+    attr_reader   :filename         # Name of JSON file
+    attr_reader   :created_at       # Timestamp at creation
+    attr_accessor :last_updated     # Timestamp at last updated
+    attr_reader   :mode             # Game mode
+    attr_reader   :players          # List of player names
+    attr_accessor :scoreboard       # List of round records
+
+    # Initialize game from given hash
+    # Param: filename - name of json file
+    #        ondisk   - whether Game object exists on disk
+    #        players  - array of player names associatied with this game
+    def initialize(filename, ondisk=true, players=[])
+      if ondisk
+        # Game object exists on disk. Read it from file.
+        self.read_data(filename)
+      else
+        # Create new Game object with starting values.
+        @filename = filename
+        @created_at = DateTime.now
+        @last_updated = DateTime.now
+        @mode = players.length
+        @players = players
+        self.initialize_scoreboard
+        self.write_data
+      end
+      @plist = @players.map {|x| x.downcase}
+    end
+
+    # Populate @scoreboard with starting Round objects
+    def initialize_scoreboard
+      # Make initial scores e.g. { "joshua" => 35000, "kenta" => 35000, "thao" => 35000 }
+      start_score = mode == 3 ? Scoring::P_START_3 : Scoring::P_START_4
+      init_scores = Hash[ @players.map{ |p| [p.downcase, start_score] } ]
+      init_round = {"name" => "",
+                    "wind" => nil,
+                    "number" => 0,
+                    "bonus" => 0,
+                    "riichi" => 0,
+                    "scores" => init_scores}
+      @scoreboard = [Round.new(init_round)]
+      self.clone_last_round(true)
+    end
+
+    # Populate Game object with info from hash
+    # Param: db - hash of game data
+    def populate(db)
+      @filename = db["filename"]
+      @created_at = DateTime.parse(db["created_at"])
+      @last_updated = DateTime.parse(db["last_updated"])
+      @mode = db["mode"]
+      @players = db["players"]
+      @scoreboard = []
+      db["scoreboard"].each do |round|
+        @scoreboard << Round.new(round)
+      end
+    end
+
+    # Return Hash object representing Game object
+    def to_h
+      hash = {}
+      self.instance_variables.each do |var|
+        hash[var.to_s[1..-1]] = self.instance_variable_get(var)
+      end
+      hash["scoreboard"] = []
+      @scoreboard.each do |r|
+        hash["scoreboard"] << r.to_h
+      end
+      hash.delete("plist")
+      return hash
+    end
+
+    # Read JSON database file and repopulate object
+    def read_data(filename)
+      filepath = File.expand_path("../../../data/" + filename, __FILE__)
+      file = File.read(filepath)
+      db = JSON.parse(file)
+      self.populate(db)
+    end
+
+    # Write Game object to JSON database file
+    def write_data
+      @last_updated = DateTime.now
+      hash = self.to_h
+      filepath = File.expand_path("../../../data/" + @filename, __FILE__)
+      File.open(filepath, "w") do |f|
+        f.write(JSON.pretty_generate(hash))
+      end
+    end
+
+    # Add new round result
+    def add_round(type, dealer, winner, loser, hand)
+      if not @scoreboard.last.update_round(type, dealer, winner, loser, hand)
+        printf "  An error occurred while updating round score.\n" \
+               "  Please check your input (winner, hand) and try again.\n\n"
+        return
+      end
+      self.clone_last_round
+      self.write_data
+    end
+
+    # Clone last round as next round and add to scoreboard
+    # Param: to_next  - bool indicating whether to move to next round (optional)
+    def clone_last_round(to_next=false)
+      new_round = @scoreboard.last.clone
+      if (to_next || new_round.name == "") then new_round.next_round end
+      new_round.update_name
+      @scoreboard << new_round
+    end
+
+    # Remove latest round from scoreboard
+    def remove_last_round
+      if @scoreboard.length > 2
+        @scoreboard.pop
+        @scoreboard.pop
+        self.clone_last_round
+        self.write_data
+      else
+        printf "Error: Current game already in initial state. " \
+          "No round deleted.\n"
+      end
+    end
+
+    # Move data file of this game to trash
+    def delete_from_disk
+      FileUtils.mv(File.expand_path("../../../data/" + @filename, __FILE__),
+                   File.expand_path("../../../data/trash/" + @filename, __FILE__))
+    end
+
+    # Validate players input
+    # Param: players  - list of players to check
+    # Return: true if all players in list are in this game, else false
+    def validate_players(players)
+      flag = true
+      players.each do |p|
+        if not @plist.include?(p)
+          printf "Error: Player \"%s\" not in current list of players\n", p
+          flag = false
+        end
+      end
+      return flag
+    end
+
+    # Add riichi stick declared by player
+    # Param: player - string of player's name
+    # Return: true if successful, else false
+    def add_riichi(player)
+      if @players.map(&:downcase).include? player
+        ret = @scoreboard.last.add_riichi(player)
+        if ret then self.write_data end
+        return ret
+      else
+        printf "Error: \"%s\" not in current game's players list\n", player
+        return false
+      end
+    end
+
+    # Print scoreboard header
+    # Round       Joshua    Kenta     Thao
+    def print_header
+      #maxlen = [@players.max_by(&:length).length, 5].max
+      printf "%-#{COL_SPACING}s", "Round"
+      @players.each do |p|
+        printf "%-#{COL_SPACING}s", p
+      end
+      puts nil
+    end
+
+    # Print entire scoreboard
+    def print_scoreboard
+      self.print_title
+      (COL_SPACING * (@mode+1)).times { printf "-" }
+      puts nil
+      self.print_header
+      @scoreboard[0].print_scores(nil)  # print init scores
+      @scoreboard[1..-2].each.with_index(1) do |curr,i|
+        delta = {}
+        prev = @scoreboard[i-1]
+        prev.scores.each do |k,v|
+          delta[k] = (curr.scores[k]-prev.scores[k]).to_f/1000
+        end
+        curr.print_scores(delta)
+      end
+      # print ongoing round
+      @scoreboard.last.print_scores(nil,true)
+      puts nil
+    end
+
+    # Print last round scores
+    # Round       Joshua    Kenta     Thao
+    # E1B1R2      33400     39800     31800
+    def print_last_round
+      self.print_header
+      @scoreboard[-2].print_scores(nil)
+    end
+
+    # Print 1-line game title
+    # game1: 3P (E1B1R1) ~ Joshua, Kenta, Thao ~ 2016-11-05T14:05:00-07:00
+    def print_title
+      printf "%s: %dP (%s) ~ %s ~ %s", @filename, @mode, @scoreboard[-2].name,
+        @players.join(", "), @last_updated
+      puts nil
+    end
+
+    # Print current round sticks
+    def print_current_sticks
+      @scoreboard.last.print_sticks
+    end
+
+  end
+end

data/lib/reachy/game_menu.rb

@@ -0,0 +1,228 @@
+require_relative 'game'
+require_relative 'round'
+require_relative 'util'
+
+##############################################
+# Game menu and specific game interactions
+##############################################
+module Reachy
+
+  # Game menu for a particular game
+  def self.game_menu
+    loop do
+      game = @games[@selected_game_index]
+      puts "(Enter \"x\" to go back to main menu.)\n"
+      puts nil
+      printf "*** Game \"%s\" Options:\n" \
+        "  1) Add next round result\n" \
+        "  2) Declare riichi\n" \
+        "  3) View current scoreboard\n" \
+        "  4) Remove last round entry\n" \
+        "  5) Delete current game\n" \
+        "  6) Choose a different game\n" \
+        "  7) Add new game\n", game.filename
+      choice = prompt_ch "---> Enter your choice: "
+      puts nil
+      case choice
+      when "x"
+        puts nil
+        return # to main menu
+      when "1"
+        puts "\n[Add next round result]"
+        puts nil
+        add_round(game)
+      when "2"
+        puts "\n[Declare riichi]"
+        puts nil
+        declare_riichi(game)
+      when "3"
+        puts "\n[View current scoreboard]"
+        puts nil
+        game.print_scoreboard
+        puts "(Press any key to continue)"
+        STDIN.getch
+      when "4"
+        puts "\n[Remove last round entry]"
+        puts nil
+        remove_last_round(game)
+      when "5"
+        puts "\n[Delete current game]"
+        puts nil
+        return if confirm_delete(game) # main menu if current game deleted
+      when "6"
+        puts "\n[Choose a different game]"
+        puts nil
+        view_game
+      when "7"
+        puts "\n[Add new game]"
+        puts nil
+        add_game
+      when ""
+        puts "\nEnter a choice... >_>"
+        puts nil
+      else
+        printf "\nInvalid choice: %s\n", choice
+        puts nil
+      end
+    end
+  end
+
+  # Add a new round to the current game. Sub menu option 1.
+  def self.add_round(game)
+    puts "(Enter \"x\" to return to game options.)"
+    puts nil
+    dealer = prompt "---> Dealer's name: "
+    return if dealer == "x"
+    puts nil
+
+    loop do
+      printf "*** Round result type:\n" \
+        "  1) Tsumo\n" \
+        "  2) Ron\n" \
+        "  3) Tenpai\n" \
+        "  4) Noten\n" \
+        "  5) Chombo\n"
+      choice = prompt "---> Select round result: "
+      case choice
+      when "x"
+        puts nil
+        return
+      when "1"
+        # Tsumo
+        type = T_TSUMO
+        winner = prompt "---> Winner's name: "
+        return if winner == "x"
+        winner = winner.split
+        if winner.length > 1
+          puts "  Assuming \"%s\" is the winner, ignoring remaining players.",
+            winner.first
+          winner = [winner.first]
+        end
+        next if not game.validate_players(winner)
+
+        hand = prompt "---> Hand value(s) (e.g. \"2 30\" or \"mangan\"): "
+        return if hand == "x"
+        hand = validate_hand(hand)
+
+        loser = []  # Round::update_round will set loser = all - winner
+        game.add_round(type, dealer, winner, loser, hand)
+        break
+      when "2"
+        # Ron
+        type = T_RON
+        puts nil
+        winner = prompt "---> Winner(s) (first winner gets bonus and riichi sticks): "
+        return if winner == "x"
+        winner = winner.split
+        next if not game.validate_players(winner)
+
+        loser = prompt "---> Player who dealt into winning hand(s): "
+        return if loser == "x"
+        loser = loser.split
+        if loser.length > 1
+          puts "  Assuming \"%s\" is the player who dealt into winning hand.",
+            loser.first
+          loser = [loser.first]
+        end
+        next if not game.validate_players(loser)
+        if winner.include? loser.first
+          puts "Loser can't be a winner..."
+          next
+        end
+
+        hand = prompt "---> Hand value(s) (e.g. \"2 30 yakuman\" or \"mangan\"): "
+        puts nil
+        return if hand == "x"
+        hand = validate_hand(hand)
+
+        if hand.length != winner.length
+          printf "The number of winners and winning hands do not match. " \
+                 "Please try again.\n\n"
+        end
+        game.add_round(type, dealer, winner, loser, hand)
+        break
+      when "3"
+        # Tenpai
+        type = T_TENPAI
+        winner = prompt "---> Player(s) in tenpai (separated by space): "
+        return if winner == "x"
+        winner = winner.split
+        next if not game.validate_players(winner)
+
+        loser = []  # Round::update_round will set losers = all - winners
+        hand = []
+        game.add_round(type, dealer, winner, loser, hand)
+        break
+      when "4"
+        # Noten
+        type = T_NOTEN
+        winner = []
+        loser = []
+        hand = []
+        game.add_round(type, dealer, winner, loser, hand)
+        break
+      when "5"
+        # Chombo
+        type = T_CHOMBO
+        loser = prompt "---> Player who chombo'd: "
+        return if loser == "x"
+        loser = loser.split
+        if loser.length > 1
+          puts "  Assuming \"%s\" is the player who dealt into winning hand.",
+            loser.first
+          loser = [loser.first]
+        end
+        next if not game.validate_players(loser)
+
+        winner = [] # Round::update_round will set winners = all - loser
+        hand = []
+        game.add_round(type, dealer, winner, loser, hand)
+        break
+      when ""
+        puts "Enter a choice... >_>"
+        puts nil
+      else
+        printf "Invalid choice: %s\n", choice
+        puts nil
+      end
+    end
+
+    puts "*** Game scoreboard updated."
+    puts nil
+    game.print_scoreboard
+  end
+
+  # Update riichi sticks. Sub menu option 2.
+  def self.declare_riichi(game)
+    puts "(Enter \"x\" to return to game options.)"
+    puts nil
+    player = prompt "---> Player(s) who declared riichi: "
+    player = player.split
+    return if not game.validate_players(player)
+
+    player.each do |p|
+      if game.add_riichi(p)
+        printf "\n*** Riichi stick added by %s.\n", p
+        game.print_current_sticks
+      end
+    end
+  end
+
+  # Remove last round from scoreboard. Sub menu option 3.
+  def self.remove_last_round(game)
+    printf "---> Removing last round entry:\n"
+    game.print_last_round
+    conf = prompt "  Are you sure? (y/N) "
+    if conf == "y"
+      game.remove_last_round
+      puts nil
+      puts "*** Game scoreboard updated."
+      puts nil
+      game.print_scoreboard
+      return true
+    else
+      puts "You changed your mind? Fine.\n\n"
+      return false
+    end
+  end
+end

data/lib/reachy/main_menu.rb

@@ -0,0 +1,192 @@
+require_relative 'game'
+require_relative 'round'
+require_relative 'util'
+require_relative 'game_menu'
+
+##############################################
+# Main menu and top level interactions
+##############################################
+module Reachy
+
+  # Main menu
+  def self.main_menu
+    loop do
+      puts "*** Main menu:\n" \
+        "  1) View or update existing game scoreboard\n" \
+        "  2) Add new game\n" \
+        "  3) Delete existing game\n" \
+        "  4) Display all scoreboards"
+      choice = prompt_ch "---> Enter your choice: "
+      puts nil
+      case choice
+      when "1"
+        puts "\n[View or update existing game scoreboard]"
+        puts nil
+        if view_game then game_menu else puts nil end
+      when "2"
+        puts "\n[Add new game]"
+        puts nil
+        if add_game then game_menu else puts nil end
+      when "3"
+        puts "\n[Delete existing game]"
+        puts nil
+        delete_game
+      when "4"
+        puts "\n[Display all scoreboards]"
+        puts nil
+        display_all_scoreboards
+      when ""
+        puts "\nEnter a choice... >_>"
+        puts nil
+      else
+        printf "\nInvalid choice: %s\n", choice
+        puts nil
+      end
+    end
+  end
+
+  # Find number of prefix-match game choices
+  def self.choice_match
+    return (@games[@choice_buf.to_i] ? 1 : 0) if L_NEWLINE.include?(@choice_buf[-1])
+    l = (1..@games.length).map{|i| i if /\A#{@choice_buf}\d*\z/.match(i.to_s)}.compact
+    ret = l.length
+    return ret
+  end
+
+  # View/update an existing game. Main menu option 1.
+  def self.view_game
+    loop do
+      puts "(Enter \"x\" to go back to main menu.)"
+      puts nil
+      puts "*** Choose existing game:"
+      return if not display_all_games
+
+      @choice_buf = prompt_ch "---> Enter your choice: "
+      if @choice_buf == "x"
+        puts nil
+        return false # to main menu
+      elsif L_NEWLINE.include?(@choice_buf)
+        puts "\n\nEnter a choice... >_>"
+        puts nil
+      else
+        # Check if current input buffer represents a unique game
+        matches = choice_match
+        while matches > 1
+          @choice_buf += prompt_ch ""
+          matches = choice_match
+        end
+        puts nil
+        puts nil
+        if choice_match == 0
+          printf "Invalid choice: %s\n", @choice_buf
+          puts nil
+        else
+          c = @choice_buf.to_i
+          # Print scoreboard for this game
+          @games[c - 1].print_scoreboard
+          @selected_game_index = c - 1
+          return true # to main menu
+        end
+      end
+    end
+  end
+
+  # Add a game. Main menu option 2.
+  def self.add_game
+    puts "(Enter \"x\" to go back to previous menu.)"
+    puts nil
+
+    # Ask for unique game name.
+    unique = false
+    until unique do
+      name = prompt("---> Game name: ", false)
+      return false if name == "x"
+      next if name.length == 0
+      if not /\A\w+\z/.match(name)
+        printf "Please enter only alphanumeric characters and underscores.\n"
+        next
+      end
+      unique = true
+      @games.each do |game|
+        if game.filename == name
+          unique = false
+          printf "Already exists a game of name: %s!\n", name
+          break
+        end
+      end
+    end
+
+    # Ask for number of players
+    good = false
+    until good do
+      nump = prompt "---> Number of players (3 or 4): "
+      return false if nump == "x"
+      nump = nump.to_i
+      if nump == 3 or nump == 4
+        good = true
+      else
+        puts "Invalid number of players"
+      end
+    end
+
+    # Ask for unique player handles
+    good = false
+    until good do
+      players = prompt "---> Player names (separated by spaces, in ESWN order): "
+      return false if nump == "x"
+      players = players.split
+      if players.length == nump and players.uniq.length == players.length
+        good = true
+      else
+        printf "Must input %d unique player handles\n", nump
+      end
+    end
+
+    newgame = Game.new(name, false, players)
+
+    # Add to @games array and go to its menu.
+    @games << newgame
+    puts "\n*** New game created! Scoreboard:"
+    puts nil
+    newgame.print_scoreboard
+    @selected_game_index = @games.length - 1 # last entry is the new game
+    return true
+  end
+
+  # Delete a game. Main menu option 3.
+  def self.delete_game
+    loop do
+      puts "(Enter \"x\" to go back to main menu.)"
+      puts nil
+      puts "*** Choose existing game to delete:"
+      return if not display_all_games
+      choice = prompt "---> Enter your choice: "
+      case choice
+      when "x"
+        return # to main menu
+      when ""
+        puts "\nEnter a choice... >_>"
+      else
+        # Check that choice consists only of digits and within @games bounds
+        if /\A\d+\z/.match(choice) and choice.to_i <= @games.length and choice.to_i > 0
+          # Ask for confirmation
+          chosen_game = @games[choice.to_i - 1]
+          puts nil
+          confirm_delete(chosen_game)
+          return # to main menu
+        else
+          printf "Invalid choice: %s\n", choice
+          puts nil
+        end
+      end
+    end
+  end
+
+  # Display all scoreboards. Main menu option 4.
+  def self.display_all_scoreboards
+    @games.each do |game|
+      game.print_scoreboard
+    end
+  end
+
+end