reachy 1.1

data/lib/reachy/round.rb

@@ -0,0 +1,242 @@
+require_relative 'scoring'
+
+##############################################
+# Round record class
+##############################################
+module Reachy
+  class Round
+
+    attr_reader   :name           # Name of round (e.g. E1B2R1)
+    attr_reader   :mode           # Game mode
+    attr_reader   :wind           # Round wind
+    attr_reader   :number         # Round number
+    attr_reader   :bonus          # Current bonus sticks
+    attr_accessor :riichi         # Current riichi sticks
+    attr_accessor :scores         # Hash of <player's name> => <score>
+
+    # Initialize round
+    # Param: round - hash of round data
+    # Populate Round object with info from hash
+    def initialize(db)
+      @name = db["name"]
+      @wind = db["wind"]
+      @number = db["number"]
+      @bonus = db["bonus"]
+      @riichi = db["riichi"]
+      @scores = db["scores"]
+      @mode = @scores.length
+    end
+
+    # Return a deep copy of this Round object
+    def clone
+      return Marshal.load(Marshal.dump(self))
+    end
+
+    # Return Hash object representing Round object
+    def to_h
+      hash = {}
+      self.instance_variables.each do |var|
+        hash[var.to_s[1..-1]] = self.instance_variable_get(var)
+      end
+      hash.delete("mode")
+      return hash
+    end
+
+    # Add riichi stick declared by player
+    # Param: player - string of player's name
+    # Return: true if successful, else false
+    # Note: - round name should not be changed
+    #       - do not write to file here
+    def add_riichi(player)
+      if @scores[player] >= Scoring::P_RIICHI
+        @riichi += 1
+        @scores[player] -= Scoring::P_RIICHI
+        return true
+      else
+        puts "Unable to declare riichi: not enough points"
+        return false
+      end
+    end
+
+    # Update wind and round number to next round
+    def next_round
+      if not @wind
+        @wind = "E"
+        @number = 1
+      elsif @number == @mode
+        if @wind == "W"
+          printf "Already in last possible round (West %d)!\n", @number
+          return []
+        else
+          @wind = (@wind == "E" ? "S" : "W")
+          @number = 1
+        end
+      else
+        @number += 1
+      end
+    end
+
+    # Give bonus and riichi points to player
+    # Param: winner - string of player's name to award points to
+    #        loser  - list of players who pay for bonus points
+    #        dealer - bool indicating whether winner was dealer
+    # Return: true if successful, else false
+    def award_bonus(winner,loser,dealer)
+      if @scores.include?(winner)
+        @scores[winner] += @bonus*Scoring::P_BONUS
+        share_count = loser.length
+        if share_count>1 then share_count += (@mode==3 ? 1 : 0) end
+        bonus_paym = (@bonus*Scoring::P_BONUS)/share_count
+        loser.each do |l|
+          if @scores.include?(l)
+            @scores[l] -= bonus_paym
+          else
+            printf "Error: \"%s\" not in current list of players\n", l
+          end
+        end
+        @bonus = 0 if not dealer
+        @scores[winner] += @riichi*Scoring::P_RIICHI
+        @riichi = 0
+        return true
+      else
+        printf "Error: \"%s\" not in current list of players\n", winner
+        return false
+      end
+    end
+
+    # Update round name
+    def update_name
+      @name = @wind ? (@wind + @number.to_s) : ""
+      @name += "B" + @bonus.to_s if @bonus > 0
+      @name += "R" + @riichi.to_s if @riichi > 0
+    end
+
+    # Update round data from given input
+    # Param: type   - round result type (tsumo/ron/tenpai/noten/chombo)
+    #        dealer - string of dealer's name
+    #        winner - list of winner's name or players in tenpai
+    #        loser  - list of players who chombo or did not win
+    #        hand   - list of list of hand values (e.g. [["mangan"], [2,60]])
+    # Return: true if successful, else false
+    # Usage: This round is a clone of previous round, so just update its values.
+    #        Multiple ron winners: - winner and hand lists must match
+    #                              - first winner in list gets bonus/riichi points
+    def update_round(type,dealer,winner,loser,hand)
+      # Verify inputs
+      if (dealer == nil)
+        puts "Error: Missing dealer's name"
+        return false
+      end
+      if (hand.empty? || hand.first.empty?) && (type==T_TSUMO || type==T_RON)
+        puts "Error: Missing hand value"
+        return false
+      end
+
+      dealer_flag = winner.include?(dealer)
+
+      # Handle each round type
+      case type
+
+      when T_TSUMO
+        # Tsumo type: loser = everyone else
+        losers = @scores.keys
+        losers -= winner
+        return false if not self.award_bonus(winner.first,losers,dealer_flag)
+        if dealer_flag then @bonus += 1 else self.next_round end
+        score_h = Scoring.get_tsumo(dealer_flag, hand.first)
+        winner.each do |w|
+          @scores[w] += if dealer_flag then score_h["nondealer"]*(@mode-1)
+                        else (score_h["dealer"]+score_h["nondealer"]*(@mode-2)) end
+        end
+        losers.each do |l|
+          @scores[l] -= score_h[l==dealer ? "dealer" : "nondealer"]
+        end
+
+      when T_RON
+        # Ron type - can have multiple winners off of same loser
+        return false if not self.award_bonus(winner.first,loser,dealer_flag)
+        if dealer_flag then @bonus += 1 else self.next_round end
+        winner.zip(hand).each do |w,h|
+          paym = Scoring.get_ron((w==dealer),h)
+          @scores[w] += paym
+          @scores[loser.first] -= paym
+        end
+
+      when T_TENPAI
+        # Tenpai type: losers = all - winners
+        losers = @scores.keys
+        losers -= winner
+        if winner.length < @mode
+          if dealer_flag then @bonus += 1 else self.next_round end
+          total = @mode==4 ? Scoring::P_TENPAI_4 : Scoring::P_TENPAI_3
+          paym = total / losers.length
+          recv = total / winner.length
+          winner.each do |w|
+            @scores[w] += recv
+          end
+          losers.each do |l|
+            @scores[l] -= paym
+          end
+        end
+
+      when T_NOTEN
+        # Noten type: ignore all other params
+        self.next_round
+
+      when T_CHOMBO
+        # Chombo type: loser = chombo player, winner = everyone else
+        winners = @scores.keys
+        winners -= loser
+        dealer_flag = loser.include?(dealer)
+        score_h = Scoring.get_chombo(dealer_flag)
+        @scores[loser.first] -= if dealer_flag then score_h["nondealer"]*(@mode-1)
+                                else (score_h["dealer"] + score_h["nondealer"]*(@mode-2)) end
+        winners.each do |w|
+          @scores[w] += score_h[w==dealer ? "dealer" : "nondealer"]
+        end
+
+      else
+        printf "Invalid round result type\n", type
+        puts nil
+        return false
+      end
+
+      return true
+    end
+
+    # Print single line round scores
+    # Param: delta    - hash of score deltas between this round and previous one
+    #        ongoing  - bool indicating if round is ongoing (optional)
+    def print_scores(delta,ongoing=false)
+      round_name = @name
+      round_name += "*" if ongoing
+      printf "%-#{COL_SPACING}s", round_name
+      @scores.each do |key,val|
+        if delta
+          d = delta[key]
+          d = 0.0 if not d
+          if d == 0           # not sure why one-liner doesn't work here...
+            d = "="
+          elsif d < 0
+            d = d.to_s + "k"
+          else
+            d = "+" + d.to_s + "k"
+          end
+          val = val.to_s + "(" + d + ")"
+        else
+          val = val.to_s
+        end
+        printf "%-#{COL_SPACING}s", val
+      end
+      puts nil
+    end
+
+    # Print bonus and riichi sticks summary
+    def print_sticks
+      printf "  %-#{COL_SPACING}s: %d\n", "Bonus sticks", @bonus
+      printf "  %-#{COL_SPACING}s: %d\n", "Riichi sticks", @riichi
+      puts nil
+    end
+
+  end
+end

