delve 0.0.7

data/lib/delve/entity.rb

@@ -0,0 +1,23 @@
+class Entity
+  def initialize
+    @components = Hash.new
+  end
+
+  def has?(component_id)
+    @components.keys.include? component_id
+  end
+
+  def add(component)
+    raise 'Cannot add the same component more than once' if has?(component.id)
+    @components[component.id] = component
+  end
+
+  def get(component_id)
+    return nil unless has?(component_id)
+    @components[component_id]
+  end
+
+  def act
+    get(:actor).act if has?(:actor)
+  end
+end

data/lib/delve/event_queue.rb

@@ -0,0 +1,48 @@
+class EventQueue
+  def initialize
+    @time = 0
+    @events = Array.new
+  end
+
+  def time
+    @time
+  end
+
+  def add(event, time)
+    raise 'Unable to add a nil event' unless event
+    raise 'Unable to schedule event with no time' unless time
+    
+    i = @events.length
+    (0..@events.length - 1).each do |e|
+      if @events[e][:time] > time
+        i = e
+        break
+      end
+    end
+
+    @events.insert(i, { :event => event, :time => time })
+  end
+
+  def get
+    return nil unless @events.length > 0
+    
+    e = @events.shift
+
+    if e[:time] > 0
+      @time += e[:time]
+      @events.each { |x| x[:time] -= e[:time] }
+    end
+    e[:event]
+  end
+
+  def remove(event)
+    index = @events.index { |e| e[:event] == event }
+    return false unless index
+    @events.delete_at index
+    true
+  end
+
+  def clear
+    @events = Array.new
+  end
+end

data/lib/delve/fov/discrete_shadowcasting.rb

@@ -0,0 +1,78 @@
+require 'delve/fov/fov'
+
+class DiscreteShadowCasting < FieldOfView
+
+  def initialize(options=Hash.new, block&)
+    super options, block&
+  end
+
+  def compute(x, y, radius)
+    raise 'Cannot call compute without a block' unless block_given?
+    center = @coords
+    map = @map
+
+    yield x, y, 0, nil
+
+    return nil unless light_passes? x, y
+     #TODO: need to create a light_passes? method on the base class, that calls into the bllock thats passed in. The block should be a class that exposes a light_passes? method
+    
+    data = Arrray.new
+
+    a, b, cx, cy, blocks = nil
+
+    (1..radius-1).each do |r|
+      neighbours = get_circle x, y, r
+      angle = 360 / neighbours.length
+
+      (0..neighbours.length-1).each do |i|
+        cx = neighbours[i][0]
+        cy = neighbours[i][1]
+        a = angle * (i - 0.5)
+        b = a + angle
+
+        blocks = !light_passes? cx, cy
+        yield cx, cy, r, 1 if visible_coords a.floor, b.ceil, blocks, data
+
+        return nil if data.length == 2 and data[0] == 0 && data[1] == 360
+      end
+    end
+  end
+
+  private
+  def visible_coords(a, b, blocks, data)
+    #TODO: How to deal with the arguments.calee section?
+
+    index = 0
+    index += 1 while index < data.length and data[index] < a
+
+    if index == data.length
+      if blocks
+        data << a
+        data << b
+      end
+      return true
+    end
+
+    count = 0
+
+      if index % 2 == 0
+        while index < data.length and data[index] < b
+          index += 1
+          count += 1
+        end
+
+        return false if count == 0
+
+        if blocks
+          if count % 2 == 0
+            #TODO Splice needs to be rubified
+            data.splice index-count, count, b
+          else
+            data.splice index-count, count
+          end
+        end
+      end
+    return true
+  end
+
+end

data/lib/delve/fov/fov.rb

@@ -0,0 +1,83 @@
+class FieldOfView
+
+  def initialize(options=Hash.new, block&)
+    @light_passes = block&
+    @options = { :topology => :eight }
+    options.each { |k, v| @options[k] = v }
+  end
+
+  def compute(x, y, r, block&)
+
+  end
+
+  private
+  def get_circle(cx, cy, r)
+    result = Array.new
+    dirs, count_factor, start_offset = nil
+
+    if @options[:topology] == :four
+      count_factor = 1
+      start_offset = [0, 1]
+      dirs = [
+        directions[:eight][7],
+        directions[:eight][1],
+        directions[:eight][3],
+        directions[:eight][5]
+      ]
+    elsif @options[:topology] == :six
+      dirs = directions[:six]
+      count_factor = 1
+      start_offset = [-1, 1]
+    elsif @options[:topology] == :eight
+      dirs = directions[:four]
+      count_factor = 2
+      start_offset = [-1, 1]
+    end
+
+    x = cx + (start_offset[0] * r)
+    y = cy + (start_offset[1] * r)
+
+    (0..dirs.length-1).each do |i|
+      (0..((r*count_factor) - 1)).each do |j|
+        result << [x, y]
+        x += dirs[i][0]
+        y += dirs[i][1]
+      end
+    end
+
+    result
+  end
+
+  def directions(v)
+    dirs = {
+      :four => [
+        [ 0, -1],
+        [ 1,  0],
+        [ 0,  1],
+        [-1,  0]
+      ],
+      :eight => [
+        [ 0, -1],
+        [ 1, -1],
+        [ 1,  0],
+        [ 1,  1],
+        [ 0,  1],
+        [-1,  1],
+        [-1,  0],
+        [-1, -1]
+      ],
+      :six => [
+        [-1, -1],
+        [ 1, -1],
+        [ 2,  0],
+        [ 1,  1],
+        [-1,  1],
+        [-2,  0]
+      ]
+    }
+
+    dirs[v]
+  end
+
+
+end

