beefdump 0.0.1

data/README.md

@@ -0,0 +1,13 @@
+# BeefDump
+
+A testbed for non-player character AI in role-playing games.
+
+## Install
+
+Install Ruby 1.8 (with ZLIB and BASE64)
+
+Install the required gems:
+
+    gem install gosu xml-simple
+    
+And you're done.

data/lib/beefdump.rb

@@ -0,0 +1,16 @@
+module Beefdump
+  # Bootstrap helpers
+  def self.load_dir(dir)
+    Dir.new(dir).each do |file|
+      next unless file =~ /\.rb$/
+      load "#{dir}/#{file}"
+    end
+  end
+
+  # Load path
+  LIB_PATH = File.expand_path(File.dirname(__FILE__))
+  $LOAD_PATH << LIB_PATH
+
+  # Monkey patches
+  load_dir("#{LIB_PATH}/beefdump/monkey_patches")
+end

data/lib/beefdump/boot.rb

@@ -0,0 +1,35 @@
+module Beefdump
+  require 'ostruct'
+
+  # Config
+  require 'beefdump/config/base'
+  CONFIG_PATH = "#{ROOT_PATH}/config"
+  CONFIG = Config::Base.new
+  # load beefdump config blueprint
+  require 'beefdump/config/blueprint'
+  
+  base_config = "#{CONFIG_PATH}/base.rb"
+  load base_config if File.exist?(base_config)
+
+  # Logger
+  load CONFIG.logger.class
+  Logger.level = CONFIG.logger.level
+  Logger.info "Monkey patches, config and logger loaded. Let's get going!"
+
+  # Utils
+  UTILS_PATH = "#{LIB_PATH}/beefdump/utils"
+  Logger.info "Loading utils."
+  load_dir(UTILS_PATH)
+
+  # Game
+  Logger.info "Loading game kernel"
+  load "#{LIB_PATH}/beefdump/game/base.rb"
+
+  # Modules
+  Logger.info "Loading beefdump modules"
+  CONFIG.active_modules.each do |modul|
+    Logger.trace "Loading module #{modul}"
+    require "beefdump/#{modul}#{modul =~ /.+\/.+/ ? "" : "/#{modul}"}"
+  end
+  Logger.info "Loading of modules completed"
+end

data/lib/beefdump/client/base.rb

@@ -0,0 +1,33 @@
+module Beefdump
+  module Client
+    # The most basic client which is kind of a client specification
+    class Base
+      attr_reader :player
+    
+      # Initialize the client on connection to the server
+      def initialize(game, player = nil)
+        @game = game
+        @player = player
+      end
+    
+      # Do whatever the client would like to do.
+      # This is called by the server in any game loop.
+      def act
+      end
+
+      # The server wants to close the connection to the client.
+      # Clean up the stuff in here
+      def disconnect
+      end
+    
+      protected
+      def id
+        object_id
+      end
+    
+      def log(level, message)
+        Logger.send(level, "Client #{id}: #{message}")
+      end
+    end
+  end
+end

data/lib/beefdump/client/graphical/client.rb