data/lib/reachy/scoretable.rb

@@ -0,0 +1,169 @@
+##############################################
+# Hash objects containing scoring tables
+##############################################
+module Reachy
+
+  # Hash of tsumo scores
+  H_TSUMO = {
+    "dealer" => {
+      "han_1" => {
+        "fu_20" => 400,
+        "fu_30" => 500,
+        "fu_40" => 700,
+        "fu_50" => 800,
+        "fu_60" => 1000,
+        "fu_70" => 1200
+      },
+      "han_2" => {
+        "fu_20" => 700,
+        "fu_30" => 1000,
+        "fu_40" => 1300,
+        "fu_50" => 1600,
+        "fu_60" => 2000,
+        "fu_70" => 2300
+      },
+      "han_3" => {
+        "fu_20" => 1300,
+        "fu_25" => 1600,
+        "fu_30" => 2000,
+        "fu_40" => 2600,
+        "fu_50" => 3200,
+        "fu_60" => 3900
+      },
+      "han_4" => {
+        "fu_20" => 2600,
+        "fu_25" => 3200,
+        "fu_30" => 3900
+      },
+      "mangan"          => 4000,
+      "haneman"         => 6000,
+      "baiman"          => 8000,
+      "sanbaiman"       => 12000,
+      "yakuman"         => 16000,
+      #"double_yakuman"  => 32000
+    },
+    "nondealer" => {
+      "han_1" => {
+        "fu_20" => { "dealer" => 400, "nondealer" => 200 },
+        "fu_30" => { "dealer" => 500, "nondealer" => 300 },
+        "fu_40" => { "dealer" => 700, "nondealer" => 400 },
+        "fu_50" => { "dealer" => 800, "nondealer" => 400 },
+        "fu_60" => { "dealer" => 1000, "nondealer" => 500 },
+        "fu_70" => { "dealer" => 1200, "nondealer" => 600 }
+      },
+      "han_2" => {
+        "fu_20" => { "dealer" => 700, "nondealer" => 400 },
+        "fu_30" => { "dealer" => 1000, "nondealer" => 500 },
+        "fu_40" => { "dealer" => 1300, "nondealer" => 700 },
+        "fu_50" => { "dealer" => 1600, "nondealer" => 800 },
+        "fu_60" => { "dealer" => 2000, "nondealer" => 1000 },
+        "fu_70" => { "dealer" => 2300, "nondealer" => 1200 }
+      },
+      "han_3" => {
+        "fu_20" => { "dealer" => 1300, "nondealer" => 700 },
+        "fu_25" => { "dealer" => 1600, "nondealer" => 800 },
+        "fu_30" => { "dealer" => 2000, "nondealer" => 1000 },
+        "fu_40" => { "dealer" => 2600, "nondealer" => 1300 },
+        "fu_50" => { "dealer" => 3200, "nondealer" => 1600 },
+        "fu_60" => { "dealer" => 3900, "nondealer" => 2000 }
+      },
+      "han_4" => {
+        "fu_20" => { "dealer" => 2600, "nondealer" => 1300 },
+        "fu_25" => { "dealer" => 3200, "nondealer" => 1600 },
+        "fu_30" => { "dealer" => 3900, "nondealer" => 2000 }
+      },
+      "mangan"          => { "dealer" => 4000, "nondealer" => 2000 },
+      "haneman"         => { "dealer" => 6000, "nondealer" => 3000 },
+      "baiman"          => { "dealer" => 8000, "nondealer" => 4000 },
+      "sanbaiman"       => { "dealer" => 12000, "nondealer" => 6000 },
+      "yakuman"         => { "dealer" => 16000, "nondealer" => 8000 },
+      #"double_yakuman"  => { "dealer" => 32000, "nondealer" => 16000 }
+    }
+  }
+
+  # Hash of ron scores
+  H_RON = {
+    "dealer" => {
+      "han_1" => {
+        "fu_20" => 1000,
+        "fu_30" => 1500,
+        "fu_40" => 2000,
+        "fu_50" => 2400,
+        "fu_60" => 2900,
+        "fu_70" => 3400
+      },
+      "han_2" => {
+        "fu_20" => 2000,
+        "fu_25" => 2400,
+        "fu_30" => 2900,
+        "fu_40" => 3900,
+        "fu_50" => 4800,
+        "fu_60" => 5800,
+        "fu_70" => 6800
+      },
+      "han_3" => {
+        "fu_20" => 3900,
+        "fu_25" => 4800,
+        "fu_30" => 5800,
+        "fu_40" => 7700,
+        "fu_50" => 9600,
+        "fu_60" => 11600
+      },
+      "han_4" => {
+        "fu_20" => 7700,
+        "fu_25" => 9600,
+        "fu_30" => 11600
+      },
+      "mangan"          => 12000,
+      "haneman"         => 18000,
+      "baiman"          => 24000,
+      "sanbaiman"       => 36000,
+      "yakuman"         => 48000,
+      #"double_yakuman"  => 96000
+    },
+    "nondealer" => {
+      "han_1" => {
+        "fu_20" => 700,
+        "fu_30" => 1000,
+        "fu_40" => 1300,
+        "fu_50" => 1600,
+        "fu_60" => 2000,
+        "fu_70" => 2300
+      },
+      "han_2" => {
+        "fu_20" => 1300,
+        "fu_30" => 2000,
+        "fu_25" => 1600,
+        "fu_40" => 2600,
+        "fu_50" => 3200,
+        "fu_60" => 3900,
+        "fu_70" => 4500
+      },
+      "han_3" => {
+        "fu_20" => 2600,
+        "fu_25" => 3200,
+        "fu_30" => 3900,
+        "fu_40" => 5200,
+        "fu_50" => 6300,
+        "fu_60" => 7700
+      },
+      "han_4" => {
+        "fu_20" => 5200,
+        "fu_25" => 6400,
+        "fu_30" => 7700
+      },
+      "mangan"          => 8000,
+      "haneman"         => 12000,
+      "baiman"          => 16000,
+      "sanbaiman"       => 24000,
+      "yakuman"         => 32000,
+      #"double_yakuman"  => 64000
+    }
+  }
+
+  # Hash of chombo scores
+  H_CHOMBO = {
+    "dealer" => 4000,
+    "nondealer" => { "dealer" => 4000, "nondealer" => 2000 }
+  }
+end

