essytas 0.0.1

data/lib/game/map/events.rb

@@ -0,0 +1,29 @@
+
+module Core::Game
+  module Events
+
+    class Event
+      attr_reader :object
+      def initialize(obj)
+        @object = obj
+      end
+    end
+
+    class MotionEvent < Event
+      attr_reader :old_pos
+      def initialize(npc, old_pos)
+        super(npc)
+        @old_pos = old_pos
+      end
+    end
+
+    class TriggerEvent < Event
+      attr_reader :other
+      def initialize(activator, other)
+        super(activator)
+        @other = other
+      end
+    end
+
+  end
+end

data/lib/game/map/fog.rb

@@ -0,0 +1,41 @@
+
+module Core::Game
+  
+  class Fog
+    
+    def initialize(file, sx, sy, a=255, r=255, g=255, b=255)
+      @img = Core.sprite("fog/#{file}", true)
+      @x = @y = 0.0
+      @sx, @sy = sx, sy
+      @color = Gosu::Color.new(a, r, g, b)
+    end
+    def update
+      @x += @sx
+      @y += @sy
+      if @x > 1024
+        @x = 0.0
+      elsif @x < 0
+        @x = 1024.0
+      end
+      if @y > 768.0
+        @y = 0
+      elsif @y < 0
+        @y = 768.0
+      end
+    end
+    def draw
+      @img.draw(@x, @y, Core::FOG_Z, 1, 1, @color)
+      if @sx != 0
+        @img.draw(@x-@img.width, @y, Core::FOG_Z, 1, 1, @color)
+      end
+      if @sy != 0
+        @img.draw(@x, @y-@img.height, Core::FOG_Z, 1, 1, @color)
+      end
+      if @sx != 0 and @sy != 0
+        @img.draw(@x-@img.width, @y-@img.height, Core::FOG_Z, 1, 1, @color)
+      end
+    end
+    
+  end
+  
+end

data/lib/game/map/map.rb

