essytas 0.0.1

data/lib/game/npc/goal.rb

@@ -0,0 +1,93 @@
+
+# FIXME policy = :recalc doesnt work
+
+module Core::Game
+  
+  class Goal
+    def initialize
+      @state = :before
+    end
+    def setup
+      @state = :progress
+    end
+    def state
+      return @state
+    end
+    def restart
+      @state = :before
+    end
+    def recalc
+      restart
+    end
+  end
+  
+  class MotionGoal < Goal
+    attr_reader :dx, :dy, :x, :y
+    attr_accessor :state
+    def initialize(dx, dy, x, y)
+      super()
+      @dx, @dy = dx, dy
+      @x, @y = x, y
+    end
+    def recalc
+      @state = :recalc
+    end
+  end
+  
+  class CompositeGoal < Array
+    attr_reader :state
+    def initialize(policy=:abort)
+      super()
+      @current = 0
+      @policy = policy
+      @state = :progress
+    end
+    def reset
+      self.clear
+      @current = 0
+      @state = :reset
+    end
+    def start
+      @state = :progress
+    end
+    def current
+      return self[@current]
+    end
+    def update
+      if @state == :progress
+        awesome_print(self) if !current
+        case current.state
+        when :before
+          if current.class != MotionGoal
+            current.setup
+          end
+        when :progress
+          return
+        when :failed
+          handle_failed
+        when :finished
+          advance
+        end
+      end
+    end
+    def advance
+      @current += 1
+      if @current == self.size
+        @state = :finished
+        @current = 0
+      end
+    end
+    private
+    def handle_failed
+      case @policy
+      when :abort
+        @state = :failed
+      when :retry
+        current.restart
+      when :recalc
+        current.recalc
+      end
+    end
+  end
+  
+end

data/lib/game/npc/npc.rb

@@ -0,0 +1,95 @@
+
+require_relative "goal.rb"
+require_relative "bubble.rb"
+
+# TODO move goal logic to mapobject
+
+module Core::Game
+  # Interactive map object
+  class MapNPC < MapObject
+    attr_accessor :behaviour
+    attr_reader :goal, :gamename, :children
+    def initialize(x, y, props)
+      super(x, y, props)
+      @x, @y = x, y
+      @behaviour = nil
+      @goal = CompositeGoal.new(:retry)
+      @speed = 2
+      @name = "npc-#{props[:file].downcase}-#{rand(1000)}"
+      @gamename = props[:name] ? props[:name] : @name
+      @children = []
+      @bubble = nil
+    end
+    
+    def setup
+      super
+      @behaviour.on_init if @behaviour
+    end
+    
+    # Generates a path from the current position to the given screen coordinates by using A*
+    def find_path_to(x, y)
+      #puts("from #{@x/32}|#{@y/32} to #{x}|#{y}")
+      curr = Core.window.state.map.current.astar(AStar::Node.new(@x/32, @y/32), AStar::Node.new(x, y))
+      @goal.reset
+      while curr and curr.parent
+        @goal.push(MotionGoal.new((curr.x - curr.parent.x) * 32, (curr.y - curr.parent.y) * 32, x, y))
+        curr = curr.parent
+      end
+      @goal.reverse!
+      @goal.start
+      return @goal
+    end
+    
+    def update
+      @children.each { |child|
+        if child.follow
+          child.x = @x + child.xoff
+          child.y = @y + child.yoff
+        end
+        child.update
+      }
+      @behaviour.on_update if @behaviour
+      moved = update_move(Core.window.state.map.current)
+      @goal.update if @goal.size > 0
+      if @goal.current.class == MotionGoal
+        if @goal.current.state == :recalc
+          @dx = @dy = 0
+          find_path_to(@goal.last.x, @goal.last.y)
+          @goal.update
+        end
+        if @dx == 0 and @dy == 0
+          if @goal.current.state == :before
+            @dx, @dy = @goal.current.dx, @goal.current.dy
+            @goal.current.state = :progress
+          elsif @goal.current.state == :progress
+            if moved
+              @goal.advance
+            else
+              @goal.current.state = :failed
+            end
+          end
+        end
+      end
+      if @bubble
+        @bubble.update
+        @bubble = nil if @bubble.remove?
+      end
+    end
+    
+    def draw(x, y)
+      super
+      @bubble.draw(@x+x, @y+y) if @bubble
+      @children.each { |child| child.draw(x, y) }
+    end
+    
+    # Displays a speech bubble with the given text
+    def talk(text)
+      @bubble = Bubble.new(text)
+    end
+    
+    def destroy_goal
+      @goal.reset
+    end
+    
+  end
+end

