cyberarm_engine 0.1.0

data/lib/cyberarm_engine/engine.rb

@@ -0,0 +1,95 @@
+module CyberarmEngine
+  class Engine < Gosu::Window
+    IMAGES = {}
+    SAMPLES= {}
+    SONGS  = {}
+
+    attr_accessor :show_cursor
+    attr_reader :current_state, :last_frame_time
+
+    def self.now
+      Gosu.milliseconds
+    end
+
+    def self.dt
+      $window.last_frame_time/1000.0
+    end
+
+    def initialize(width = 800, height = 600, fullscreen = false, update_interval = 1000.0/60)
+      @show_cursor = false
+
+      super(width, height, fullscreen, update_interval)
+      $window = self
+      @last_frame_time = Gosu.milliseconds-1
+      @current_frame_time = Gosu.milliseconds
+      self.caption = "CyberarmEngine #{CyberarmEngine::VERSION} #{Gosu.language}"
+
+      @states = []
+
+      setup if defined?(setup)
+    end
+
+    def draw
+      current_state.draw if current_state
+    end
+
+    def update
+      current_state.update if current_state
+      @last_frame_time = Gosu.milliseconds-@current_frame_time
+      @current_frame_time = Gosu.milliseconds
+    end
+
+    def needs_cursor?
+      @show_cursor
+    end
+
+    def dt
+      @last_frame_time/1000.0
+    end
+
+    def button_down(id)
+      current_state.button_down(id) if current_state
+    end
+
+    def button_up(id)
+      current_state.button_up(id) if current_state
+    end
+
+    def push_state(klass, options={})
+      if klass.instance_of?(klass.class) && defined?(klass.options)
+        @states << klass
+      else
+        @states << klass.new(options) if child_of?(klass, GameState)
+        @states << klass.new if child_of?(klass, Container)
+      end
+    end
+
+    private def child_of?(input, klass)
+      input.ancestors.detect {|c| c == klass}
+    end
+
+    def current_state
+      @states.last
+    end
+
+    def previous_state
+      if @states.size > 1 && state = @states[@states.size-2]
+        return state
+      else
+        return nil
+      end
+    end
+
+    def pop_state
+      @states.pop
+    end
+
+    # Sourced from https://gist.github.com/ippa/662583
+    def draw_circle(cx,cy,r, z = 9999,color = Gosu::Color::GREEN, step = 10)
+      0.step(360, step) do |a1|
+        a2 = a1 + step
+        draw_line(cx + Gosu.offset_x(a1, r), cy + Gosu.offset_y(a1, r), color, cx + Gosu.offset_x(a2, r), cy + Gosu.offset_y(a2, r), color, z)
+      end
+    end
+  end
+end

data/lib/cyberarm_engine/game_object.rb