@@ -0,0 +1,247 @@
+
+module Core::Game
+  require_relative "../../ext/astar/node.rb"
+  require_relative "../../ext/astar/priority_queue.rb"
+  require_relative "tile.rb"
+  
+  class Map
+    attr_reader :layers, :properties, :module
+    attr_accessor :xoff, :yoff, :objects
+    def initialize(props, layers, objects, mod)
+      @properties = props
+      @layers = layers
+      @objects = objects
+      @xoff = @yoff = 0
+      @module = mod
+      create_static_collision
+    end
+    
+    def width
+      return @properties[:width]
+    end
+    
+    def height
+      return @properties[:height]
+    end
+    
+    def create_static_collision
+      return if @layers.empty?
+      tiles = []
+      @layers.each { |l|
+        i = 0
+        l.filled.each { |row|
+          row.each { |tile|
+            if !tile
+              if tiles[i] == false
+                i += 1
+                next
+              else
+                tiles[i] = true
+                i += 1
+                next
+              end
+            end
+            tiles[i] = tile.passable?
+            i += 1
+          }
+        }
+      }
+      @collision = Core::CollisionLayer.new(@layers.first.filled.first.size, @layers.first.filled.size, tiles)
+    end
+    
+    # parameters are scrolling, instance variables are world positions
+    def draw(xoff, yoff)
+      @layers.each { |l|
+        l.filled.each { |ary|
+          ary.each { |tile|
+            tile.draw(xoff+@xoff, yoff+@yoff) if tile
+          }
+        }
+      }
+    end
+    
+    def passable?(x, y, player=false)
+      if !player && ((x/32) < 0 or (x/32) >= width or (y/32) < 0 or (y/32) >= height)
+        return false
+      elsif player
+        if (x/32).to_i >= width
+          if Core.window.state.map.right.passable?(0, y, true)
+            Core.window.state.map.load(Core.window.state.map.right.properties[:file])
+            Core.window.state.map.player.teleport(0, y / 32)
+            return true
+          else
+            return false
+          end
+        elsif (x/32).to_i < 0
+          if Core.window.state.map.left.passable?((Core.window.state.map.left.width - 1) * 32, y, true)
+            Core.window.state.map.load(Core.window.state.map.left.properties[:file])
+            Core.window.state.map.player.teleport(Core.window.state.map.current.width, y / 32)
+            return true
+          else
+            return false
+          end
+        elsif (y/32).to_i >= height
+          if Core.window.state.map.left.passable?(x, 0, true)
+            Core.window.state.map.load(Core.window.state.map.lower.properties[:file])
+            Core.window.state.map.player.teleport(x / 32, 0)
+            return true
+          else
+            return false
+          end
+        elsif (y/32).to_i < 0
+          if Core.window.state.map.left.passable?(x, (Core.window.state.map.upper.height - 1) * 32, true)
+            Core.window.state.map.load(Core.window.state.map.upper.properties[:file])
+            Core.window.state.map.player.teleport(x / 32, Core.window.state.map.current.height)
+            return true
+          else
+            return false
+          end
+        end
+      end
+      begin
+        p = @collision.tiles[y/32][x/32]
+      rescue
+        puts("Collision out of bounds: #{x/32}|#{y/32}")
+      end
+      if p
+        obj = Core.window.state.find_object(x, y)
+        if !obj
+          return true
+        end
+        p = obj.through
+      end
+      return p
+    end
+    
+    def generate_costmap
+      map = []
+      x = 0
+      @collision.tiles.each { |ary|
+        cary = []
+        y = 0
+        ary.each { |tile|
+          if tile
+            obj = Core.window.state.find_object(y*32, x*32)
+            if obj and !obj.through
+              cary.push(0)
+              y += 1
+              next
+            end
+            cary.push(1)
+          else
+            cary.push(0)
+          end
+          y += 1
+        }
+        map.push(cary)
+        x += 1
+      }
+      return map
+    end
+    
+    def generate_successor_nodes(anode, costmap)
+      height = costmap.size
+      width = costmap.first.size
+      # determine nodes bordering this one - only N,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) # not on left edge, so provide a left-bordering node
+        newnode = AStar::Node.new((anode.x-1),anode.y,costmap[anode.y][(anode.x-1)])
+        yield newnode
+      end
+      if (east && east > 0) # not on right edge, so provide a right-bordering node
+        newnode = AStar::Node.new((anode.x+1),anode.y,costmap[anode.y][(anode.x+1)])
+        yield newnode
+      end
+      if (north && north > 0) # not on left edge, so provide a left-bordering node
+        newnode = AStar::Node.new(anode.x,(anode.y-1),costmap[(anode.y-1)][anode.x])
+        yield newnode
+      end
+      if (south && south > 0) # not on right edge, so provide a right-bordering node
+        newnode = AStar::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 = AStar::PriorityQueue.new()
+      closed = AStar::PriorityQueue.new()
+      node_start.calc_h(node_goal)
+      open.push(node_start)
+      costmap = generate_costmap
+      while !open.empty? do
+        iterations += 1 #keep track of how many times this itersates
+        node_current = open.find_best
+        if node_current == node_goal
+          #puts("Iterations: #{iterations}")
+          #show_path(node_current)
+          return node_current 
+        end       
+        generate_successor_nodes(node_current, costmap) { |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)
+        }
+        #now we've gone through all the successors, so the current node can be closed
+        closed.push(node_current)
+      end
+    end
+    
+    def show_path(anode)
+      #shows the path back from node 'anode' by following the parent pointer
+      curr = anode
+      pathmap = generate_costmap
+      while curr.parent do
+        pathmap[curr.y][curr.x] = '*'
+        curr = curr.parent
+      end
+      pathmap[curr.y][curr.x] = '*'
+      pathstr=""
+      pathmap.each_index do |row|
+        pathmap[row].each_index do |col|
+          pathstr<<"|#{pathmap[row][col]}"
+        end
+        pathstr<<"|\n"
+      end
+      puts(pathstr)
+    end
+    
+    def upper
+      return @properties[:upper]
+    end
+    
+    def lower
+      return @properties[:lower]
+    end
+    
+    def left
+      return @properties[:left]
+    end
+    
+    def right
+      return @properties[:right]
+    end
+    
+  end
+end

data/lib/game/map/map_animation.rb

@@ -0,0 +1,26 @@
+
+module Core::Game
+  
+  class MapAnimation < MapObject
+    
+    def initialize(anim, x, y)
+      super(x, y, {})
+      @anim = Core.anim(anim)
+      @anim.play(x, y, @z)
+    end
+    
+    def update
+    end
+    
+    def draw(xoff, yoff)
+      @anim.x = @x + xoff
+      @anim.y = @y + yoff
+      @anim.draw
+      if @anim.remove?
+        @dead = true
+      end
+    end
+    
+  end
+  
+end

data/lib/game/map/map_loader.rb

