rubyplay_framework 1.6.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3c77d7b777232da3f802d9d9159e08562e3c105d
+  data.tar.gz: f3cd748d4c311ae2c5e7a16be17ad9bbe6bf33f3
+SHA512:
+  metadata.gz: 9a7e262d96c1601a4cb2683c3bb7cda23ba156a878dcb0fdf46782b39118f6b82978f6a1f691c8e97c0ba9688181f3bf31f5714bbdc166ec16fcb73eafbe6c8f
+  data.tar.gz: 8f267960659b72c214d951bf99b11bf6bfc5f74c90e4346c8fbbca990344de579ddb8fa7be3fa067c8851e5391b97eb37f41179824867baaea5b65bf5ef6c120

data/lib/interpreter/gameLexer.rb

@@ -0,0 +1,94 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.5
+# from lexical definition file "lib/interpreter/gameLexer.rex".
+#++
+
+require 'racc/parser'
+class GameLanguage < Racc::Parser
+  require 'strscan'
+
+  class ScanError < StandardError ; end
+
+  attr_reader   :lineno
+  attr_reader   :filename
+  attr_accessor :state
+
+  def scan_setup(str)
+    @ss = StringScanner.new(str)
+    @lineno =  1
+    @state  = nil
+  end
+
+  def action
+    yield
+  end
+
+  def scan_str(str)
+    scan_setup(str)
+    do_parse
+  end
+  alias :scan :scan_str
+
+  def load_file( filename )
+    @filename = filename
+    open(filename, "r") do |f|
+      scan_setup(f.read)
+    end
+  end
+
+  def scan_file( filename )
+    load_file(filename)
+    do_parse
+  end
+
+
+  def next_token
+    return if @ss.eos?
+    
+    # skips empty actions
+    until token = _next_token or @ss.eos?; end
+    token
+  end
+
+  def _next_token
+    text = @ss.peek(1)
+    @lineno  +=  1  if text == "\n"
+    token = case @state
+    when nil
+      case
+      when (text = @ss.scan(/[ \t]+[a-z]+|[ \t]+[A-Z][a-z]+|[ \t]+[a-z]+\d+|[ \t]+[A-Z][a-z]+\d+/))
+         action { [:WORD, text.gsub!(/[\ \t]+/,'')] }
+
+      when (text = @ss.scan(/[ \t]+/))
+        ;
+
+      when (text = @ss.scan(/\d+|-\d+/))
+         action {[:NUMBER, text.to_i]}
+
+      when (text = @ss.scan(/\d+\.\d+|-\d+\.\d+/))
+         action {[:FLOAT, test.to_f]}
+
+      when (text = @ss.scan(/\w+/))
+         action {[:FUNCTION, text]}
+
+      else
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    else
+      raise  ScanError, "undefined state: '" + state.to_s + "'"
+    end  # case state
+    token
+  end  # def _next_token
+
+  def tokenize(code)
+    scan_setup(code)
+    tokens = []
+    while token = next_token
+      tokens << token
+    end
+    tokens
+  end
+end # class

data/lib/interpreter/gameLexer.rex

@@ -0,0 +1,24 @@
+class GameLanguage
+macro
+  BLANK	[\ \t]+ #only works on macro
+  NUMBER \d+|-\d+
+  FLOAT \d+\.\d+|-\d+\.\d+
+  WORD [\ \t]+[a-z]+|[\ \t]+[A-Z][a-z]+|[\ \t]+[a-z]+\d+|[\ \t]+[A-Z][a-z]+\d+
+  FUNCTION \w+
+rule
+  {WORD}   { [:WORD, text.gsub!(/[\ \t]+/,'')] }
+  {BLANK} #do nothing
+  {NUMBER} {[:NUMBER, text.to_i]}
+  {FLOAT} {[:FLOAT, test.to_f]}
+  {FUNCTION} {[:FUNCTION, text]}
+
+inner
+  def tokenize(code)
+    scan_setup(code)
+    tokens = []
+    while token = next_token
+      tokens << token
+    end
+    tokens
+  end
+end

data/lib/interpreter/gameParser.racc

