essytas 0.0.1

data/lib/def/skills.def

@@ -0,0 +1,40 @@
+
+{
+name = healing
+icon = "skills/healing"
+}
+
+{
+name = crafting
+icon = "skills/crafting"
+}
+
+{
+name = botany
+icon = "skills/botany"
+}
+
+{
+name = healing_magic
+icon = "skills/healing_magic"
+}
+
+{
+name = mind
+icon = "skills/mind"
+}
+
+{
+name = elemental
+icon = "skills/elemental"
+}
+
+{
+name = ranged
+icon = "skills/ranged"
+}
+
+{
+name = melee
+icon = "skills/melee"
+}

data/lib/def/spells.def

@@ -0,0 +1,42 @@
+
+# Healing
+
+{
+name = stop_bleed
+icon = "spells/stop_bleed"
+type = healing
+cost = 2
+}
+
+# Mind
+
+{
+name = protect
+icon = "spells/protect"
+type = mind
+cost = 1
+}
+
+# Elemental
+
+{
+name = heat
+icon = "spells/heat"
+type = elemental
+cost = 10
+}
+
+{
+name = cold
+icon = "spells/cold"
+type = elemental
+cost = 10
+}
+
+#EOF
+{
+name = 
+icon = "spells/"
+type = 
+cost = 
+}

data/lib/def/spells.rb

@@ -0,0 +1,16 @@
+
+module Core::Game::Spells
+  
+  def self.stop_bleed
+    puts("stop_bleed")
+  end
+  
+  def self.heat
+    puts("heat")
+  end
+  
+  def self.cold
+    puts("cold")
+  end
+  
+end

data/lib/def/weapons.def

@@ -0,0 +1,9 @@
+
+# Only used for weapons which do not have an item
+
+claw
+{
+icon = "claw"
+type = melee
+effects = [damage, bleed_rare]
+}

data/lib/ext/astar/AMap.rb

@@ -0,0 +1,146 @@
+#AStar Map
+#by Marcin Coles
+#27/Sep/2007
+require_relative 'priority_queue.rb'
+require_relative 'node.rb'
+
+module AStar
+
+  class AMap
+    attr_reader :nodes
+    def initialize(costmap)
+      #cost map is a 2D array - eg a 2x2 map is AMap.new([[3,5],[3,2]])
+      # the values are the movement cost for the node at those co-ordinates
+      #should do some error checking for size of the map, but anyway
+      # note that the costmap array is indexed @costmap[y][x], 
+      # which is the opposite way to Node(x,y)
+      ##note that it's probably easier to use AMap.load(file)
+      @costmap=costmap
+      @height=costmap.size
+      @width=costmap.first.size
+      @nodes=[]
+      @output="\n"
+      costmap.each_index do |row|
+        costmap[row].each_index do |col|
+          @nodes.push(Node.new(col,row,costmap[row][col]))
+          @output<<"|#{costmap[row][col]}"
+        end
+        @output<<"|\n"
+      end
+    end
+    
+    def self.load(filename)
+      #loads a map from a text file - see map.txt for example, reproduced here
+      #~ 1,1,1,1,1,1
+      #~ 1,2,2,2,2,1
+      #~ 1,3,3,3,3,1
+      #~ 1,3,3,3,3,1
+      #~ 1,2,2,2,2,1
+      #~ 1,1,1,1,1,1
+      mmap=[]
+      File.open(filename) do |f|
+        f.each_line do |line|
+          linearr=[]
+          line.chomp.split(',').each do |e|
+            linearr.push(e.to_i)
+          end
+          mmap.push(linearr)
+        end
+      end
+      return AMap.new(mmap)
+    end
+    
+    def generate_successor_nodes(anode)
+      # determine nodes bordering this one - only North,S,E,W for now
+      # no boundary condition check, eg if anode.x==-4
+      # considers a wall to be a 0 so therefore not allow that to be a neighbour
+      north=@costmap[anode.y-1][(anode.x)] unless (anode.y-1)<0 #boundary check for -1
+      south=@costmap[anode.y+1][(anode.x)] unless (anode.y+1)>(@height-1)
+      east=@costmap[anode.y][(anode.x+1)] unless (anode.x+1)>(@width-1)
+      west=@costmap[anode.y][(anode.x-1)] unless (anode.x-1)<0 #boundary check for -1
+      
+      if (west && west>0) then # not on left edge, so provide a left-bordering node
+        newnode=Node.new((anode.x-1),anode.y,@costmap[anode.y][(anode.x-1)])
+        yield newnode
+      end
+      if (east && east>0) then # not on right edge, so provide a right-bordering node
+        newnode=Node.new((anode.x+1),anode.y,@costmap[anode.y][(anode.x+1)])
+        yield newnode
+      end
+      if (north && north>0) then # not on left edge, so provide a left-bordering node
+        newnode=Node.new(anode.x,(anode.y-1),@costmap[(anode.y-1)][anode.x])
+        yield newnode
+      end
+      if (south && south>0) then # not on right edge, so provide a right-bordering node
+        newnode=Node.new(anode.x,(anode.y+1),@costmap[(anode.y+1)][anode.x])
+        yield newnode
+      end    
+    end
+
+    def astar(node_start,node_goal)
+      iterations=0
+      open=PriorityQueue.new()
+      closed=PriorityQueue.new()
+      node_start.calc_h(node_goal)
+      open.push(node_start)
+      while !open.empty? do
+        iterations+=1 #keep track of how many times this itersates
+        node_current=open.find_best
+        if node_current==node_goal then #found the solution
+          puts "Iterations: #{iterations}"
+          return node_current 
+        end       
+        generate_successor_nodes(node_current) do |node_successor|
+          #now doing for each successor node of node_current
+          node_successor.calc_g(node_current)
+          #skip to next node_successor if better one already on open or closed list
+          if open_successor=open.find(node_successor) then 
+            if open_successor<=node_successor then next end  #need to account for nil result
+          end
+          if closed_successor=closed.find(node_successor) then
+            if closed_successor<=node_successor then next end 
+          end
+          #still here, then there's no better node yet, so remove any copies of this node on open/closed lists
+          open.remove(node_successor)
+          closed.remove(node_successor)
+          # set the parent node of node_successor to node_current
+          node_successor.parent=node_current
+          # set h to be the estimated distance to node_goal using the heuristic
+          node_successor.calc_h(node_goal)
+          # so now we know this is the best copy of the node so far, so put it onto the open list
+          open.push(node_successor)
+        end
+        #now we've gone through all the successors, so the current node can be closed
+        closed.push(node_current)
+      end
+    end
+      
+    def co_ord(x,y)
+      a=Node.new(x,y)
+      @nodes.find {|n| n==a}
+    end
+    
+    def to_s
+      @output
+    end
+    
+    def show_path(anode)
+      #shows the path back from node 'anode' by following the parent pointer
+      curr=anode
+      pathmap=@costmap.clone
+      while curr.parent do
+        pathmap[curr.y][curr.x]='*'
+        curr=curr.parent
+      end
+      pathmap[curr.y][curr.x]='*'
+      pathstr="\n"
+      pathmap.each_index do |row|
+        pathmap[row].each_index do |col|
+          pathstr<<"|#{pathmap[row][col]}"
+        end
+        pathstr<<"|\n"
+      end
+      pathstr
+    end
+  end
+end