@@ -0,0 +1,94 @@
+module Beefdump
+  module Client
+    module Graphical
+      class Client < Client::Base
+        require 'gosu'
+        require 'beefdump/client/graphical/window'
+    
+        def initialize(game, *options)
+          super(game, *options)
+          @window = Window.new(self, Window::WIDTH, Window::HEIGHT, false)
+          @window.caption = Time.now
+        
+          initialize_tilesets(game.map)
+      
+          @player = @game.claim_player("Peter", self)
+          start_main_loop
+        end
+    
+        def act
+          @window.caption = Time.now
+        end
+    
+        def disconnect
+          @window.close
+          @window_thread.join
+        end
+    
+        def update_window
+          return unless @game.should_run?
+        
+          if @window.button_down? Gosu::Button::KbEscape
+            @game.shutdown!
+          end
+          handle_camera_movement
+        end
+      
+        def draw_window
+          left   = @player.position.x / @game.map.tile_width
+          top    = @player.position.y  / @game.map.tile_height
+          diff_x = @player.position.x % @game.map.tile_width
+          diff_y = @player.position.y  % @game.map.tile_height
+          width  = Window::WIDTH  / @game.map.tile_width  + 1
+          height = Window::HEIGHT / @game.map.tile_height + 1
+        
+          tile_layers = @game.map.background_at(left, top, width, height)
+        
+          tile_layers.each do |tile_layer|
+            tile_layer.each_with_index do |row, x|
+              row.each_with_index do |tile, y|
+                tileset = @game.map.tileset_for(tile)
+                next unless tileset
+                tile_id = tile - tileset.first_gid
+                @tileset_images[@game.map.tilesets.index(tileset)][tile_id].draw(x * @game.map.tile_width - diff_x, y * @game.map.tile_height - diff_y, 0)
+              end
+            end
+          end
+        end
+    
+        protected
+        def start_main_loop
+          Thread.abort_on_exception = true
+          @window_thread = Thread.new do
+            @window.show
+          end
+        end
+      
+        def initialize_tilesets(map)
+          @tileset_images = []
+          map.tilesets.each do |tileset|
+            log(:trace, "Loading tileset image '#{tileset.image_file}'")
+            @tileset_images << Gosu::Image.load_tiles(@window, tileset.image_file, tileset.tile_width, tileset.tile_height, true)
+            log(:trace, "Loaded #{@tileset_images.last.size} tiles.")
+          end
+        end
+      
+        def handle_camera_movement
+          if @window.button_down? Gosu::Button::KbRight
+            @player.position.x = [(@game.map.width * @game.map.tile_width) - Window::WIDTH, @player.position.x + 5].min
+          end
+          if @window.button_down? Gosu::Button::KbLeft
+            @player.position.x = [0, @player.position.x - 5].max
+          end
+        
+          if @window.button_down? Gosu::Button::KbDown
+            @player.position.y = [(@game.map.height * @game.map.tile_height) - Window::HEIGHT, @player.position.y + 5].min
+          end
+          if @window.button_down? Gosu::Button::KbUp
+            @player.position.y = [0, @player.position.y - 5].max
+          end
+        end
+     end 
+    end
+  end
+end

data/lib/beefdump/client/graphical/window.rb

@@ -0,0 +1,24 @@
+module Beefdump
+  module Client
+    module Graphical
+      require 'gosu'
+      class Window < Gosu::Window
+        WIDTH  = 640
+        HEIGHT = 480
+      
+        def initialize(client, *args)
+          super(*args)
+          @client = client
+        end
+      
+        def update
+          @client.update_window
+        end
+      
+        def draw
+          @client.draw_window
+        end
+      end
+    end
+  end
+end

data/lib/beefdump/config/base.rb

@@ -0,0 +1,8 @@
+module Beefdump
+  module Config
+    require 'ostruct'
+    
+    class Base < OpenStruct
+    end
+  end
+end

data/lib/beefdump/config/blueprint.rb

@@ -0,0 +1,7 @@
+module Beefdump
+  CONFIG.active_modules = %w{world map client/base client/graphical/client}
+
+  CONFIG.logger = Config::Base.new(
+    :class => "beefdump/logger.rb",
+    :level => :info)
+end

data/lib/beefdump/game/base.rb