@@ -0,0 +1,177 @@
+
+require_relative "fog.rb"
+
+module Core::Game
+  class MapLoader
+    
+    attr_reader :objects, :misc, :player
+    attr_accessor :xoff, :yoff
+    
+    def initialize
+      @objects = []
+      @maps = []
+      @misc = []
+      @player = Core::Game::Player.new(0, 0)
+      @tonepic = Core.sprite("pixel", true)
+      @box = Core::GUI::Textfield.new(256, 480, 512, 224, "", 24, :left)
+      @message = false
+      @xoff = 496
+      @yoff = 360
+    end
+    
+    def current
+      return @maps[4]
+    end
+    
+    def left
+      return @maps[3]
+    end
+    
+    def right
+      return @maps[5]
+    end
+    
+    def upper
+      return @maps[1]
+    end
+    
+    def lower
+      return @maps[7]
+    end
+    
+    # 0 1 2
+    # 3 4 5
+    # 6 7 8
+    # 
+    # 4 => current
+
+    def load(file)
+      @maps.clear
+      map = Core::Parse.map(file)
+      @objects = map.objects
+      @objects.push(@player)
+      @maps[4] = map
+      if map.upper
+        @maps[1] = Core::Parse.map(map.upper)
+        @maps[1].yoff = -@maps[1].height*32
+        if @maps[1].left
+          @maps[0] = Core::Parse.map(@maps[1].left)
+          @maps[0].xoff = -@maps[1].height*32
+          @maps[0].yoff = -@maps[0].height*32
+        end
+        if @maps[1].right
+          @maps[2] = Core::Parse.map(@maps[1].right)
+          @maps[2].xoff = @maps[1].height*32
+          @maps[2].yoff = -@maps[1].height*32
+        end
+      end
+      if map.right
+        @maps[5] = Core::Parse.map(map.right)
+        @maps[5].xoff = @maps[4].width*32
+        if @maps[5].upper
+          @maps[2] = Core::Parse.map(@maps[5].upper)
+          @maps[2].xoff = @maps[4].width*32
+          @maps[2].yoff = -@maps[2].height*32
+        end
+        if @maps[5].lower
+          @maps[8] = Core::Parse.map(@maps[5].lower)
+          @maps[8].xoff = @maps[4].width*32
+          @maps[8].yoff = @maps[4].height*32
+        end
+      end
+      if map.left
+        @maps[3] = Core::Parse.map(map.left)
+        @maps[3].xoff = -@maps[3].width*32
+        if !@maps[1].left and @maps[3].upper
+          @maps[0] = Core::Parse.map(@maps[3].upper)
+          @maps[0].xoff = -@maps[0].width*32
+          @maps[0].yoff = -@maps[0].height*32
+        end
+      end
+      if map.lower
+        @maps[7] = Core::Parse.map(map.lower)
+        @maps[7].yoff = @maps[7].height*32
+        if @maps[7].left
+          @maps[6] = Core::Parse.map(@maps[7].left)
+          @maps[6].xoff = -@maps[7].height*32
+          @maps[6].yoff = @maps[7].height*32
+          if !@maps[6].left and @maps[3].lower
+            @maps[6] = Core::Parse.map(@maps[3].lower)
+            @maps[6].xoff = -@maps[6].width*32
+            @maps[6].yoff = +@maps[6].height*32
+          end
+        end
+        if @maps[7].right
+          @maps[8] = Core::Parse.map(@maps[7].right)
+          @maps[8].xoff = @maps[7].height*32
+          @maps[8].yoff = @maps[7].height*32
+        end
+      end
+      if map.properties[:music]
+        if map.properties[:music] == "nil"
+          @song.stop if @song
+        else
+          @song = Core::Song.new(map.properties[:music])
+          @song.play(true)
+        end
+      end
+      if map.properties[:fog]
+        if map.properties[:fog] == "nil"
+          @fog = nil
+        else
+          @fog = Core::Game::Fog.new(map.properties[:fog], map.properties[:fogx].to_f, map.properties[:fogy].to_f, map.properties[:foga].to_i, map.properties[:fogr].to_i, map.properties[:fogg].to_i, map.properties[:fogb].to_i)
+        end
+      end
+      if map.properties[:tonea] or map.properties[:toner] or map.properties[:toneg] or map.properties[:toneb]
+        @tone = Gosu::Color.new(map.properties[:tonea].to_i, map.properties[:toner].to_i, map.properties[:toneg].to_i, map.properties[:toneb].to_i)
+      else
+        @tone = nil
+      end
+    end
+    
+    def update
+      if !@message
+        @objects.each { |obj|
+          obj.setup if obj.do_setup?
+          obj.update
+          if obj.dead?
+            @objects.delete(obj)
+          end
+        }
+        @misc.each { |obj|
+          obj.update
+        }
+        @fog.update if @fog
+      else
+        if Core.window.pressed?(Gosu::KbSpace)
+          @message = false
+        end
+      end
+    end
+    
+    def draw
+      @maps.each { |map|
+        map.draw(@xoff, @yoff) if map
+      }
+      @objects.each { |obj|
+        obj.draw(@xoff, @yoff)
+      }
+      @misc.each { |m|
+        m.draw
+      }
+      @fog.draw if @fog
+      @tonepic.draw(0, 0, 500000, 1024, 768, @tone) if @tone
+      if @message
+        @box.draw
+      end
+    end
+    
+    def message(str, x=256, y=480, w=512, h=224)
+      @box.text = str
+      @message = true
+      @box.x, @box.y = x, y
+      @box.w, @box.h = w, h
+    end
+    
+  end
+end