essytas 0.0.1

data/lib/game/combat/control.rb

@@ -0,0 +1,18 @@
+
+module Core::Game::Combat
+  
+  # Used for scripted battles (dialogues and stuff)
+  class Control
+    def initialize(battle)
+      @battle = nil
+    end
+    def battle=(b)
+      @battle = b
+    end
+    def update
+    end
+    def draw
+    end
+  end
+  
+end

data/lib/game/combat/gui.rb

@@ -0,0 +1,190 @@
+
+require_relative "gui/select_spell.rb"
+require_relative "gui/select_item.rb"
+
+module Core::Game::Combat
+  
+  class GUI
+    
+    attr_reader :attacking, :casting, :using
+    
+    def initialize
+      @x = 0
+      @y = 544
+      @z = 5000
+      @bg = Core.sprite("gui/battle_infoback")
+      @w = {} # Currently shown windows
+      @ready = []
+      @paused = false
+      @chosen = @choose = nil
+      @attacking = []
+      @casting = []
+      @using = []
+      @add = {}
+    end
+      
+    def push(type, *parms)
+      case type
+      when :ready
+        ready(parms)
+      end
+    end
+      
+    def open_info(obj, x, y)
+      if @choose and !@chosen
+        @chosen = obj
+      else
+        if Core.config[:combat_gui_info_window_x]
+          x = Core.config[:combat_gui_info_window_x]
+        end
+        if Core.config[:combat_gui_info_window_y]
+          y = Core.config[:combat_gui_info_window_y]
+        end
+        @w[:info] = Core::GUI::Window.new(x, y, 320, 256, "Info", true, "gui/container_background", true)
+        @w[:info].add(:text, Core::GUI::Textfield.new(8, 8, 304, 240, "#{obj}"))
+        @w[:info].title = "#{Core::Trans.enemy(obj.data.name)}"
+        @w[:info].save_pos(:combat_gui_info_window_x, :combat_gui_info_window_y)
+      end
+    end
+      
+    def update
+      @w.each_value { |w|
+        w.update
+        if w.remove?
+          @w.delete(@w.key(w))
+        end
+      }
+      @add.each do |k, v|
+        @w.store(k, v)
+      end
+      @add = {}
+      w = @w[:select_spell]
+      if w and w.selected
+        @choose = lambda { cast(w.actor, @chosen, w.selected) }
+      end
+      if @choose and @chosen
+        @choose.call
+      end
+    end
+      
+    def draw
+      @bg.draw(@x, @y, @z, 1024/@bg.width.to_f, 224/@bg.height.to_f)
+      @w.each_value { |w|
+        w.draw
+      }
+    end
+    
+    def paused?
+      return @paused
+    end
+    
+    def attacked
+      @attacking = []
+    end
+    
+    def spell_cast
+      @casting = []
+    end
+    
+    def item_used
+      @using = []
+    end
+    
+    def abort_action(actor)
+      @paused = false
+      @choose = nil
+      @chosen = nil
+      @w[:select_spell].close! if @w[:select_spell]
+      @w[:select_item].close! if @w[:select_item]
+      setup_ready_actions(actor)
+    end
+    
+    private
+    
+    def attack(attacker, target)
+      @attacking = [attacker, target]
+      shift_ready
+      abort_action(@ready.first)
+    end
+    
+    def cast(attacker, target, spell)
+      @casting = [attacker, target, spell]
+      shift_ready
+      abort_action(@ready.first)
+    end
+    
+    def use(attacker, target, item)
+      @using = [attacker, target, item]
+      shift_ready
+      abort_action(@ready.first)
+    end
+    
+    def ready(ary)
+      actor = ary.first
+      char = actor.character
+      if @ready.empty?
+        @w[:ready] = Core::GUI::Window.new(768, @y, 256, 224, char.name, false, "gui/container_background")
+        setup_ready_actions(actor)
+      end
+      @ready.push(actor)
+    end
+    
+    def shift_ready
+      if @ready.empty?
+        @w.delete(:ready)
+      else
+        @ready.shift
+        if @ready.empty?
+          @w[:ready].close!
+        else
+          @w[:ready].title = @ready.first.character.name
+          setup_ready_actions(@ready.first.character)
+        end
+      end
+    end
+    
+    def setup_ready_actions(actor)
+      w = @w[:ready]
+      w.empty
+      w.add(:attack, Core::GUI::Button.new(8, 8, 240, 32, Core::Trans.menu(:attack), lambda {open_attack(actor)}))
+      w.add(:skill, Core::GUI::Button.new(8, 48, 240, 32, Core::Trans.menu(:magic), lambda {open_spell(actor)}))
+      w.add(:item, Core::GUI::Button.new(8, 88, 240, 32, Core::Trans.menu(:item), lambda {open_item(actor)}))
+    end
+    
+    def open_attack(actor)
+      @paused = true
+      @choose = lambda { attack(actor, @chosen) }
+      open_abort(actor)
+    end
+    
+    def open_spell(actor)
+      @paused = true
+      if Core.config[:combat_gui_spell_select_window_x]
+        x = Core.config[:combat_gui_spell_select_window_x]
+      else
+        x = 192
+      end
+      if Core.config[:combat_gui_spell_select_window_y]
+        y = Core.config[:combat_gui_spell_select_window_y]
+      else
+        y = 192
+      end
+      @add.store(:select_spell, SelectSpell.new(x, y, actor))
+      @add[:select_spell].parent = self
+      open_abort(actor)
+    end
+    
+    def open_item(actor)
+      puts("STUB: GUI.open_item")
+      @paused = true
+      open_abort(actor)
+    end
+    
+    def open_abort(actor)
+      @w[:ready].empty
+      @w[:ready].add(:abort, Core::GUI::Button.new(8, 8, 240, 32, Core::Trans.menu(:abort), lambda {abort_action(actor)}))
+    end
+    
+  end
+
+end