@@ -0,0 +1,95 @@
+module Beefdump
+  module Game
+    class Base
+      require 'beefdump/game/state'
+      require 'beefdump/game/player'
+    
+      CLIENT_UPDATE_RATE      = 1.0 / 10 # 10 times a second
+      GAME_STATE_PATH         = "#{ROOT_PATH}/game_state"
+      CURRENT_GAME_STATE_FILE = "#{GAME_STATE_PATH}/current.bin"
+
+      attr_reader :map
+  
+      def initialize
+        load_static_data
+        load_map('test')
+        init_game_state
+    
+        load_clients
+
+        @shutdown = false
+
+        game_loop
+      end
+  
+      def load_map(new_map)
+        @map = Map.load(new_map)
+      end
+  
+      def shutdown!
+        Logger.info "Received shutdown command from client. Quitting game."
+        save_game_state
+        @shutdown = true
+      end
+  
+      def claim_player(name, client)
+        player = @state.players.select {|p| p.name == name}.first
+        raise "Player not found" unless player
+        player
+      end
+  
+      def should_run?
+        !@shutdown
+      end
+  
+      protected
+  
+      def init_game_state
+        Logger.info("Loading game state.")
+      
+        if File.exist?(CURRENT_GAME_STATE_FILE)
+          @state = File.open(CURRENT_GAME_STATE_FILE, 'r') {|f| Marshal.load(f)}
+        else
+          Logger.info("No saved game state found.")
+          initially_create_game_state!
+        end
+      end
+  
+      def initially_create_game_state!
+        initial_state = @map.get_initial_state
+        @state = Game::State.from_xml(initial_state, self)
+      end
+  
+      def save_game_state
+        Logger.info("Saving game state")
+        File.open(CURRENT_GAME_STATE_FILE, 'w') {|f| Marshal.dump(@state, f)}
+      end
+    
+      def load_static_data
+        World.load
+      end
+  
+      def load_clients
+        Logger.info "Loading clients."
+        @clients = []
+        @clients << Client::Graphical::Client.new(self)
+      end
+  
+      def game_loop
+        Logger.info "All systems go! Starting main game loop."
+      
+        while self.should_run?
+          start_time = Time.now.to_f
+      
+          @clients.each do |client|
+            client.act
+          end
+      
+          passed_time = Time.now.to_f - start_time
+          sleep passed_time > CLIENT_UPDATE_RATE ? 0 : CLIENT_UPDATE_RATE - passed_time
+        end
+        Logger.info("fin")
+      end
+    end
+  end
+end

data/lib/beefdump/game/player.rb

@@ -0,0 +1,12 @@
+module Beefdump
+  module Game
+    class Player
+      attr_reader :name, :position
+    
+      def initialize(name, position)
+        @name = name
+        @position = position
+      end
+    end
+  end
+end

data/lib/beefdump/game/state.rb

@@ -0,0 +1,22 @@
+module Beefdump
+  module Game
+    class State
+      require 'ostruct'
+      attr_reader :players, :game
+    
+      def initialize(players)
+        @players = players
+      end
+    
+      def self.from_xml(xml, game)
+        players = []
+        xml['players'].first['player'].each do |player|
+          position = player['position'].first
+          players << Game::Player.new(player['name'], OpenStruct.new({:x => position['x'].to_i, :y => position['y'].to_i}))
+        end
+      
+        self.new(players)
+      end
+    end
+  end
+end

data/lib/beefdump/logger.rb

@@ -0,0 +1,19 @@
+module Beefdump
+  class Logger
+    LEVELS = [:trace, :info, :warn, :error]
+  
+    def self.level=(new_level)
+      raise "No valid log level: '#{new_level}'!" unless @level = LEVELS.index(new_level)
+    end
+  
+    def self.method_missing(method_name, *args)
+      return super.send(method_name, args) unless LEVELS.include?(method_name)
+      log(method_name, args.first) if LEVELS.index(method_name) >= @level
+    end
+  
+    protected
+    def self.log(level, message)
+      puts "[#{level}] #{Time.now}: #{message}"
+    end
+  end
+end

data/lib/beefdump/map/layer.rb