@@ -0,0 +1,256 @@
+module CyberarmEngine
+  class GameObject
+    include Common
+
+    attr_accessor :image, :angle, :position, :velocity, :center_x, :center_y, :scale_x, :scale_y,
+                  :color, :alpha, :mode, :options, :paused, :radius, :last_position
+    def initialize(options={})
+      if options[:auto_manage] || options[:auto_manage] == nil
+        $window.current_state.add_game_object(self)
+      end
+
+      @options = options
+      @image = options[:image] ? image(options[:image]) : nil
+      x = options[:x] ? options[:x] : 0
+      y = options[:y] ? options[:y] : 0
+      z = options[:z] ? options[:z] : 0
+      @position = Vector.new(x, y, z)
+      @velocity = Vector.new
+      @last_position = Vector.new
+      @angle = options[:angle] ? options[:angle] : 0
+
+      @center_x = options[:center_x] ? options[:center_x] : 0.5
+      @center_y = options[:center_y] ? options[:center_y] : 0.5
+
+      @scale_x  = options[:scale_x] ? options[:scale_x] : 1
+      @scale_y  = options[:scale_y] ? options[:scale_y] : 1
+
+      @color    = options[:color] ? options[:color] : Gosu::Color.argb(0xff_ffffff)
+      @alpha    = options[:alpha] ? options[:alpha] : 255
+      @mode = options[:mode] ? options[:mode] : :default
+
+      @paused = false
+      @speed = 0
+      @debug_color = Gosu::Color::GREEN
+      @world_center_point = Vector.new(0,0)
+
+      setup
+
+      @debug_text = MultiLineText.new("", color: @debug_color, y: @position.y-(self.height*self.scale), z: 9999)
+      @debug_text.x = @position.x
+      if @radius == 0 || @radius == nil
+        @radius = options[:radius] ? options[:radius] : defined?(@image.width) ? ((@image.width+@image.height)/4)*scale : 1
+      end
+    end
+
+    def draw
+      if @image
+        @image.draw_rot(@position.x, @position.y, @position.z, @angle, @center_x, @center_y, @scale_x, @scale_y, @color, @mode)
+      end
+
+      if $debug
+        show_debug_heading
+        $window.draw_circle(@position.x, @position.y, radius, 9999, @debug_color)
+        if @debug_text.text != ""
+          $window.draw_rect(@debug_text.x-10, (@debug_text.y-10), @debug_text.width+20, @debug_text.height+20, Gosu::Color.rgba(0,0,0,200), 9999)
+          @debug_text.draw
+        end
+      end
+    end
+
+    def update
+    end
+
+    def debug_text(text)
+      @debug_text.text = text
+      @debug_text.x = @position.x-(@debug_text.width / 2)
+      @debug_text.y = @position.y-(@debug_text.height + self.radius + self.height)
+    end
+
+    def scale
+      if @scale_x == @scale_y
+        return @scale_x
+      else
+        false
+        # maths?
+      end
+    end
+
+    def scale=(int)
+      self.scale_x = int
+      self.scale_y = int
+      self.radius = ((@image.width+@image.height)/4)*self.scale
+    end
+
+    def visible
+      true
+      # if _x_visible
+      #   if _y_visible
+      #     true
+      #   else
+      #     false
+      #   end
+      # else
+      #   false
+      # end
+    end
+
+    def _x_visible
+      self.x.between?(($window.width/2)-(@world_center_point.x), ($window.width/2)+@world_center_point.x) ||
+        self.x.between?(((@world_center_point.x)-$window.width/2), ($window.width/2)+@world_center_point.x)
+    end
+
+    def _y_visible
+      self.y.between?(($window.height/2)-(@world_center_point.y), ($window.height/2)+@world_center_point.y) ||
+        self.y.between?((@world_center_point.y)-($window.height/2), ($window.height/2)+@world_center_point.y)
+    end
+
+    def heading(ahead_by = 100, object = nil, angle_only = false)
+      direction = Gosu.angle(@last_position.x, @last_position.x, @position.x, position.y).gosu_to_radians
+
+      _x = @position.x + (ahead_by * Math.cos(direction))
+      _y = @position.y + (ahead_by * Math.sin(direction))
+
+      return direction if angle_only
+      return Vector.new(_x, _y) unless angle_only
+    end
+
+    def show_debug_heading
+      _heading = heading
+      Gosu.draw_line(@position.x, @position.y, @debug_color, _heading.x, _heading.y, @debug_color, 9999)
+    end
+
+    def width
+      @image ? @image.width : 0
+    end
+
+    def height
+      @image ? @image.height : 0
+    end
+
+    def pause
+      @paused = true
+    end
+
+    def unpause
+      @paused = false
+    end
+
+    def rotate(int)
+      self.angle+=int
+      self.angle%=360
+    end
+
+    def alpha=int # 0-255
+      @alpha = int
+      @alpha = 255 if @alpha > 255
+      @color = Gosu::Color.rgba(@color.red, @color.green, @color.blue, int)
+    end
+
+    def draw_rect(x, y, width, height, color, z = 0)
+      $window.draw_rect(x,y,width,height,color,z)
+    end
+
+    def button_up(id)
+    end
+
+    def button_down?(id)
+    end
+
+    def find_closest(game_object_class)
+      best_object = nil
+      best_distance = 100_000_000_000 # Huge default number
+
+      game_object_class.all.each do |object|
+        distance = Gosu::distance(self.x, self.y, object.x, object.y)
+        if distance <= best_distance
+          best_object = object
+          best_distance = distance
+        end
+      end
+
+      return best_object
+    end
+
+    def look_at(object)
+      # TODO: Implement
+    end
+
+    def circle_collision?(object)
+      distance = Gosu.distance(self.x, self.y, object.x, object.y)
+      if distance <= self.radius+object.radius
+        true
+      else
+        false
+      end
+    end
+
+    # Duplication... so DRY.
+    def each_circle_collision(object, resolve_with = :width, &block)
+      if object.class != Class && object.instance_of?(object.class)
+        $window.current_state.game_objects.select {|i| i.class == object.class}.each do |o|
+          distance = Gosu.distance(self.x, self.y, object.x, object.y)
+          if distance <= self.radius+object.radius
+            block.call(o, object) if block
+          end
+        end
+      else
+        list = $window.current_state.game_objects.select {|i| i.class == object}
+        list.each do |o|
+          next if self == o
+          distance = Gosu.distance(self.x, self.y, o.x, o.y)
+          if distance <= self.radius+o.radius
+            block.call(self, o) if block
+          end
+        end
+      end
+    end
+
+    def destroy
+      if $window.current_state
+        $window.current_state.game_objects.each do |o|
+          if o.is_a?(self.class) && o == self
+            $window.current_state.game_objects.delete(o)
+          end
+        end
+      end
+    end
+
+    # NOTE: This could be implemented more reliably
+    def all
+      INSTANCES.select {|i| i.class == self}
+    end
+
+    def self.each_circle_collision(object, resolve_with = :width, &block)
+      if object.class != Class && object.instance_of?(object.class)
+        $window.current_state.game_objects.select {|i| i.class == self}.each do |o|
+          distance = Gosu.distance(o.x, o.y, object.x, object.y)
+          if distance <= o.radius+object.radius
+            block.call(o, object) if block
+          end
+        end
+      else
+        lista = $window.current_state.game_objects.select {|i| i.class == self}
+        listb = $window.current_state.game_objects.select {|i| i.class == object}
+        lista.product(listb).each do |o, o2|
+          next if o == o2
+          distance = Gosu.distance(o.x, o.y, o2.x, o2.y)
+          if distance <= o.radius+o2.radius
+            block.call(o, o2) if block
+          end
+        end
+      end
+    end
+
+    def self.destroy_all
+      INSTANCES.clear
+      if $window.current_state
+        $window.current_state.game_objects.each do |o|
+          if o.is_a?(self.class)
+            $window.current_state.game_objects.delete(o)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cyberarm_engine/game_state.rb