data/lib/game/npc/task.rb

@@ -0,0 +1,73 @@
+
+module Core::Game::NPC
+  
+  class Task
+    # action: proc to execute
+    # wait: stall later tasks until this one finished
+    # remove_after: delete task when finished
+    def initialize(parameters)
+      @array = parameters
+      @finished = false
+      @current = 0
+    end
+  
+    def execute(npc, other=nil)
+      if !@array.empty? and !@finished
+        send(@array[@current].first, @array[@current], npc, other)
+      end
+    end
+    
+    def empty?
+      return @array.empty?
+    end
+  
+    def finished?
+      return @finished
+    end
+    
+    def reset
+      @finished = false
+    end
+    
+    def next_subtask(npc, other)
+      if @array[@current].include?(:remove)
+        @array.delete_at(@current)
+      else
+        @current += 1
+      end
+      if @current >= @array.size
+        @current = 0
+        return
+      end
+      if !@array[@current-1].include?(:wait)
+        execute(npc, other)
+      end
+    end
+    
+    private
+    
+    def particles(parms, npc, other)
+      npc.children.push(Core::Game::MapParticle.new(parms[1].x, parms[1].y, parms[2]))
+      npc.children.last.xoff = npc.children.last.yoff = 16
+      if parms.include?(:follow)
+        npc.children.last.follow = true
+      end
+      next_subtask(npc, other)
+    end
+    
+    def path_to(parms, npc, other)
+      if npc.goal.state != :progress
+        next_subtask(npc, other)
+        npc.find_path_to(parms[1].x, parms[1].y)
+        npc.goal.start
+      end
+    end
+    
+    def msg(parms, npc, other)
+      Core.window.state.map.message(parms[1])
+      next_subtask(npc, other)
+    end
+  
+  end
+  
+end

data/lib/game/osd/magic.rb

@@ -0,0 +1,24 @@
+
+module Core::Game
+  module OSD
+  
+    class Magic < Core::GUI::Window
+      def initialize(x, y, caster=Core::Game.party.player, target=nil)
+        if x + 640 > 1024
+          x = 386
+        elsif x < 0
+          x = 0
+        end
+        if y + 480 > 768
+          y = 264
+        elsif y < 0
+          y = 0
+        end
+        super(x, y, 640, 480, Core::Trans.menu(:magic), true, "osd/magic_bg", true)
+        @caster, @target = caster, target
+        add(:char, Core::GUI::CharSelector.new(16, 16, @state.party))
+      end
+    end
+  
+  end  
+end

data/lib/game/party.rb

@@ -0,0 +1,42 @@
+
+require_relative "character.rb"
+
+module Core::Game
+  
+  # TODO < Array
+  class Party
+    attr_accessor :location, :player_index
+    def initialize
+      @members = []
+      @members += Core::Game.characters
+      @player_index = 0
+      @location = ""
+      (Core::Game.items.size * 5).times { @members[0].inventory.add(Core::Game.items.sample) }
+      @members[0].equipment.equip(Core::Game.items[1], :rarm, @members[0].inventory)
+    end
+    def add(char)
+      @members.push(char)
+    end
+    def remove(char)
+      @members.delete(char)
+    end
+    def members
+      return @members
+    end
+    def update
+      @members.each { |m|
+        m.update
+      }
+    end
+    def player
+      return @members[@player_index]
+    end
+  end
+  
+  # Character states
+  NORMAL = 0
+  ASLEEP = 1
+  DEAD = 2
+  UNCONSCIOUS = 3
+  
+end

data/lib/game/skills.rb