@@ -0,0 +1,53 @@
+module Beefdump
+  module Map
+    class Layer
+      require 'zlib'
+      require 'base64'
+    
+      attr_reader :name, :width, :height, :map, :field
+    
+      def initialize(layer_data, map)
+        @map = map
+      
+        load_layer_attributes!(layer_data)
+      
+        load_data!(layer_data["data"].first)
+      end
+    
+      protected
+      def load_layer_attributes!(layer_data)
+        @name   = layer_data["name"]
+        @width  = layer_data["width"].to_i
+        @height = layer_data["height"].to_i
+      
+        Logger.trace "Loaded layer attributes: Name: #{@name} Width: #{@width} Height: #{@height}"
+      end
+    
+      def load_data!(data)
+        Logger.trace "Loading layer data for layer '#{@name}'."
+      
+        encoding    = data["encoding"]
+        compression = data["compression"]
+      
+        raise "Map layers without BASE64 enconding are unsupported!" unless encoding == "base64"
+        raise "Map layers without GZIP compression are unsupported!" unless compression == "gzip"
+      
+        content = StringIO.new(Base64.decode64(data["content"].strip))
+        gz = Zlib::GzipReader.new(content)
+      
+        @field = []
+        row = []
+        byte_arr = []
+        gz.each_byte do |byte|
+          byte_arr << byte
+          if byte_arr.size == 4
+            row << (byte_arr[0] | byte_arr[1] << 8 | byte_arr[2] << 16 | byte_arr[3] << 24)
+            byte_arr = []
+            @field << row and row = [] if row.size == @width
+          end
+        end
+        gz.close
+      end
+    end
+  end
+end

data/lib/beefdump/map/map.rb

@@ -0,0 +1,136 @@
+module Beefdump
+  module Map
+    MAP_PATH = "#{ROOT_PATH}/map"
+  
+    class Base
+      require 'xmlsimple'
+      require 'beefdump/map/layer'
+      require 'beefdump/map/tileset'
+      require 'beefdump/map/object'
+    
+      MAP_FORMAT_VERSION = "1.0"
+  
+      attr_reader :width, :height, :tile_width, :tile_height, :layers, :tilesets, :objects, :name
+  
+      def initialize(map_name, map_data)
+        @name = map_name
+      
+        check_compatibility!(map_data)
+    
+        load_map_attributes!(map_data)
+        load_layers!(map_data)
+        load_tilesets!(map_data)
+        load_objects!(map_data)
+
+        @raw_data = map_data
+      end
+    
+      def background_at(x, y, width = 1, height = 1)
+        tiles = []
+        @layers.each do |layer|
+          field = Array.new(width).map {|e| Array.new(height).map {|e| nil}}
+          for diff_x in 0..(width - 1)
+            for diff_y in 0..(height - 1)
+              field[diff_x][diff_y] = layer.field[y + diff_y] ? layer.field[y + diff_y][x + diff_x] : nil
+            end
+          end
+          tiles << field
+        end
+      
+        tiles
+      end
+    
+      def objects_at(x, y)
+        objects = @objects.select {|o| o.is_at?(x, y)}
+      end
+    
+      def tileset_for(gid)
+        return unless gid
+        chosen = nil
+        @tilesets.each do |tileset|
+          break if chosen && gid < tileset.first_gid
+          chosen = tileset if gid >= tileset.first_gid
+        end
+      
+        chosen
+      end
+    
+      def get_initial_state
+        Logger.info("Loading initial state for map '#{@name}'.")
+        initial_state_file = "#{MAP_PATH}/#{@name}.isx"
+        raise "Initial state file for map '#{@name}' not found!" unless File.exist?(initial_state_file)
+      
+        XmlSimple.xml_in(initial_state_file)
+      end
+  
+      protected
+      def check_compatibility!(map_data)
+        Logger.trace "Checking map format compatibility."
+      
+        raise "Map format unsupported (#{map_data["orientation"]})!" unless map_data["orientation"] == "orthogonal"
+        Logger.warn("Map format version #{map_data['version']} is not supported - scary problems may occur! Supply maps in format version #{MAP_FORMAT_VERSION} to ensure smooth operation.") if map_data['version'] != MAP_FORMAT_VERSION
+      end
+  
+      def load_map_attributes!(map_data)
+        @width       = map_data["width"].to_i
+        @height      = map_data["height"].to_i
+        @tile_width  = map_data["tilewidth"].to_i
+        @tile_height = map_data["tileheight"].to_i
+      
+        Logger.trace "Loaded map attributes: Width: #{@width} Height: #{@height} Tile Width: #{@tile_width} Tile Height: #{@tile_height}"
+      end
+  
+      def load_layers!(map_data)
+        @layers = map_data["layer"].map {|layer_data| Layer.new(layer_data, self)}
+      
+        Logger.info "Loaded #{@layers.size} map layers."
+      end
+    
+      def load_tilesets!(map_data)
+        @tilesets = map_data["tileset"].map {|tileset_data| Tileset.new(tileset_data, self)}.sort {|a, b| a.first_gid <=> b.first_gid}
+      
+        Logger.info "Loaded #{@tilesets.size} tilesets containing #{@tilesets.inject(0) {|a,t| a += t.tiles_count}} tiles at all."
+      end
+    
+      def load_objects!(map_data)
+        @objects = []
+        map_data["objectgroup"].each do |object_group|
+          object_group["object"].each do |object|
+            new_object = Object.new(object)
+            raise "Duplicate object name on map: #{new_object.name}" if @objects.any? {|o| o.name == new_object.name}
+            @objects << new_object
+          end
+        end
+      
+        check_object_reference_integrity
+      
+        Logger.info "Loaded #{@objects.size} objects on the map."
+      end
+    
+      def check_object_reference_integrity
+        Logger.info "Checking reference integrity on objects."
+      
+        @objects.each do |object|
+          object.properties.each do |property, value|
+            if object.blueprint.properties[property].type == :name_reference
+              raise "Object '#{object.name}' references to an object named '#{value}' as it's '#{property}' value but such an object does not exist!" unless @objects.any? {|o| o.name == value}
+            end
+          end
+        end
+      end
+    end
+  
+    def self.load(map_name)
+      Logger.info "Trying to load map #{map_name}"
+    
+      map_file = "#{MAP_PATH}/#{map_name}.tmx"
+      raise "Map does not exist: '#{map_file}'!" unless File.exist?(map_file)
+  
+      map = Base.new(map_name, XmlSimple.xml_in(map_file))
+
+      Logger.info "Successfully loaded map."
+      map
+    end
+  
+  end
+end