@@ -0,0 +1,40 @@
+class GameLanguage
+rule
+  function : FUNCTION
+  | FUNCTION WORD { return val }
+  | FUNCTION WORD WORD { return val }
+  | FUNCTION WORD WORD WORD { return val }
+  | FUNCTION WORD WORD WORD WORD { return val }
+  | FUNCTION NUMBER NUMBER { return val }
+  | FUNCTION NUMBER NUMBER NUMBER { return val }
+end
+
+---- header
+  require_relative 'gameLexer'
+
+---- inner
+  @@functions = []
+  
+  def parse(object, input)
+    output = scan_str(input)
+    if(output.kind_of?(Array))
+    	if(@@functions.find { |f| (f[0] == output[0]) && (f.length == output.length) })
+  			object.public_send(output[0].to_sym, *(output.drop(1)))
+  		else
+  			raise RuntimeError, "No such function #{output[0]}"
+  	    end
+    else
+    	if(@@functions.find { |f| (f[0] == output) })
+  			object.public_send(output.to_sym)
+  		else
+  			raise RuntimeError, "No such function #{output}"
+  	    end
+    end
+  end
+  
+  def intialize_functions(filename)
+  	file = File.open(filename).read
+  	file.each_line { |line| 
+  		@@functions << line.gsub(/\s+/, ' ').strip.split(" ")
+  	}
+  end

data/lib/interpreter/gameParser.rb

@@ -0,0 +1,172 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.14
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+  require_relative 'gameLexer'
+
+class GameLanguage < Racc::Parser
+
+module_eval(<<'...end gameParser.racc/module_eval...', 'gameParser.racc', 16)
+  @@functions = []
+  
+  def parse(object, input)
+    output = scan_str(input)
+    if(output.kind_of?(Array))
+    	if(@@functions.find { |f| (f[0] == output[0]) && (f.length == output.length) })
+  			object.public_send(output[0].to_sym, *(output.drop(1)))
+  		else
+  			raise RuntimeError, "No such function #{output[0]}"
+  	    end
+    else
+    	if(@@functions.find { |f| (f[0] == output) })
+  			object.public_send(output.to_sym)
+  		else
+  			raise RuntimeError, "No such function #{output}"
+  	    end
+    end
+  end
+  
+  def intialize_functions(filename)
+  	file = File.open(filename).read
+  	file.each_line { |line| 
+  		@@functions << line.gsub(/\s+/, ' ').strip.split(" ")
+  	}
+  end
+...end gameParser.racc/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+     4,     5,     7,     2,     6,     3,     8,     9,    10,    11 ]
+
+racc_action_check = [
+     2,     2,     4,     0,     3,     1,     5,     7,     8,     9 ]
+
+racc_action_pointer = [
+     1,     5,    -3,     4,    -1,     2,   nil,     4,     4,     6,
+   nil,   nil ]
+
+racc_action_default = [
+    -8,    -8,    -1,    -8,    -2,    -8,    12,    -3,    -6,    -4,
+    -7,    -5 ]
+
+racc_goto_table = [
+     1 ]
+
+racc_goto_check = [
+     1 ]
+
+racc_goto_pointer = [
+   nil,     0 ]
+
+racc_goto_default = [
+   nil,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 6, :_reduce_none,
+  2, 6, :_reduce_2,
+  3, 6, :_reduce_3,
+  4, 6, :_reduce_4,
+  5, 6, :_reduce_5,
+  3, 6, :_reduce_6,
+  4, 6, :_reduce_7 ]
+
+racc_reduce_n = 8
+
+racc_shift_n = 12
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :FUNCTION => 2,
+  :WORD => 3,
+  :NUMBER => 4 }
+
+racc_nt_base = 5
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "FUNCTION",
+  "WORD",
+  "NUMBER",
+  "$start",
+  "function" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+# reduce 1 omitted
+
+module_eval(<<'.,.,', 'gameParser.racc', 3)
+  def _reduce_2(val, _values, result)
+     return val 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'gameParser.racc', 4)
+  def _reduce_3(val, _values, result)
+     return val 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'gameParser.racc', 5)
+  def _reduce_4(val, _values, result)
+     return val 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'gameParser.racc', 6)
+  def _reduce_5(val, _values, result)
+     return val 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'gameParser.racc', 7)
+  def _reduce_6(val, _values, result)
+     return val 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'gameParser.racc', 8)
+  def _reduce_7(val, _values, result)
+     return val 
+    result
+  end
+.,.,
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+end   # class GameLanguage

