ascension 0.1.0

data/lib/ascension.rb

@@ -0,0 +1,209 @@
+require 'mharris_ext'
+require 'rchoice'
+require 'mongo_persist'
+
+def playing_on_command_line?
+  $playing_on_command_line = true if $playing_on_command_line.nil?
+  $playing_on_command_line
+end
+
+%w(to_json).each do |f|
+  load File.dirname(__FILE__) + "/ascension/#{f}.rb"
+end
+
+def db
+  Mongo::Connection.new.db('ascension')
+end
+
+class Array
+  def sum
+    inject { |s,i| s + i }
+  end
+end
+
+class Object
+  def klass
+    self.class
+  end
+end
+
+class Events
+  def fire(event)
+    
+  end
+end
+
+class Game
+  setup_mongo_persist :sides, :center, :void, :honor, :deck, :turn_manager
+  def addl_json_attributes
+    %w(mongo_id engageable_cards constant_cards current_side_index last_update_dt)
+  end
+
+  fattr(:sides) { [] }
+  fattr(:center) { Center.new(:game => self) }
+  fattr(:void) { Void.new }
+  fattr(:honor) { 60 }
+  fattr(:deck) { CenterDeck.starting }
+  fattr(:center_wc) { CenterWithConstants.new(:game => self) }
+  fattr(:turn_manager) { TurnManager.new(:game => self) }
+
+  def engageable_cards
+    turn_manager.current_side.engageable_cards
+  end
+  def constant_cards
+    center_wc.constant_cards
+  end
+  def current_side_index
+    turn_manager.current_side_index
+  end
+  def last_update_dt
+    Time.now
+  end
+
+  def card_places
+    places = [deck,center,void]
+    sides.each do |side|
+      places += [side.hand,side.discard,side.deck,side.played]
+    end
+    places
+  end
+
+  def after_mongo_load
+    center.game = self
+    turn_manager.game = self
+
+    sides.each do |s|
+      s.game = self
+      %w(discard deck hand played constructs).each do |m|
+        s.send(m).side = s
+      end
+      s.choices.each do |c|
+        c.side = s
+      end
+    end
+
+    card_places.each do |cards|
+      cards.hydrate!
+    end
+  end
+
+  def find_card(card_id)
+    raise "blank card id" if card_id.blank?
+    card_places.each do |cards|
+      res = cards.find { |x| x.card_id.to_s == card_id.to_s }
+      return res if res
+    end
+    raise "no card #{card_id}"
+  end
+
+  class << self
+    def reset!
+      Game.collection.remove
+      game = Game.new
+      side = Side.new(:game => game)
+      game.sides << side
+      game.sides << Side.new(:game => game)
+
+      game.deck = CenterDeck.starting
+      #game.deck << Parse.get("Mephit")
+      game.center.fill!
+      #side.deck << game.deck.get_one('Temple Librarian')
+      #side.deck[-1] = Card::Hero.arha
+
+      #side.deck << Parse.get("Shade ot Black Watch")
+      #side.deck << Parse.get("Seer of the Forked Path")
+      #side.deck << Parse.get("Demon Slayer")
+      game.sides.each do |s|
+        s.draw_hand!
+      end
+      #side.hand << game.deck.get_one('Void Thirster')
+      #side.deck << game.deck.get_one('Void Initiate')
+
+      game.mongo.save!
+      game
+    end
+  end
+end
+
+class Side
+  include FromHash
+  setup_mongo_persist :discard, :deck, :hand, :played, :constructs, :honor, :side_id, :choices
+  attr_accessor :game
+  fattr(:discard) { Discard.new(:side => self) }
+  fattr(:deck) { PlayerDeck.starting(:side => self) }
+  fattr(:hand) { Hand.new(:side => self) }
+  fattr(:played) { Played.new(:side => self) }
+  fattr(:constructs) { Constructs.new(:side => self) }
+  fattr(:honor) { 0 }
+  fattr(:side_id) { rand(100000000000000) }
+  fattr(:choices) { [] }
+
+  def draw_hand!
+    5.times { draw_one! }
+  end
+  def draw_one!
+    hand << deck.draw_one
+  end
+  def play(card)
+    played << card
+    hand.remove(card)
+  end
+  def acquire_free(card)
+    discard << card
+    game.center_wc.remove(card)
+    fire_event Event::CardPurchased.new(:card => card)
+  end
+  def purchase(card)
+    acquire_free(card)
+    #card.apply_abilities(self)
+    played.pool.runes -= card.rune_cost
+  end
+  def defeat(monster)
+    game.void << monster
+    game.center.remove(monster) unless monster.name =~ /cultist/i && !game.center.include?(monster)
+    
+    fire_event Event::MonsterKilled.new(:card => monster, :center => true)
+    
+    monster.apply_abilities(self)
+    played.pool.power -= monster.power_cost
+  end
+  def engage(card)
+    if card.monster?
+      defeat(card)
+    else
+      purchase(card)
+    end
+  end
+  def engageable_cards
+    game.center_wc.engageable_cards(self) 
+  end
+  def end_turn!
+    played.discard!
+    hand.discard!
+    constructs.apply!
+    draw_hand!
+    
+  end
+  def total_cards
+    [hand,played,deck,discard].map { |x| x.size }.sum
+  end
+  
+  fattr(:events) { Event::Events.new(:side => self) }
+  def fire_event(event)
+    events << event
+  end
+  def other_side
+    game.sides.reject { |x| x == self }.first
+  end
+  def print_status!
+    puts "Center " + game.center.to_s_cards
+    puts "Hand " + hand.to_s_cards
+    puts "Played " + played.to_s_cards
+    puts "Constructs " + constructs.to_s_cards unless constructs.empty?
+    puts "Pool " + played.pool.to_s
+  end
+end
+
+%w(card cards ability pool events parse turn_manager setup_rchoice).each do |f|
+  load File.dirname(__FILE__) + "/ascension/#{f}.rb"
+end