data/lib/beefdump/map/object.rb

@@ -0,0 +1,75 @@
+module Beefdump
+  module Map
+    class Object
+      attr_reader :name, :x, :y, :width, :height, :type, :properties, :blueprint
+    
+      def initialize(object_data)
+        load_object_attributes!(object_data)
+      
+        load_properties!(object_data["properties"])
+      end
+    
+      def is_at?(x, y)
+        self.x >= x && self.x + self.width <= x && self.y >= y && self.y + self.height <= y
+      end
+    
+      protected
+      def load_object_attributes!(object_data)
+        @type = object_data["type"].to_sym
+        @blueprint = World.objects[@type]
+        raise "Unsupported object type '#{@type}' on map!" unless @blueprint
+      
+        @name   = object_data["name"]
+        @x      = object_data["x"]
+        @y      = object_data["y"]
+        @width  = object_data["width"]
+        @height = object_data["height"]
+      
+        Logger.trace "Loaded object attributes: Name: #{@name} Position: #{@x}, #{@y} Width: #{@width} Height: #{@height} Type: #{@type}"
+      end
+    
+      def load_properties!(properties_data)
+        @properties = {}
+        return unless properties_data
+
+        properties_data.first["property"].each do |property_data|
+          value = check_and_cast_property(property_data["property"])
+          @properties[property_data["name"].to_sym] = property_data["value"]
+        end
+      
+        check_for_mandatory_properties
+      
+        Logger.trace "Sucessfully loaded properties for object '#{@name}'."
+      end
+    
+      def check_and_cast_property(property_data)
+        return unless property_data
+
+        property_name = property_data["name"].to_sym
+        property_blueprint = @blueprint.properties[property_name]
+        raise "Object type '#{@type}' has no '#{property_name}' property (on object '#{@name}')" unless property_blueprint
+      
+        value = property_data["value"]
+        return nil unless value
+      
+        case property_blueprint.type
+        when :number
+          raise "Value of property '#{property_name}' on object '#{@name}' must be numeric and not #{value}!" unless value.numeric?
+          value.to_f
+        when :string
+          value.to_s
+        when :name_reference
+          value.to_s
+        end
+      end
+    
+      def check_for_mandatory_properties
+        @blueprint.properties.each do |type, property|
+          next unless property.mandatory?
+
+          raise "Mandatory property '#{property.name}' not set on object '#{@name}' of type #{@type}!" unless @properties[property.name]
+        end
+      end
+    end
+  end
+end