data/lib/map/dungeon.rb

@@ -0,0 +1,93 @@
+require 'nokogiri'
+require 'map/entity'
+
+module MapDungeon
+
+  class Dungeon
+    
+    def initialize(name = "", description = "")
+      @name, @description = name, description
+      @entities = Hash.new()
+    end
+    
+    #Attributes access
+    attr_accessor :name, :description
+    
+    #Add entities to the hash
+    def add_entity(entity, type)
+      if(@entities[type] == nil)
+        @entities[type] = [entity]
+      else
+        @entities[type] << entity
+      end
+    end
+    
+    #Remove the entity from the array
+    def remove_entity(entity, type)
+      @entities[type].delete(entity)
+    end
+    
+    #Returns true if the entity exists
+    def has_entity?(entity, type)
+      @entities[type].find { |e| entity.eql?(e) }  
+    end
+      
+    #Entity iterator
+    def each_entity()
+      @entities.each { |key, value|
+        value.each { |entity| yield entity }
+      }
+    end
+    
+    #Concrete entity iterator
+    def each_type_entity(type)
+      @entities[type].each { |entity| yield entity }
+    end
+    
+    #To string
+    def to_s()
+      "#{@name}: #{@description}"
+    end
+    
+  end
+  
+  #Dungeon builder class
+  class DungeonXPathBuilder
+    include MapEntity
+    
+    def initialize()
+      @dungeon = Dungeon.new()
+    end
+    
+    attr_reader :dungeon
+    
+    def build_XML_dungeon(name, description, node = nil, entityBuilder = "")
+      add_name(name)
+      add_description(description)
+      if(node != nil)
+        node.each() { |entity|
+          args = []
+          if(entityBuilder.length > 0)
+            builder = Object::const_get(entityBuilder).new()
+          else
+            builder = EntityXPathBuilder.new()
+          end
+          nodeSet = entity.xpath("*")
+          nodeSet.each { |n| args << n.content }
+          builder.build_XML_entity(*(args))
+          @dungeon.add_entity(builder.entity, builder.entity.type)
+        }
+      end
+    end
+    
+    def add_name(name)
+      @dungeon.name = name
+    end
+    
+    def add_description(description)
+      @dungeon.description = description
+    end
+    
+  end
+  
+end

data/lib/map/entity.rb

@@ -0,0 +1,59 @@
+require 'nokogiri'
+
+module MapEntity
+  
+  class Entity
+    
+    def initialize(type = "", nametag = "")
+      @type, @nametag = type, nametag
+    end
+    
+    #Attributes access
+    attr_accessor :type, :nametag
+    
+    #Redefinition of equal operator
+    def ==(other)
+      (self.class ==other.class) && (self.state == other.state)
+    end
+    
+    def to_s()
+      "Type: #{@type}\nName: #{@nametag}"
+    end
+    
+    #Use Entity == for eql? method
+    alias_method :eql?, :==
+    
+  protected
+      
+    def state
+      [type, nametag]
+    end
+      
+  end
+  
+  #Entity builder class
+  class EntityXPathBuilder
+    
+    def initialize()
+      @entity = Entity.new()
+    end
+    
+    attr_reader :entity
+    
+    #Builds the entity of a dungeon
+    def build_XML_entity(type, nametag)
+      add_type(type)
+      add_nametag(nametag)
+    end
+    
+    def add_type(type)
+      @entity.type = type
+    end
+    
+    def add_nametag(nametag)
+      @entity.nametag = nametag
+    end
+    
+  end
+  
+end

data/lib/map/map.rb