data/lib/reachy/scoring.rb

@@ -0,0 +1,86 @@
+require_relative 'defines'
+require_relative 'scoretable'
+
+##############################################
+# Scoring class
+##############################################
+module Reachy
+  module Scoring
+
+    # Point constants
+    P_BONUS     = 300
+    P_RIICHI    = 1000
+    P_TENPAI_3  = 2000
+    P_TENPAI_4  = 3000
+    P_START_3   = 35000
+    P_START_4   = 25000
+
+    # Convert han, fu input to hash keys
+    # Param: han - fixnum of han's
+    #        fu  - fixnum of fu's
+    # Return: list of keys
+    def self.to_keys(han,fu)
+      keys = []
+      if ((han<3 && fu>70) || (han==3 && fu>60) || (han==4 && fu>30) || (han==5))
+        keys = ["mangan"]
+      elsif (han==6 || han==7)
+        keys = ["haneman"]
+      elsif (han==8 || han==9 || han==10)
+        keys = ["baiman"]
+      elsif (han==11 || han==12)
+        keys = ["sanbaiman"]
+      elsif (han==13)
+        keys = ["yakuman"]
+      else
+        keys << "han_" + han.to_s
+        keys << "fu_" + fu.to_s
+      end
+      return keys
+    end
+
+    # Get Tsumo settlements
+    # Param: dealer - bool indicating if dealer won
+    #        hand   - list representing hand value (e.g. ["mangan"], [2,60])
+    # Return: hash of points
+    def self.get_tsumo(dealer,hand)
+      keys_h = if hand.first.instance_of?(String) then hand
+               else Scoring.to_keys(hand[0],hand[1]) end
+      if dealer
+        val = if keys_h.length == 2 then H_TSUMO["dealer"][keys_h[0]][keys_h[1]]
+              else H_TSUMO["dealer"][keys_h[0]] end
+        if not val then return nil end
+        return { "nondealer" => val }
+      else
+        val = if keys_h.length == 2 then H_TSUMO["nondealer"][keys_h[0]][keys_h[1]]
+              else H_TSUMO["nondealer"][keys_h[0]] end
+        return val
+      end
+    end
+
+    # Get Ron settlements
+    # Param: dealer - bool indicating if dealer won
+    #        hand   - list representing hand value (e.g. ["mangan"], [2,60])
+    # Return: fixnum of points
+    def self.get_ron(dealer,hand)
+      keys_h = if hand.first.instance_of?(String) then hand
+               else Scoring.to_keys(hand[0],hand[1]) end
+      val = if keys_h[1] then
+              H_RON[dealer ? "dealer" : "nondealer"][keys_h[0]][keys_h[1]]
+            else H_RON[dealer ? "dealer" : "nondealer"][keys_h[0]] end
+      return val
+    end
+
+    # Get Chombo settlements
+    # Param: dealer - bool indicating if dealer chombo
+    # Return: hash of points
+    def self.get_chombo(dealer)
+      if dealer
+        val = H_CHOMBO["dealer"]
+        if not val then return nil end
+        return { "nondealer" => val }
+      else
+        return H_CHOMBO["nondealer"]
+      end
+    end
+  end
+end