@@ -0,0 +1,64 @@
+
+module Core::Game
+  @skills = []
+  
+  def self.skills
+    return @skills
+  end
+  
+  def self.skills=(ary)
+    @skills = ary
+  end
+  
+  def self.find_skill(name)
+    @skills.each { |skill|
+      if skill.name == name
+        return skill
+      end
+    }
+  end
+  
+  class Skill
+    attr_reader :name, :desc, :img
+  end
+  
+  # skills and their respective levels, instanced once for every character
+  class Skills
+    def initialize
+      @skills = {}
+      Core::Game.skills.each { |skill|
+        @skills.store(skill, 0)
+      }
+    end
+    
+    def list
+      return @skills
+    end
+    
+    def advance(skill)
+      @skills.each { |s|
+        if skill.class == s.class
+          @skills[s] += 1
+        end
+      }
+    end
+    
+    def level_to_s(skill)
+      lvl = @skills[skill]
+      case lvl
+      when 0
+        return Core::Trans.menu(:xp_none)
+      when 1
+        return Core::Trans.menu(:xp_vlittle)
+      when 2
+        return Core::Trans.menu(:xp_little)
+      when 3
+        return Core::Trans.menu(:xp_mediocre)
+      when 4
+        return Core::Trans.menu(:xp_experienced)
+      when 5
+        return Core::Trans.menu(:xp_vexperienced)
+      end
+    end
+  end
+end

data/lib/game/spell.rb

@@ -0,0 +1,35 @@
+
+require_relative "../def/spells.rb"
+
+module Core::Game
+  
+  def self.spells
+    return @spells
+  end
+  
+  def self.spells=(ary)
+    @spells = ary
+  end
+  
+  def self.find_spell(name)
+    @spells.each { |spell|
+      if spell.name == name
+        return spell
+      end
+    }
+    return nil
+  end
+  
+  class Spell
+    attr_reader :name, :icon, :type, :cost
+    def cast(caster, target=nil)
+      puts("#{caster} casts #{self.name} on #{target}")
+      if Core::Game::Spells.respond_to?(self.name)
+        Core::Game::Spells.send(self.name)
+      else
+        puts("ERROR: No ruby definition for spell #{self.name} found")
+      end 
+    end
+  end
+  
+end

data/lib/game_window.rb

@@ -0,0 +1,95 @@
+
+#--
+# Main state logic - obviously
+
+if Core.config[:opengl]
+  require_relative "ext/shader.rb"
+end
+
+require_relative "particles.rb"
+require_relative "animation.rb"
+
+module Core
+
+  class GameWindow < Gosu::Window
+
+    attr_accessor :state, :saved
+
+    include States
+
+    def initialize
+      super(1024, 768, false)
+      self.caption = "Essytas - v#{Core::VERSION}"
+      Core.window = self
+      Core.particles = Core::Parse.particles
+      Core.animations = Core::Parse.animations
+      @state = StartMenu.new(self)
+      @unpress = []
+      @font = Core.font(Core::DEFAULT_FONT, 20)
+      @bg = Core.sprite("pixel", true)
+      if (Core.config[:contrast] != 1.0 and Core.config[:opengl])
+        @contrast = Shader.new(self, "glsl/contrast")
+        @contrast["contrast"] = Core.config[:contrast]
+      else
+        @contrast = nil
+      end
+    end
+
+    def update
+      @state.update
+      unpress
+      self.caption = "Essytas - v#{Core::VERSION} - #{Gosu.fps} FPS"
+    end
+
+    def draw
+      @state.draw
+      if $DEBUG
+        @bg.draw(16, 16, 999999, 160, 48, 0x99000000)
+        @font.draw("Mouse: #{mouse_x.to_i}|#{mouse_y.to_i}", 32, 32, 999999)
+      end
+      if @contrast
+        @contrast.apply
+      end
+    end
+
+    # Advance to the next state
+    # 
+    # Requires an EH::States::State instance
+    def advance(state)
+      @state.finish
+      @state = state
+    end
+
+    # Save current state so we can go back to it later
+    #
+    # The GameState is saved when switching to a MenuState
+    def save
+      @saved = @state
+    end
+    
+    def load
+      @state = @saved
+    end
+    # Checks if a specific key is pressed
+    # 
+    # Only returns true again if the key was held loose
+    def pressed?(key)
+      p = button_down?(key)
+      if p
+        if @unpress.include?(key)
+          p = false
+        else
+          @unpress.push(key)
+        end
+      end
+      return p
+    end
+    def unpress
+      @unpress.each { |key|
+        if !button_down?(key)
+          @unpress.delete(key)
+        end
+      }
+    end
+  end
+end