@@ -0,0 +1,228 @@
+require 'nokogiri'
+require 'map/point'
+require 'map/dungeon'
+require 'map/entity'
+require 'map/mapExceptions'
+
+class Map
+  
+include MapPoint, MapDungeon, MapEntity
+
+  def initialize()
+    @map_nodes = Hash.new()
+    @adjacencies = Hash.new()
+  end
+  
+  #Attribute access
+  attr_reader :map_nodes, :adjacencies
+  
+  #Builds the map structure from XML specification
+  def build_map(filePath, pointBuilder = "", dungeonBuilder = "", entityBuilder = "")
+    if(filePath.include?('http'))
+      doc = parse_from_URL(filePath)
+    else
+      doc = parse_from_XML(filePath)
+    end
+    doc.remove_namespaces!
+    doc.xpath("//node").each() { |node|
+      coords = node.xpath("point//*")
+      point = build_point(coords, pointBuilder)
+      dungeonElements = node.xpath("dungeon//*[not(name()='entity') and not(ancestor-or-self::entity)]")
+      dungeon = build_dungeon(node, dungeonElements, dungeonBuilder, entityBuilder)
+      @map_nodes[point] = dungeon
+      build_adjacent(point, node, pointBuilder)  
+    }
+    p = @map_nodes.keys().sample() #Get random key
+    if(@map_nodes.length() != check_connectivity(p))
+      raise MapExceptions::MalformedMapException.new()
+    end
+  end   
+  
+  #Puts move the entity from one point to an adjacent
+  def movement(fromPoint, toPoint, entity)
+    if(is_adjacent?(fromPoint, toPoint))
+        remove_entity(fromPoint, entity)
+        add_entity(toPoint, entity)
+    else
+      raise MapExceptions::NotAdjacentException.new(fromPoint,toPoint)
+    end
+  end
+  
+  #Allows to make a movement without creating a explicit Point object
+  def move(point, entity, movX = 0, movY = 0, movZ = 0)
+    toPoint = Point.new(point.x()+movX, point.y()+movY, point.z()+movZ)
+    movement(point, toPoint, entity)
+  end
+  
+  #Check if point2 is in the adjacent list of point1
+  def is_adjacent?(point1, point2)
+    @adjacencies[point1].find { |p| point2 == p }  
+  end
+  
+  #Returns the node with that coordinates
+  def get_node(point)
+    @map_nodes[point]
+  end
+  
+  #Iterates over the adjacency hash
+  def each_adjacency()
+    @adjacencies.each { |key, value|
+      value.each { |adjacent| yield adjacent }
+    }
+  end
+  
+  #Allows user to add a new node after building the map
+  def add_new_node(point, node, adjacencies = [])
+    @map_nodes[point] = node
+    @adjacencies[point] = adjacencies
+    adjacencies.each do |p| 
+      if((@adjacencies[p] != nil) && !(is_adjacent?(p, point)))
+        @adjacencies[p] << point
+      end
+    end
+  end
+  
+  #Allows user to delete a node of the map
+  def delete_node(point)
+    @map_nodes.delete(point)
+    @adjacencies.delete(point)
+    @adjacencies.each { |k, v| @adjacencies[k].delete(point) }
+  end
+  
+  #Adds a new adjacent to point only if it belongs to the map
+  def add_new_adjacent(point, newAdjacent)
+    if((@map_nodes[point] != nil) && !(is_adjacent?(point, newAdjacent)) && (@map_nodes[newAdjacent] != nil))
+      @adjacencies[point] << newAdjacent
+      @adjacencies[newAdjacent] << point
+    end 
+  end
+  
+  #Delete a single element from the adjacent list of point
+  def delete_adjacent(point, adjacent)
+    @adjacencies[point].delete(adjacent)
+    @adjacencies[adjacent].delete(point)
+  end
+  
+  #Adds a new entity to the node
+  def add_entity(point, entity)
+    @map_nodes[point].add_entity(entity, entity.type())
+  end
+  
+  #Removes an entity
+  def remove_entity(point, entity)
+    @map_nodes[point].remove_entity(entity, entity.type())
+  end
+  
+  #Checks if there is an entity on the node
+  def has_entity?(point, entity)
+    @map_nodes[point].has_entity?(entity, entity.type())
+  end
+  
+  #Checks if the map generated is fully connected
+  def check_connectivity(point, visited = Hash.new())
+    visited[point] = 1
+    @adjacencies[point].each { |nextPoint|
+      if(!visited.has_key?(nextPoint))
+        check_connectivity(nextPoint, visited)
+      end
+    }
+    return visited.length()
+  end
+  
+  #Shortest path from initial to destination
+  def shortest_path(initial, destination)
+    distance = Hash.new()
+    visited = Hash.new()
+    @adjacencies.each_key { |point|
+      if(is_adjacent?(initial, point))
+        distance[point] = 1
+      else
+        distance[point] = (2**(0.size * 8 - 2) - 1)
+      end
+    }
+    visited[initial] = true
+    distance.delete(initial)
+    until(visited.length == @adjacencies.length) do
+      if((value = distance.values.min) != nil)
+        if(!(visited.has_key?(distance.key(value))))
+          nextNode = distance.key(value)
+          visited[nextNode] = true
+          if(nextNode == destination)
+            break;
+          end
+          @adjacencies[nextNode].each { |a|
+            alt = distance[nextNode] + 1
+            if(!(visited.has_key?(a)) && alt < distance[a])
+              distance[a] = alt
+            end
+          }
+          distance.delete(nextNode)
+        end
+      end
+    end
+    return distance[destination]
+  end
+
+protected
+  
+  #Parse XML document and returns a String
+  def parse_from_XML(file)
+    File.open(file) { |f| Nokogiri::XML(f) }
+  end
+  
+  #Parse XML from given url
+  def parse_from_URL(url)
+    Nokogiri::XML(open(url))
+  end   
+  
+  #Builds the point of a node
+  def build_point(nodeSet, pointBuilder = "")
+    args = []
+    if(pointBuilder.length > 0)
+      builder = Object::const_get(pointBuilder).new()
+    else
+      builder = PointXPathBuilder.new()
+    end
+    nodeSet.each { |node| args << node.content }
+    builder.build_XML_point(*(args))
+    builder.point()
+  end
+  
+  #Builds the dungeon object of a node
+  def build_dungeon(node, nodeSet, dungeonBuilder = "", entityBuilder = "")
+    args = []
+    if(dungeonBuilder.length > 0)
+      builder = Object::const_get(dungeonBuilder).new()
+    else
+      builder = DungeonXPathBuilder.new()
+    end
+    nodeSet.each { |n| args << n.content }
+    if(!(node.xpath("dungeon//entity").empty?))
+      args << node.xpath("dungeon//entity")
+      args << entityBuilder
+      builder.build_XML_dungeon(*(args))
+    else
+      builder.build_XML_dungeon(*(args))
+    end
+    builder.dungeon()
+  end
+
+  #Builds the adjacent list of a node
+  def build_adjacent(point, node, pointBuilder = nil)
+    node.xpath("adjacent//point").each() { |pnt|
+      coords = pnt.xpath(".//*")
+      p = build_point(coords, pointBuilder)
+      if(@adjacencies[point] == nil)
+        @adjacencies[point] = [p]
+      elsif(!(is_adjacent?(point, p)))
+        @adjacencies[point] << p
+      end
+      if(@adjacencies[p] == nil)
+        @adjacencies[p] = [point]
+      elsif(!(is_adjacent?(p, point)))
+        @adjacencies[p] << point
+      end
+    }
+  end
+  
+end