data/lib/game/combat/gui/select_item.rb

@@ -0,0 +1,11 @@
+
+module Core::Game::Combat
+  
+  class SelectItem < Core::GUI::Window
+    
+    def initialize(x, y, actor)
+    end
+    
+  end
+  
+end

data/lib/game/combat/gui/select_spell.rb

@@ -0,0 +1,38 @@
+
+module Core::Game::Combat
+  
+  class SelectSpell < Core::GUI::Window
+    
+    attr_reader :selected, :actor
+    
+    def initialize(x, y, actor)
+      super(x, y, 384, 256, Core::Trans.menu(:select_spell), true, "gui/container_background", true)
+      @close.proc = lambda { close!; @parent.abort_action(actor) }
+      save_pos(:combat_gui_spell_select_window_x, :combat_gui_spell_select_window_y)
+      add(:container, Core::GUI::Container.new(8, 8, 184, 240, 24))
+      add(:info, Core::GUI::Textfield.new(200, 8, 176, 240, ""))
+      @actor = actor
+      setup_skill_select
+      @selected = nil
+    end
+    
+    private
+    
+    def setup_skill_select
+      char = @actor.character
+      c = get(:container)
+      y = 8
+      char.spells.each { |spell, level|
+        c.add(Core::GUI::Button.new(0, y, c.w-24, c.ch, Core::Trans.spell(spell.name), lambda { clicked(spell) }))
+        y += c.ch
+      }
+    end
+    
+    def clicked(spell)
+      get(:info).text = Core::Trans.spell("#{spell.name}_desc".to_sym)
+      @selected = spell
+    end
+    
+  end
+  
+end

data/lib/game/constitution.rb

@@ -0,0 +1,48 @@
+
+module Core::Game
+  WOUND_LOCATIONS = [:head, :neck, :torso, :abdomen, :leg, :foot, :arm]
+  class Wound
+    attr_reader :location, :severity
+    def initialize(location, severity)
+      if !WOUND_LOCATIONS.include?(location)
+        puts("WARNING: Unknown wound location #{location}")
+      end
+      @location = location
+      @severity = severity
+    end
+    def location_factor
+      case @location
+      when :head
+        return 5
+      when :neck
+        return 3
+      when :torso
+        return 2
+      when :abdomen
+        return 3
+      when :leg
+        return 1
+      when :foot
+        return 1
+      when :arm
+        return 2
+      else
+        return 1
+      end
+    end
+  end
+  
+  class Constitution
+    def initialize
+      @wounds = []
+    end
+    # this should only be called when needed
+    def update(char)
+      str = char.strength
+      dmg = 0
+      @wounds.each { |w|
+        dmg += w.severity * w.location_factor
+      }
+    end
+  end
+end