data/lib/delve/game.rb

@@ -0,0 +1,22 @@
+class Game
+  def initialize(display, screen_manager, input)
+    raise 'Unable to initialize game when display is nil' unless display
+    raise 'Unable to initialize game when screen manager is nil' unless screen_manager
+    raise 'Unable to initalize game when input is nil' unless input
+    @display = display
+    @screen_manager = screen_manager
+    @input = input
+  end
+
+  def start
+    raise 'Unable to start game when screen_manager is empty' if @screen_manager.empty?
+    quit = false
+    while !quit
+      @screen_manager.render @display
+      @display.render
+
+      quit = @screen_manager.update @input
+    end
+  end
+
+end

data/lib/delve/generator/cellular.rb

@@ -0,0 +1,111 @@
+require 'delve/generator/map'
+
+class CellularGenerator < Map
+
+  def initialize(width=nil, height=nil, opts=Hash.new)
+    super width, height
+    @options = {
+      born: [5, 6, 7, 8],
+      survive: [4, 5, 6, 7, 8],
+      topology: :eight
+    }
+
+    set_options opts
+
+    @dirs = directions @options[:topology]
+    @map = fill 0
+  end
+
+  def randomize(probablility)
+    (0..@width-1).each do |i|
+      (0..@height-1).each do |j|
+        @map[i][j] = rand < probablility ? 1 : 0
+      end
+    end
+  end
+
+  def set_options(opts)
+    opts.keys.each { |key| @options[key] = opts[key] }
+  end
+
+  def set(x, y, value)
+    @map[x][y] = value
+  end
+
+  def generate
+    new_map = fill 0
+    randomize 0.45
+    born = @options[:born]
+    survive = @options[:survive]
+
+    (0..@height-1).each do |j|
+      width_step = 1
+      width_start = 0
+      if @options[:topology] == 6
+        width_step = 2
+        width_start = j%2
+      end
+
+      width_start.step(@width-1, width_step) do |i|
+        curr = @map[i][j]
+        ncount = get_neighbours i, j
+
+        if curr > 0 and survive.index(ncount) != nil
+          new_map[i][j] = 1
+        elsif curr <= 0 and born.index(ncount) != nil
+          new_map[i][j] = 1
+        end
+
+        yield i, j, new_map[i][j]
+      end
+    end
+
+    @map = new_map
+  end
+
+  private
+  def get_neighbours cx, cy
+    result = 0
+    @dirs.each do |dir|
+      x = cx + dir[0]
+      y = cy + dir[1]
+      
+      next if x < 0 or x >= (@width - 1) or y < 0 or y >= (@height - 1)
+      result += @map[x][y] == 1 ? 1 :0
+    end
+
+    result
+  end
+
+  def directions(v)
+    dirs = {
+      :four => [
+        [ 0, -1],
+        [ 1,  0],
+        [ 0,  1],
+        [-1,  0]
+      ],
+      :eight => [
+        [ 0, -1],
+        [ 1, -1],
+        [ 1,  0],
+        [ 1,  1],
+        [ 0,  1],
+        [-1,  1],
+        [-1,  0],
+        [-1, -1]
+      ],
+      :six => [
+        [-1, -1],
+        [ 1, -1],
+        [ 2,  0],
+        [ 1,  1],
+        [-1,  1],
+        [-2,  0]
+      ]
+    }
+
+    dirs[v]
+  end
+
+end

data/lib/delve/generator/dungeon.rb

@@ -0,0 +1,19 @@
+require 'delve/generator/map'
+
+class Dungeon < Map
+
+  def initialize(width=nil, height=nil)
+    super width, height
+    @rooms = Array.new
+    @corridors = Array.new
+  end
+
+  def rooms
+    @rooms
+  end
+
+  def corridors
+    @corridors
+  end
+
+end

data/lib/delve/generator/map.rb

@@ -0,0 +1,30 @@
+class Map
+
+  @@default_width = 80
+  @@default_height = 24
+
+  def initialize(width=nil, height=nil)
+    @width = width || @@default_width
+    @height = height || @@default_height
+  end
+
+  def width
+    @width
+  end
+
+  def height
+    @height
+  end
+
+  def fill(value)
+    map = Array.new
+    (0..@width-1).each do |x|
+      map << Array.new
+      (0..@height-1).each do
+        map[x] << value
+      end
+    end
+    map
+  end
+
+end

data/lib/delve/generator/noise.rb

@@ -0,0 +1,33 @@
+require 'perlin_noise'
+require 'delve/generator/map'
+
+class Noise < Map
+
+  @@grains = {
+    :fine => 0.03,
+    :coarse => 0.1
+  }
+
+  def initialize width, height, grain
+    raise 'Cannot initialize noise generator when width is less than zero' if width < 0
+    raise 'Cannot initialize noise generator when height is less than zero' if height < 0
+    raise 'Cannot initialize noise generator when grain is not defined' unless grain
+    raise 'Cannot initialize noise generator with unknown grain' unless @@grains.include?(grain)
+
+    super width, height
+
+    @grain = @@grains[grain]
+    @inverse = 1/@grain
+  end
+
+  def generate
+    noise = Perlin::Noise.new 2
+
+    0.step((@width-1) * @grain, @grain) do |x|
+      0.step((@height-1) * @grain, @grain).each do |y|
+        yield(x*@inverse, y*@inverse, noise[x, y])
+      end
+    end
+  end
+
+end