data/lib/map/mapExceptions.rb

@@ -0,0 +1,20 @@
+module MapExceptions
+  
+  class MalformedMapException < StandardError
+     
+    def initialize(msg="The given map is not fully connected")
+      super
+    end
+     
+  end
+   
+  class NotAdjacentException < StandardError
+     
+    def initialize(pointIni, pointFin)
+      msg = "Point #{pointFin} is not an adjacent point of #{pointIni}"
+      super(msg)
+    end
+     
+  end
+ 
+end

data/lib/map/point.rb

@@ -0,0 +1,69 @@
+require 'nokogiri'
+
+module MapPoint
+  
+  class Point
+    
+    def initialize(x = 0, y = 0, z = 0)
+      @x, @y, @z = x, y, z
+    end
+    
+    #Attributes access
+    attr_accessor :x, :y, :z
+    
+    #Redefinition of equal operator
+    def ==(other)
+      (self.class ==other.class) && (self.state == other.state)
+    end
+    
+    #Use Point == for eql? method
+    alias_method :eql?, :==
+    
+    #It allows to use Point as a hash key
+    def hash
+      state.hash
+    end
+    
+    #To string
+    def to_s
+      "(#{@x},#{@y},#{@z})"
+    end
+    
+  protected
+    
+    def state
+      [x, y, z]
+    end
+    
+  end
+  
+  #Point builder class
+  class PointXPathBuilder
+    
+    def initialize()
+      @point = Point.new()
+    end
+    
+    attr_reader :point
+    
+    #Builds the point of a node
+    def build_XML_point(x, y, z)
+      add_x(x.to_i)
+      add_y(y.to_i)
+      add_z(z.to_i)
+    end
+    
+    def add_x(x)
+      @point.x = x
+    end
+    
+    def add_y(y)
+      @point.y = y
+    end
+    
+    def add_z(z)
+      @point.z = z
+    end
+    
+  end
+end