data/lib/reachy/util.rb

@@ -0,0 +1,156 @@
+require 'io/console'
+
+require_relative 'defines'
+
+##############################################
+# Reachy utilities
+##############################################
+module Reachy
+
+  # Prompt for user input with a message.
+  # If EOF is entered, aborts program.
+  # Param: message - string to display
+  #        downcase - whether to downcase input
+  # Return: User input
+  # Note: always strips input!
+  def self.prompt(message, downcase=true)
+    print message
+    input = gets
+    goodbye if !input
+    if downcase
+      return input.strip.downcase
+    else
+      return input.strip
+    end
+  end
+
+  # Prompt for one character, downcased.
+  # If EOF is entered, aborts program.
+  # Param: message - string to display
+  # Return: User input character, downcased
+  def self.prompt_ch(message)
+    print message
+    input = STDIN.getch
+    goodbye if input == SIGINT_CH || input == EOF_CH
+    print input
+    return input.downcase
+  end
+
+  # Read all games in data dir, and store in @games array
+  def self.read_all_games
+    @games = []
+    Dir.foreach(File.expand_path("../../../data/", __FILE__)) do |filename|
+      # Skip . and .. dir entries, and trash dir
+      next if filename == '.' or filename == '..' or filename == "trash"
+
+      # Create game objects
+      game = Game.new(filename)
+      @games << game
+    end
+  end
+
+  # Print out all games in database
+  def self.display_all_games
+    if @games.empty?
+      puts "  No game currently in database. Please add a new game."
+      puts nil
+      return false
+    end
+    @games.each_with_index do |game, index|
+      printf "  %d) ", index + 1
+      game.print_title
+    end
+    return true
+  end
+
+  # Confirm game deletion
+  def self.confirm_delete(chosen_game)
+    printf "---> Deleting game \"%s\". This action cannot be undone.\n", chosen_game.filename
+    conf = prompt "  Are you sure? (y/N) "
+    if conf == "y"
+      # Move associated json file to trash.
+      chosen_game.delete_from_disk
+      # Delete from @games array
+      @games.delete(chosen_game)
+      printf "*** Game \"%s\" deleted from database.\n\n", chosen_game.filename
+      return true
+    else
+      puts "You changed your mind? Fine.\n\n"
+      return false
+    end
+  end
+
+  # Ensure that the data and data/trash directory exist, if not create them
+  def self.ensure_data_dir
+    if not File.directory?(File.expand_path("../../../data/", __FILE__))
+      Dir.mkdir File.expand_path("../../../data/", __FILE__)
+    end
+    if not File.directory?(File.expand_path("../../../data/trash/", __FILE__))
+      Dir.mkdir File.expand_path("../../../data/trash/", __FILE__)
+    end
+  end
+
+  # Validate hand input
+  # Param: hand - string of hand value input
+  # Return: reformated hand value or empty list if input invalid
+  def self.validate_hand(hand)
+    split_hand = hand.split
+    hand = []
+    i = 0
+    flag = true
+    while i < split_hand.length   # Did this C-style AKA imperatively.. how to ruby
+      if split_hand[i].match(/^\d+$/)
+        han = split_hand[i]
+        fu = split_hand[i+1]
+        if fu.match(/^\d+$/) && (fu.to_i==25 || fu.to_i%10 == 0)
+          hand << [han.to_i, fu.to_i]
+          i += 2
+        else
+          flag = false
+          hand = []
+          break
+        end
+      elsif L_HANDS.include?(split_hand[i])
+        hand << [split_hand[i]]
+        i += 1
+      else
+        flag = false
+        hand = []
+        break
+      end
+    end
+    if not flag
+      printf "Hand value malformed: \"%s\"\n", hand
+    end
+    return hand
+  end
+
+  # Display winners of every game
+  def self.display_all_winners
+    puts " Current winners:"
+    puts " ----------------"
+    @games.each do |game|
+      high_score = game.scoreboard.last.scores.values.max
+      winners = game.scoreboard.last.scores.select{ |player, score| score == high_score}
+      printf "  * %s: %s - %d points\n", game.filename, winners.keys.join(", "), high_score
+    end
+    puts nil
+  end
+
+  # Call system cowsay if available
+  def self.cowsay
+    system("cowsay Bye!") if system("which cowsay >/dev/null 2>&1")
+  end
+
+  # Message to print when quitting program
+  def self.goodbye
+    puts "\n\n"
+    printf "  -------------------------------\n" \
+      "  |  Thanks for flying reachy!  |\n" \
+      "  -------------------------------\n\n"
+    display_all_winners
+    cowsay
+    exit 0
+  end
+
+end

data/lib/reachy.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'date'
+require 'fileutils'
+
+require_relative 'reachy/game'
+require_relative 'reachy/util'
+require_relative 'reachy/main_menu'
+
+##############################################
+# Main driver functionality
+##############################################
+module Reachy
+
+  # Display initial screen (complete with banner, list of games)
+  def self.start_screen
+    # Display banner
+    File.open(File.expand_path("../banner", __FILE__), "r"){ |file| puts file.read }
+    puts nil
+
+    # Display all games in db
+    ensure_data_dir
+    read_all_games
+    puts "*** Current existing game(s) in database:"
+    puts nil if display_all_games
+
+    # Display main menu options
+    main_menu
+  end
+
+end