data/lib/beefdump/map/tileset.rb

@@ -0,0 +1,35 @@
+module Beefdump
+  module Map
+    class Tileset
+      attr_reader :name, :first_gid, :tile_width, :tile_height, :image_file, :image_transparency_color, :map, :dimensions, :tiles_count
+    
+      def initialize(tileset_data, map)
+        @map = map
+      
+        load_tileset_attributes!(tileset_data)
+        load_image!(tileset_data["image"].first)
+      end
+    
+      protected
+    
+      def load_tileset_attributes!(tileset_data)
+        @name        = tileset_data["name"]
+        @first_gid   = tileset_data["firstgid"].to_i
+        @tile_width  = tileset_data["tilewidth"].to_i
+        @tile_height = tileset_data["tileheight"].to_i
+      
+        Logger.trace "Loaded tileset attributes: Name: '#{@name}' First GID: #{@first_gid} Tile Width: #{@tile_width} Tile Height: #{@tile_height}"
+      end
+    
+      def load_image!(image_data)
+        @image_file = File.expand_path("#{MAP_PATH}/#{image_data["source"]}")
+        @image_transparency_color = image_data["trans"]
+      
+        @dimensions  = ImageUtil.dimensions(@image_file)
+        @tiles_count = @dimensions.first * @dimensions.last / (@tile_width * @tile_height)
+      
+        Logger.trace "Loaded tileset image data: File '#{@image_file}' Mask Color: #{@image_transparency_color} Dimensions: #{@dimensions.join(" * ")} Tiles: #{@tiles_count}"
+      end
+    end
+  end
+end

data/lib/beefdump/monkey_patches/open_struct.rb

@@ -0,0 +1,4 @@
+require 'ostruct'
+class OpenStruct
+  undef class
+end

data/lib/beefdump/monkey_patches/string.rb

@@ -0,0 +1,5 @@
+class String
+  def numeric?
+    Float(self) rescue false
+  end
+end

data/lib/beefdump/utils/image_util.rb

@@ -0,0 +1,47 @@
+module Beefdump
+  class ImageUtil
+  
+    # credits: http://snippets.dzone.com/posts/show/805
+    def self.dimensions(file)
+      case file
+      when /\.png$/i
+        IO.read(file)[0x10..0x18].unpack('NN')
+      when /\.jpg$/i
+        File.open(file, 'rb') do |io|
+          raise 'malformed JPEG' unless io.getc == 0xFF && io.getc == 0xD8 # SOI
+
+          class << io
+            def readint; (readchar << 8) + readchar; end
+            def readframe; read(readint - 2); end
+            def readsof; [readint, readchar, readint, readint, readchar]; end
+            def next
+              c = readchar while c != 0xFF
+              c = readchar while c == 0xFF
+              c
+            end
+          end
+
+          while marker = io.next
+            case marker
+              when 0xC0..0xC3, 0xC5..0xC7, 0xC9..0xCB, 0xCD..0xCF # SOF markers
+                length, bits, height, width, components = io.readsof
+                raise 'malformed JPEG' unless length == 8 + components * 3
+              when 0xD9, 0xDA:  break # EOI, SOS
+              when 0xFE:        @comment = io.readframe # COM
+              when 0xE1:        io.readframe # APP1, contains EXIF tag
+              else              io.readframe # ignore frame
+            end
+          end
+          [width, height]
+        end
+      when /\.bmp$/i
+        d = IO.read(file)[14..28]
+        d[0] == 40 ? d[4..-1].unpack('LL') : d[4..8].unpack('SS')
+      when /\.gif$/i
+        IO.read(file)[6..10].unpack('SS')
+      else
+        raise "Unsupported image type or 'wrong' file name suffix :/"
+      end
+    end
+  end
+end

data/lib/beefdump/world/entity.rb

@@ -0,0 +1,6 @@
+module Beefdump
+  module World
+    class Entity
+    end
+  end
+end

data/lib/beefdump/world/object.rb