data/lib/ascension/Ascension-statistics_v1.csv

@@ -0,0 +1,49 @@
+"Realm Short","Card Type","Name","count","rune_cost","honor","runes","honor","power","+C","draw","banish_center","banish_hand","banish_discard","banish_hand_discard","discard_from_hand","special_ability","triggerable_ability","undefined"
+"V","H","Void Initiate",3,1,1,1,,,"(-1)",,,,,"o1",,,,
+"V","H","Spike Vixen",2,2,1,,,1,1,1,,,,,,,,
+"V","H","Shade ot Black Watch",3,3,1,,,2,"(-1)",,,,,"o1",,,,
+"V","C","Shadow Star",2,3,2,,,1,,,,,,,,,,
+"V","H","Arbiter ot Precipice",2,4,1,,,,"2-1",2,,1,,,,,,
+"V","H","Demon Slayer",2,4,2,,,3,,,,,,,,,,
+"V","C","Void Thirster",2,5,3,,"1 on first_center_monster_killed","1",,,,,,,,,,
+"V","H","Emeri One with the Void",1,6,3,,,4,,,,,,,,,,
+"V","C","Muramasa",1,7,4,,,3,,,,,,,,,,
+"E","H","Arha Initiate",3,1,1,,,,1,1,,,,,,,,
+"E","H","Temple Librarian",3,2,1,,,,"(2)",2,,,,,1,,,
+"E","H","Seer ot Forked Path",3,2,1,,,,1,1,"o1",,,,,,,
+"E","H","Twofold Askara",1,4,2,,,,,,,,,,,"copy_hero",,
+"E","H","Arha Templar",2,4,3,,,,,,,,,,,"kill_monster_4",,
+"E","H","Ascetic ot Lidless Eye",2,5,2,,,,2,2,,,,,,,,
+"E","C","Tablet of Times Dawn",1,5,2,,,,,,,,,,,,,
+"E","C","The All Seeing Eye",1,6,2,,,,1,,,,,,,,"draw_1",
+"E","H","Oziah the Peerless",1,6,3,,,,,,,,,,,"kill_monster_6",,
+"E","H","Master Dhartha",1,7,3,,,,3,3,,,,,,,,
+"L","H","Lifeblood Initiate",3,1,1,1,1,,,,,,,,,,,
+"L","H","Wolf Shaman",3,3,1,1,,,1,1,,,,,,,,
+"L","H","Runic Lycanthrope",2,3,1,2,,"2 if lifebound_hero_played",,,,,,,,,,
+"L","C","Yggdrasil Staff",2,4,2,,,"1",,,,,,,,,"4_rune_to_3_honor",
+"L","H","Druids ot Stone Circle",2,4,3,,,,,,,,,,,"acquire_hero_3",,
+"L","C","Snapdragon",2,5,2,1,"1 on first_lifebound_hero_played",,,,,,,,,,,
+"L","H","Flytrap Witch",2,5,2,,2,,1,1,,,,,,,,
+"L","H","Landtalker",1,6,3,3,,,,,,,,,,,,
+"L","H","Cetra Weaver ot Stars",1,7,4,,,,,,,,,,,"acquire_hero_10",,
+"M","H","Mechana Initiate",3,1,1,,,,,,,,,,,"power_or_rune_1",,
+"M","H","Kor the Ferromancer",1,3,2,,,2,"(1)","1 if 2_or_more_constructs",,,,,,,,
+"M","C","Burrower Mk II",2,3,3,,,,"(1)","1 on mechana_construct_played",,,,,,,,
+"M","H","Avatar Golem",2,4,2,,"1 foreach type_of_construct","2",,,,,,,,,,
+"M","H","Reactor Monk",2,4,2,"2, 1 for construct",,,,,,,,,,,,
+"M","C","Rocket Courier X-99",2,4,4,,,,,,,,,,,,,"something"
+"M","C","Watchmaker Altar",2,5,5,"1 for mechana",,,,,,,,,,,,
+"M","C","The Grand Deisgn",2,6,6,"2 for mechana",,,,,,,,,,,,
+"M","C","Hedron Link Device",1,7,7,,,,,,,,,,,,,"all_mechana"
+"M","C","Hedron Cannon",1,8,8,,,,,,,,,,,,"power_for_mechana",
+"S","M","Samael's Trickster",4,"3P","-",1,1,,,,,,,,,,,
+"S","M","Tormented Soul",3,"3P","-",,1,,1,,,,,,,,,
+"S","M","Mephit",3,"3P","-",,2,,,,"o1",,,,,,,
+"S","M","Corrosive Widow",4,"4P","-",,3,,,,,,,,,"discard_construct",,
+"S","M","Mistake of Creation",4,"4P","-",,4,,"(-1)",,"o1",,"o1",,,,,
+"S","M","Wind Tyrant",3,"5P","-",3,3,,,,,,,,,,,
+"S","M","Sea Tyrant",3,"5P","-",,5,,,,,,,,,"discard_all_but_one_construct",,
+"S","M","Earth Tyrant",2,"6P","-",,5,,2,2,,,,,,,,
+"S","M","Xeron Duke of Lies",1,"6P","-",,3,,,,,,,,,"take_opponents_card",,
+"S","M","Avatar ot Fallen",1,"7P","-",,4,,,,,,,,,"acquire_center",,