@@ -0,0 +1,90 @@
+module CyberarmEngine
+  class GameState
+    include Common
+
+    attr_accessor :options, :global_pause
+    attr_reader :game_objects, :containers
+
+    def initialize(options={})
+      @options = options
+      @game_objects = []
+      @global_pause = false
+
+      @down_keys = {}
+
+      setup
+    end
+
+    def setup
+    end
+
+    def draw
+      @game_objects.each(&:draw)
+    end
+
+    def update
+      @game_objects.each(&:update)
+    end
+
+    def draw_bounding_box(box)
+      x,y, max_x, max_y = box.x, box.y, box.max_x, box.max_y
+
+      color = Gosu::Color.rgba(255, 127, 64, 240)
+
+      # pipe = 4
+      # Gosu.draw_rect(x-width, y-height, x+(width*2), y+(height*2), color, Float::INFINITY)
+      # puts "BB render: #{x}:#{y} w:#{x.abs+width} h:#{y.abs+height}"
+      # Gosu.draw_rect(x, y, x.abs+width, y.abs+height, color, Float::INFINITY)
+
+      # TOP LEFT to BOTTOM LEFT
+      $window.draw_line(
+        x, y, color,
+        x, max_y, color,
+        Float::INFINITY
+      )
+      # BOTTOM LEFT to BOTTOM RIGHT
+      $window.draw_line(
+        x, max_y, color,
+        max_x, max_y, color,
+        Float::INFINITY
+      )
+      # BOTTOM RIGHT to TOP RIGHT
+      $window.draw_line(
+        max_x, max_y, color,
+        max_x, y, color,
+        Float::INFINITY
+      )
+      # TOP RIGHT to TOP LEFT
+      $window.draw_line(
+        max_x, y, color,
+        x, y, color,
+        Float::INFINITY
+      )
+    end
+
+    def destroy
+      @options.clear
+      @game_objects.clear
+    end
+
+    def button_down(id)
+      @down_keys[id] = true
+
+      @game_objects.each do |o|
+        o.button_down(id)
+      end
+    end
+
+    def button_up(id)
+      @down_keys.delete(id)
+
+      @game_objects.each do |o|
+        o.button_up(id)
+      end
+    end
+
+    def add_game_object(object)
+      @game_objects << object
+    end
+  end
+end