data/lib/ext/astar/node.rb

@@ -0,0 +1,72 @@
+#AStar map Node
+#by Marcin Coles
+#27/Sep/2007
+module AStar
+
+  class Node
+    #class Node provides a node on a map which can be used for pathfinding. 
+    #For Node to work with PriorityQueue and AMap it needs to implement the following
+    # <= used for comparing g values
+    # == used for finding the same node - using the x,y co-ordinates
+    attr_accessor :parent
+    attr_reader :x,:y,:g,:h,:m
+    
+    def initialize(x,y,move_cost=0)
+      @x,@y,@m=x,y,move_cost
+      @g=@m
+      @h=0
+    end
+    
+    def to_s
+      #prints the node in the following format [x,y] f:g:h
+      "[#{@x},#{@y}] #{@g+@h}:#{@g}:#{@h}"
+    end
+    
+    def <=>(other)
+      #can be used for ordering the priority list
+      #puts "using <=>" #currently unused - can delete this line if required
+      self.f<=>other.f
+    end
+    
+    def <=(other)
+      #used for comparing cost so far
+      @g<=other.g
+    end
+     
+    def ==(other)
+      # nodes are == if x and y are the same - used for finding and removing same node
+      return false if other==nil
+      return (@x==other.x)&(@y==other.y)
+    end
+    
+    def calc_g(previous)
+      #cost so far is total cost of previous step plus the movement cost of this one
+      @g=previous.g+@m
+    end
+    
+    def calc_h(goal)
+      #using manhattan distance to generate a heuristic value
+      @h=(@x-goal.x).abs+(@y-goal.y).abs
+    end
+    def f
+      @g+@h
+    end
+    def better?(other,tbmul=1.01)
+      #which is better, self or other
+      #can pass a tie-breaker multiplier (tbmul) if required
+      if other==nil then return false end
+      if self==other then return false end
+      if f<other.f then 
+        return true
+      #here's the tie-breaker
+      elsif f==other.f then
+        nf=@g+tbmul*@h
+        bf=other.g+tbmul*other.h
+        if nf<bf then return true end
+      end
+      false
+    end
+      
+  end
+end
+  

data/lib/ext/astar/priority_queue.rb