data/lib/map.xsd

@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema targetNamespace="http://www.w3schools.com/map.xsd"
+    elementFormDefault="qualified"
+    xmlns="http://www.w3schools.com/map.xsd"
+    xmlns:xs="http://www.w3.org/2001/XMLSchema">
+    
+<xs:complexType name="pointType">
+	<xs:sequence>
+		<xs:element name="x" type="xs:integer"/>
+		<xs:element name="y" type="xs:integer"/>
+		<xs:element name="z" type="xs:integer"/>
+	</xs:sequence>
+</xs:complexType>
+
+<xs:complexType name="entityType">
+	<xs:sequence>
+		<xs:element name="type" minOccurs="1" maxOccurs="1">
+			<xs:simpleType>
+				<xs:restriction base="xs:string">
+					<xs:pattern value="[A-Z]([a-z])*"/>
+				</xs:restriction>
+			</xs:simpleType>
+		</xs:element>
+		<xs:element name="nametag" type="xs:string" minOccurs="1" maxOccurs="1"/>
+		<xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+	</xs:sequence>
+</xs:complexType>
+
+<xs:complexType name="dungeonType">
+	<xs:sequence>
+		<xs:element name="name" type="xs:string"/>
+		<xs:element name="description" type="xs:string"/>
+		<xs:element name="entity" type="entityType" minOccurs="0" maxOccurs="unbounded"/>
+	</xs:sequence>
+</xs:complexType>
+
+<xs:element name="map">
+  <xs:complexType>
+  	<xs:sequence>
+  		<xs:element name="node" minOccurs="2" maxOccurs="unbounded">
+		  <xs:complexType>
+		  	<xs:sequence>
+			    <xs:element name="point" type="pointType" minOccurs="1" maxOccurs="1"/>
+			    <xs:element name="dungeon" type="dungeonType" minOccurs="1" maxOccurs="1"/>
+			    <xs:element name="adjacent" minOccurs="1" maxOccurs="1">
+					<xs:complexType>
+						<xs:sequence>
+							<xs:element name="point" type="pointType" minOccurs="1" maxOccurs="unbounded"/>
+						</xs:sequence>
+					</xs:complexType>
+				</xs:element>
+		    </xs:sequence>
+		  </xs:complexType>
+  		</xs:element>
+  	</xs:sequence>
+  </xs:complexType>
+</xs:element>
+
+</xs:schema>

data/lib/rubyplay_framework.rb

@@ -0,0 +1,20 @@
+require 'map/map'
+require 'map/dungeon'
+require 'map/entity'
+require 'map/point'
+require 'map/mapExceptions'
+require 'interpreter/gameLexer'
+require 'interpreter/gameParser'
+
+module RubyplayFramework
+  include MapPoint, MapDungeon, MapEntity
+  
+  def init_Map()
+    Map.new()
+  end
+  
+  def init_Interpreter()
+    GameLanguage.new()
+  end
+  
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: rubyplay_framework
+version: !ruby/object:Gem::Version
+  version: 1.6.4
+platform: ruby
+authors:
+- Alvaro Pavon Alvarado
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.8
+- !ruby/object:Gem::Dependency
+  name: rexical
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: racc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.14
+description: A library to ease development of roleplay games for textual enviroments
+email: alvaro.pavon.alvarado@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/interpreter/gameLexer.rb
+- lib/interpreter/gameLexer.rex
+- lib/interpreter/gameParser.racc
+- lib/interpreter/gameParser.rb
+- lib/map.xsd
+- lib/map/dungeon.rb
+- lib/map/entity.rb
+- lib/map/map.rb
+- lib/map/mapExceptions.rb
+- lib/map/point.rb
+- lib/rubyplay_framework.rb
+homepage: https://github.com/Alvaro95pa/TFG_Alvaro_Pavon_URJC/tree/master
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Roleplay games development helper library
+test_files: []