data/lib/cyberarm_engine/lib/bounding_box.rb

@@ -0,0 +1,124 @@
+module CyberarmEngine
+  class BoundingBox
+    attr_accessor :min, :max
+
+    def initialize(minx = 0, miny = 0, minz = 0, maxx = 0, maxy = 0, maxz = 0)
+      @min = Vector.new(minx, miny, minz)
+      @max = Vector.new(maxx, maxy, maxz)
+    end
+
+    def ==(other)
+      @min == other.min &&
+      @max == other.max
+    end
+
+    # returns a new bounding box that includes both bounding boxes
+    def union(other)
+      temp = BoundingBox.new
+      temp.min.x = [@min.x, other.min.x].min
+      temp.min.y = [@min.y, other.min.y].min
+      temp.min.z = [@min.z, other.min.z].min
+
+      temp.max.x = [@max.x, other.max.x].max
+      temp.max.y = [@max.y, other.max.y].max
+      temp.max.z = [@max.z, other.max.z].max
+
+      return temp
+    end
+
+    # returns the difference between both bounding boxes
+    def difference(other)
+      temp = BoundingBox.new
+      temp.min = @min - other.min
+      temp.max = @max - other.max
+
+      return temp
+    end
+
+    # returns whether both bounding boxes intersect
+    def intersect?(other)
+      (@min.x <= other.max.x && @max.x >= other.min.x) &&
+      (@min.y <= other.max.y && @max.y >= other.min.y) &&
+      (@min.z <= other.max.z && @max.z >= other.min.z)
+    end
+
+    # does this bounding box envelop other bounding box? (inclusive of border)
+    def contains?(other)
+      other.min.x >= min.x && other.min.y >= min.y && other.min.z >= min.z &&
+      other.max.x <= max.x && other.max.y <= max.y && other.max.z <= max.z
+    end
+
+    # returns whether the vector is inside of the bounding box
+    def point?(vector)
+      vector.x.between?(@min.x, @max.x) &&
+      vector.y.between?(@min.y, @max.y) &&
+      vector.z.between?(@min.z, @max.z)
+    end
+
+    def volume
+      width * height * depth
+    end
+
+    def width
+      @max.x - @min.x
+    end
+
+    def height
+      @max.y - @min.y
+    end
+
+    def depth
+      @max.z - @min.z
+    end
+
+    def normalize(entity)
+      temp = BoundingBox.new
+      temp.min.x = @min.x.to_f * entity.scale
+      temp.min.y = @min.y.to_f * entity.scale
+      temp.min.z = @min.z.to_f * entity.scale
+
+      temp.max.x = @max.x.to_f * entity.scale
+      temp.max.y = @max.y.to_f * entity.scale
+      temp.max.z = @max.z.to_f * entity.scale
+
+      return temp
+    end
+
+    def normalize_with_offset(entity)
+      temp = BoundingBox.new
+      temp.min.x = @min.x.to_f * entity.scale + entity.position.x
+      temp.min.y = @min.y.to_f * entity.scale + entity.position.y
+      temp.min.z = @min.z.to_f * entity.scale + entity.position.z
+
+      temp.max.x = @max.x.to_f * entity.scale + entity.position.x
+      temp.max.y = @max.y.to_f * entity.scale + entity.position.y
+      temp.max.z = @max.z.to_f * entity.scale + entity.position.z
+
+      return temp
+    end
+
+    def +(other)
+      box = BoundingBox.new
+      box.min = self.min + other.min
+      box.min = self.max + other.max
+
+      return box
+    end
+
+    def -(other)
+      box = BoundingBox.new
+      box.min = self.min - other.min
+      box.min = self.max - other.max
+
+      return box
+    end
+
+    def sum
+      @min.sum + @max.sum
+    end
+
+    def clone
+      BoundingBox.new(@min.x, @min.y, @min.z, @max.x, @max.y, @max.z)
+    end
+  end
+end