@@ -0,0 +1,44 @@
+#AStar PriorityQueue
+#by Marcin Coles
+#27/Sep/2007
+#note - not really a priority queue at this point
+
+require_relative "node.rb"
+
+module AStar
+
+  class PriorityQueue
+    def initialize(nodes=[])
+      @nodes=nodes
+      #tie-breaker multiplier (tbmul) is 1+1/(the sqrt of the map size)
+      @tbmul=1+1/(Math.sqrt(@nodes.size))
+    end
+    def method_missing(methodname, *args)
+      #if in doubt, act like an array
+      @nodes.send(methodname, *args)
+    end
+    def find_best
+      #finds the best node, then pops it out
+      best=@nodes.first
+      @nodes.each do |node|
+        if node.better?(best,@tbmul) then best=node end
+      end
+      remove(best)
+    end
+    def find(node)
+      #finds a node - requires that node implements ==
+      @nodes.find {|x| x==node }
+    end
+    
+    def remove(node)
+      #removes a node
+      @nodes.delete(find(node))
+    end
+    
+    def to_s
+      output=""
+      @nodes.each {|e| output<<"#{e};"}
+    end
+    
+  end
+end

data/lib/ext/shader.rb

@@ -0,0 +1,116 @@
+
+class Shader
+  include Gl
+  
+  attr_reader :window, :shader_filename
+  attr_reader :program_id, :vertex_shader_id, :fragment_shader_id
+  
+  @@canvas_texture_id = nil
+  
+  def initialize(window, shader_filename)
+    @window = window
+    @shader_filename = shader_filename
+    
+    @program_id = nil
+    @vertex_shader_id = nil
+    @fragment_shader_id = nil
+    
+    create_canvas unless @@canvas_texture_id
+    compile
+  end
+  
+  def apply
+    @window.gl do
+      # copy frame buffer to canvas texture
+      glBindTexture(GL_TEXTURE_2D, @@canvas_texture_id)
+      glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0, @window.width, @window.height, 0)
+      
+      # apply shader
+      glUseProgram(@program_id)
+      
+      # clear screen
+      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+      glColor4f(1.0, 1.0, 1.0, 1.0)
+      glMatrixMode(GL_PROJECTION)
+      glPushMatrix
+      glLoadIdentity
+      glViewport(0, 0, @window.width, @window.height)
+      glOrtho(0, @window.width, @window.height, 0, -1, 1)
+      
+      # draw processed canvas texture over the screen
+      glBindTexture(GL_TEXTURE_2D, @@canvas_texture_id)
+      
+      glBegin(GL_QUADS)
+      glTexCoord2f(0.0, 1.0); glVertex2f(0.0,           0.0)
+      glTexCoord2f(1.0, 1.0); glVertex2f(@window.width, 0.0)
+      glTexCoord2f(1.0, 0.0); glVertex2f(@window.width, @window.height)
+      glTexCoord2f(0.0, 0.0); glVertex2f(0.0,           @window.height)
+      glEnd
+      
+      # done, disable shader
+      glUseProgram(0)
+      
+      # and out
+      glPopMatrix
+    end
+  end
+  
+  def uniform(name, value)
+    glUseProgram(@program_id)
+    if value.is_a?(Float)
+      glUniform1f(glGetUniformLocation(@program_id, name), value)
+    elsif value.is_a?(Integer)
+      glUniform1i(glGetUniformLocation(@program_id, name), value)
+    else
+      raise ArgumentError, "Uniform data type not supported"
+    end
+    glUseProgram(0)
+  end
+  
+  alias []= uniform
+  
+  private
+  
+  def create_canvas
+    @@canvas_texture_id = glGenTextures(1).first
+    glBindTexture(GL_TEXTURE_2D, @@canvas_texture_id)
+    glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, 1)
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, @window.width, @window.height, 0, GL_RGB, GL_UNSIGNED_BYTE, "\0" * @window.width * @window.height * 3)
+    return @@canvas_texture_id
+  end
+  
+  def compile
+    # create program
+    @program_id = glCreateProgram
+    
+    # create vertex shader
+    @vertex_shader_id = glCreateShader(GL_VERTEX_SHADER)
+    puts("INFO: Compiling vertex shader (#{@shader_filename})")
+    if File.exist?(@shader_filename + ".vert")
+      glShaderSource(@vertex_shader_id, File.read(@shader_filename + ".vert"))
+    else
+      glShaderSource(@vertex_shader_id, "void main(void)\r\n{\r\ngl_Position = ftransform();\r\ngl_TexCoord[0] = gl_MultiTexCoord0;\r\n}\r\n")
+    end
+    glCompileShader(@vertex_shader_id)
+    glAttachShader(@program_id, @vertex_shader_id)
+    
+    # create fragment shader
+    @fragment_shader_id = glCreateShader(GL_FRAGMENT_SHADER)
+    puts("INFO: Compiling fragment shader (#{@shader_filename})")
+    glShaderSource(@fragment_shader_id, File.read(@shader_filename + ".frag"))
+    glCompileShader(@fragment_shader_id)
+    glAttachShader(@program_id, @fragment_shader_id)
+    
+    # compile program
+    glLinkProgram(@program_id)
+    
+    # check for compile errors
+    unless glGetProgramiv(@program_id, GL_LINK_STATUS) == GL_TRUE
+      raise glGetProgramInfoLog(@program_id).chomp
+    end
+    
+    return @program_id
+  end
+end