data/lib/game/equipment.rb

@@ -0,0 +1,34 @@
+
+module Core::Game
+  class Equipment < Hash
+    @@locations = [
+      :head,
+      :torso,
+      :larm,
+      :rarm,
+      :legs,
+      :feet,
+      :back,
+    ]
+    def initialize
+      super
+    end
+    def equip(item, location, inventory)
+      if @@locations.include?(location)
+        inventory.remove(item)
+        ret = self[location]
+        inventory.add(ret) if ret
+        self.store(location, item)
+        return ret
+      end
+    end
+    def remove_at(location)
+      ret = self[location]
+      self[location] = nil
+      return ret
+    end
+    def at(loc)
+      return self[loc]
+    end
+  end
+end

data/lib/game/inventory.rb

@@ -0,0 +1,37 @@
+
+module Core::Game
+  # strength is an arbitrary unit; in this context it's 1 str == 1 kg of carrying
+  class Inventory < Array
+    attr_accessor :capacity, :strength
+    def initialize(capacity, strength)
+      super(capacity)
+      @capacity = capacity
+      @strength = strength
+      self.clear
+    end
+    def add(item)
+      if self.size + 1 < @capacity and item.weight + weight < @strength
+        self.push(item)
+      end
+    end
+    def remove(item, times=1)
+      removed = 0
+      self.each { |other_item|
+        if other_item.name == item.name
+          self.delete_at(self.index(other_item))
+          removed += 1
+        end
+        if removed >= times
+          return
+        end
+      }
+    end
+    def weight
+      weight = 0
+      self.each { |item|
+        weight += item.weight
+      }
+      return weight
+    end
+  end
+end

data/lib/game/item.rb

@@ -0,0 +1,54 @@
+
+module Core::Game
+  
+  class Item
+    attr_reader :name, :desc, :icon, :weight, :effects, :type, :img
+    attr_reader :icon_file
+  end
+  
+  def self.items
+    return @items
+  end
+  
+  def self.items=(ary)
+    @items = ary
+  end
+  
+  def self.find_item(name)
+    @items.each { |item|
+      if item.name == name
+        return item
+      end
+    }
+  end
+  
+  def self.itemtype_to_locations(type, equip)
+    ary = []
+    case type
+    when :armor
+      ary = [:torso]
+    when :cloth
+      ary = [:torso]
+    when :melee
+      ary = []
+      if equip.at(:rarm) != nil and equip.at(:rarm).type != :ranged
+        ary = [:larm, :rarm]
+      elsif equip.at(:rarm) == nil
+        ary = [:larm, :rarm]
+      end
+    when :pants
+      ary = [:legs]
+    when :boots
+      ary = [:feet]
+    when :ranged
+      ary = [:back]
+      if equip.at(:larm) == nil
+        ary.push(:rarm)
+      end
+    when :ammo
+      ary = [:back]
+    end
+    return ary
+  end
+  
+end

data/lib/game/magic.rb

@@ -0,0 +1,33 @@
+
+# Characters use this class to manage spells and casting
+
+module Core::Game
+  
+  class Magic
+    attr_reader :learned
+    def initialize(char)
+      @char = char
+      @learned = []
+    end
+    
+    def learn(spell)
+      @learned.push(spell) if !@learned.include?(spell)
+    end
+    
+    def forget(spell)
+      @learned.delete(spell)
+    end
+    
+    def cast(spell, caster, target=nil)
+      if @learned.include?(spell) and @char.state == Core::Game::NORMAL
+        spell.cast(caster, target)
+      end
+    end
+    
+    def cast_named(name, caster, target=nil)
+      cast(Core::Game.find_spell(name), caster, target)
+    end
+    
+  end
+  
+end