data/lib/ascension/ability.rb

@@ -0,0 +1,222 @@
+str = <<EOF
+Card
+  Ability
+    CardChoice
+      RChoice
+EOF
+
+module Ability
+  class ChoiceInstance
+    include FromHash
+    attr_accessor :choice, :side
+
+    setup_mongo_persist :choice, :choice_id
+    def addl_json_attributes
+      %w(choosable_cards name)
+    end
+    def name
+      choice.class.to_s
+    end
+
+    fattr(:choice_id) { rand(100000000000000) }
+
+    fattr(:choosable_cards) do
+      res = choice.choosable_cards(side)
+      res = res.cards if res.respond_to?(:cards)
+      res
+    end
+    def save!
+      side.choices << self
+    end
+
+    def execute!(chosen_card)
+      choice.action(chosen_card,side)
+      delete!
+    end
+
+    def delete!
+      side.choices -= [self]
+    end
+  end
+
+
+  class Base
+    fattr(:optional) { false }
+    include FromHash
+    attr_accessor :parent_card
+    setup_mongo_persist :parent_card
+    def call_until_nil(side)
+      loop do
+        choice = call(side)
+        yield if block_given?
+        return unless choice.choice.chosen_option && choosable_cards(side).size > 0
+      end
+    end
+    def choice_instance(side)
+      ChoiceInstance.new(:choice => self, :side => side)
+    end
+  end
+  
+  class BaseChoice < Base
+    def side_for_card_choice(side)
+      side
+    end
+    def card_choice(side)
+      CardChoice.new(:ability => self, :side => side_for_card_choice(side))
+    end
+    def call(side)
+      card_choice(side).tap { |x| x.run! }
+    end
+  end
+  
+  class CardChoice
+    include FromHash
+    attr_accessor :ability, :side
+    fattr(:choosable_cards) do
+      ability.choosable_cards(side)
+    end
+    class << self
+      fattr(:chooser) {}
+    end
+    fattr(:choice) do
+      res = RChoice::Choice.new(:optional => ability.optional, :name => ability.klass.to_s, :parent_obj => self)
+      choosable_cards.each do |card|
+        res.add_option card
+      end
+      res.action_blk = lambda { |card| ability.action(card,side) }
+      res.chooser = klass.chooser
+      res
+    end
+    def run!
+      choice.execute!
+    end
+  end
+
+  class Banish < BaseChoice
+  end
+  
+  class BanishCenter < Banish
+    def action(card,side)
+      side.game.center.banish(card)
+    end
+    def choosable_cards(side)
+      side.game.center
+    end
+  end
+  
+  class BanishHandDiscard < Banish
+    def action(card,side)
+      if side.hand.include?(card)
+        side.hand.banish(card)
+      else
+        side.discard.banish(card)
+      end
+    end
+    def choosable_cards(side)
+      side.hand.cards + side.discard.cards
+    end
+  end
+  
+  class EarnHonor < Base
+    attr_accessor :honor
+    def call(side)
+      side.game.honor -= honor
+      side.honor += honor
+    end
+  end
+  
+  class Draw < Base
+    def call(side)
+      side.draw_one!
+    end
+  end
+  
+  class DoCenterAction < BaseChoice
+    def optional; true; end
+    def choosable_cards(side)
+      side.game.center_wc.select { |x| can?(x,side) }
+    end
+    def can?(card,side)
+      if card.monster?
+        raise card.name unless card.power_cost
+        side.played.pool.power >= card.power_cost
+      else
+        side.played.pool.can_purchase?(card)
+      end
+    end
+    def action(card,side)
+      if card.monster?
+        side.defeat(card)
+      else
+        side.purchase(card)
+      end
+    end
+  end
+  
+  class KillMonster < BaseChoice
+    attr_accessor :max_power
+    def choosable_cards(side)
+      side.game.center_wc.select { |x| x.monster? && x.power_cost <= (max_power||99) }
+    end
+    def action(card,side)
+      side.defeat(card)
+    end
+  end
+  
+  class AcquireHero < BaseChoice
+    attr_accessor :max_rune_cost
+    def choosable_cards(side)
+      #side.game.center_wc.select { |x| x.hero? }.each { |x| puts [x.name,x.rune_cost].inspect }
+      side.game.center_wc.select { |x| x.hero? && x.rune_cost <= (max_rune_cost||99) }
+    end
+    def action(card,side)
+      side.purchase(card)
+    end
+  end
+  
+  class CopyHero < BaseChoice
+    def choosable_cards(side)
+      side.played
+    end
+    def action(card,side)
+      side.played.apply(card)
+    end
+  end
+
+  class OtherSideChoice < BaseChoice
+    def side_for_card_choice(side)
+      side.other_side
+    end
+  end
+  
+  class DiscardConstruct < OtherSideChoice
+    def choosable_cards(side)
+      side.constructs
+    end
+    def action(card,side)
+      side.constructs.discard(card)
+    end
+  end
+  
+  class KeepOneConstruct < OtherSideChoice
+    def choosable_cards(side)
+      side.constructs
+    end
+    def action(card,side)
+      other = side.constructs.reject { |x| x == card }
+      other.each do |o|
+        side.constructs.discard(o)
+      end
+    end
+  end
+  
+  class TakeOpponentsCard < BaseChoice
+    def choosable_cards(side)
+      side.other_side.hand
+    end
+    def action(card,side)
+      side.other_side.hand.remove(card)
+      side.hand << card
+    end
+  end
+end