@@ -0,0 +1,37 @@
+module Beefdump
+  module World
+    class Object < Entity
+      require 'beefdump/world/object_property'
+    
+      attr_reader :type, :properties
+    
+      def initialize(object_data)
+        load_object_attributes!(object_data)
+      
+        load_properties!(object_data["property"])
+      end
+    
+      protected
+      def load_object_attributes!(object_data)
+        raise "Objects must have a type!" unless @type = object_data["type"].to_sym
+      end
+    
+      def load_properties!(properties)
+        return unless properties
+      
+        @properties = {}
+        properties.each do |property|
+          load_property!(property)
+        end
+      end
+    
+      def load_property!(property)
+        mandatory = property["mandatory"]
+        mandatory = mandatory.downcase == "true" if mandatory
+
+        name = property["name"].to_sym
+        @properties[name] = ObjectProperty.new(name, property["type"], mandatory) 
+      end
+    end
+  end
+end

data/lib/beefdump/world/object_property.rb

@@ -0,0 +1,24 @@
+module Beefdump
+  module World
+    class ObjectProperty
+      TYPES = [:number, :string, :name_reference]
+    
+      attr_reader :name, :type
+    
+      def initialize(name, type, mandatory = false)
+        raise "Any object property need a name!" unless @name = name
+      
+        raise "Object property '#{@name}' has not type. Any property needs a type!" unless type 
+        type = type.to_sym
+        raise "Object property type '#{type}' is not supported! Use one of: #{TYPES.join(',')}." unless TYPES.include?(type)
+        @type = type
+      
+        @mandatory = !!mandatory
+      end
+    
+      def mandatory?
+        @mandatory
+      end
+    end
+  end
+end

data/lib/beefdump/world/player.rb

@@ -0,0 +1,6 @@
+module Beefdump
+  module World
+    class Player < Entity
+    end
+  end
+end

data/lib/beefdump/world/world.rb

@@ -0,0 +1,25 @@
+module Beefdump
+  module World
+    require 'xmlsimple'
+    require 'beefdump/world/entity'
+    require 'beefdump/world/object'
+    require 'beefdump/world/player'
+  
+    # Loads the object descriptions from the objects.xml file in the config folder.
+    def self.load
+      objects_file = "#{CONFIG_PATH}/objects.xml"
+      raise "Objects configuration missing! Please supply '#{objects_file}'." unless File.exist?(objects_file)
+
+      raise "Object configuration format invalid!" unless objectset = XmlSimple.xml_in(objects_file)["object"]
+      @objects = {}
+      objectset.each do |object_data|
+        object = Object.new(object_data)
+        @objects[object.type] = object
+      end
+    end
+  
+    def self.objects
+      @objects
+    end
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: beefdump
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Thorben Schr\xC3\xB6der"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-07 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: xml-simple
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: A testbed for non-player character AI in role-playing games.
+email: stillepost@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- lib/beefdump.rb
+- lib/beefdump/boot.rb
+- lib/beefdump/client/base.rb
+- lib/beefdump/client/graphical/client.rb
+- lib/beefdump/client/graphical/window.rb
+- lib/beefdump/config/base.rb
+- lib/beefdump/config/blueprint.rb
+- lib/beefdump/game/base.rb
+- lib/beefdump/game/player.rb
+- lib/beefdump/game/state.rb
+- lib/beefdump/logger.rb
+- lib/beefdump/map/layer.rb
+- lib/beefdump/map/map.rb
+- lib/beefdump/map/object.rb
+- lib/beefdump/map/tileset.rb
+- lib/beefdump/monkey_patches/open_struct.rb
+- lib/beefdump/monkey_patches/string.rb
+- lib/beefdump/utils/image_util.rb
+- lib/beefdump/world/entity.rb
+- lib/beefdump/world/object.rb
+- lib/beefdump/world/object_property.rb
+- lib/beefdump/world/player.rb
+- lib/beefdump/world/world.rb
+- README.md
+has_rdoc: true
+homepage: http://github.com/walski/beefdump
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A testbed for non-player character AI in role-playing games.
+test_files: []
+