gruesome 0.0.3 → 0.0.4

data/lib/gruesome/z/object_table.rb

@@ -3,428 +3,428 @@ require_relative 'memory'
 require_relative 'abbreviation_table'
 
 module Gruesome
-	module Z
-		class ObjectTable
-			def initialize(memory)
-				@memory = memory
-				@header = Header.new(@memory.contents)
-				@abbreviation_table = AbbreviationTable.new(@memory)
-
-				@address = @header.object_tbl_addr
-
-				if @header.version <= 3
-					# versions 1-3 have 32 entries
-					@num_properties = 31
-				else
-					# versions 4+ have 32 entries
-					@num_properties = 63
-				end
-
-				@object_tree_address = @address + @num_properties*2
-
-				if @header.version <= 3
-					@attributes_size = 4
-					@object_id_size = 1
-
-					# Entry:
-					#
-					# Attributes (4 bytes)
-					# Parent Object ID (1 byte)
-					# Sibling Object ID (1 byte)
-					# Child Object ID (1 byte)
-					# Properties Address (2 bytes)
-				else
-					@attributes_size = 6
-					@object_id_size = 2
-
-					# Entry: (Object IDs are 2 bytes)
-					#
-					# Attributes (6 bytes)
-					# Parent Object ID (2 byte)
-					# Sibling Object ID (2 byte)
-					# Child Object ID (2 byte)
-					# Properties Address (2 bytes)
-				end
-
-				@obj_entry_size = @attributes_size + (@object_id_size * 3) + 2
-
-				# Check machine endianess
-				@endian = [1].pack('S')[0] == 1 ? 'little' : 'big'
-			end
-
-			def property_default(index)
-				index -= 1
-				index %= @num_properties
-
-				# The first thing in the table is the property defaults list
-				# So, simply lookup the 16-bit word at the entry given by index
-				prop_default_addr = @address + index*2
-				@memory.force_readw(prop_default_addr)
-			end
-
-			def object_entry(index)
-				index -= 1
-				obj_entry_addr = @object_tree_address + (index * @obj_entry_size)
-
-				attributes_address = obj_entry_addr
-				cur_addr = attributes_address
-
-				# read the attributes
-				attribute_bytes = []
-				@attributes_size.times do
-					attribute_bytes << @memory.force_readb(cur_addr)
-					cur_addr += 1
-				end
-
-				# read the object ids of associated objects
-				ids = (0..2).map do |i|
-					if @object_id_size == 2
-						id = @memory.force_readw(cur_addr)
-						cur_addr += 2
-					else
-						id = @memory.force_readb(cur_addr)
-						cur_addr += 1
-					end
-					id
-				end
-
-				properties_address = @memory.force_readw(cur_addr)
-
-				# return a hash with the information of the entry
-				{	:attributes_address => attributes_address,
-					:attributes => attribute_bytes, 
-					:parent_id => ids[0], 
-					:sibling_id => ids[1], 
-					:child_id => ids[2], 
-					:properties_address => properties_address	}
-			end
-
-			def object_get_child(index)
-				object_entry(index)[:child_id]
-			end
-
-			def object_get_sibling(index)
-				object_entry(index)[:sibling_id]
-			end
-
-			def object_get_parent(index)
-				object_entry(index)[:parent_id]
-			end
-
-			def object_set_child(index, child_id)
-				entry = object_entry(index)
-				addr = entry[:attributes_address] + @attributes_size + @object_id_size*2
-
-				if @object_id_size == 1
-					@memory.force_writeb(addr, child_id)
-				else
-					@memory.force_writew(addr, child_id)
-				end
-			end
-
-			def object_set_sibling(index, sibling_id)
-				entry = object_entry(index)
-				addr = entry[:attributes_address] + @attributes_size + @object_id_size
-
-				if @object_id_size == 1
-					@memory.force_writeb(addr, sibling_id)
-				else
-					@memory.force_writew(addr, sibling_id)
-				end
-			end
-
-			def object_set_parent(index, parent_id)
-				entry = object_entry(index)
-				addr = entry[:attributes_address] + @attributes_size
-
-				if @object_id_size == 1
-					@memory.force_writeb(addr, parent_id)
-				else
-					@memory.force_writew(addr, parent_id)
-				end
-			end
-
-			def object_insert_object(index, new_child)
-				# remove child from old parent
-				if object_get_parent(new_child) != 0
-					object_remove_object new_child
-				end
-
-				# add to new parent
-				object_set_sibling(new_child, object_get_child(index))
-				object_set_child(index, new_child)
-				object_set_parent(new_child, index)
-			end
-
-			def object_remove_object(index)
-				old_parent = object_get_parent(index)
-				object_set_parent(index, 0)
-
-				if old_parent != 0
-					current_child = object_get_child(old_parent)
-					if current_child == index
-						# if we are the primary child of our parent, we removed
-						# ourselves... so we have to set a new primary child
-						# to be my sibling
-						object_set_child(old_parent, object_get_sibling(index))
-					else
-						# if not, we are within some list of siblings
-						# we need to remove ourself from this linked list
-						# whose head is current_child
-						
-						last = current_child
-						sibling = object_get_sibling(current_child)
-						while sibling != 0
-							if sibling == index
-								# found me!
-								# now, set the sibling of the previous one
-								# to my sibling (removing me from the chain)
-								object_set_sibling(last, object_get_sibling(index))
-
-								# break out of the loop
-								break
-							end
-							last = sibling
-							sibling = object_get_sibling(sibling)
-						end
-					end
-				end
-			end
-
-			def object_short_text(index)
-				entry = object_entry(index)
-				prop_address = entry[:properties_address]
-
-				# text_len is the maximum number of bytes the string can have
-				text_len = @memory.force_readb(prop_address) * 2
-				chrs = @memory.force_readzstr(prop_address+1, text_len)[1]
-
-				ZSCII.translate(0, @header.version, chrs, @abbreviation_table)
-			end
-
-			def attribute_number_to_byte_bit_pair(attribute_number)
-				# get the byte and bit number
-				#
-				# Note: it counts from the MSB, so it has to
-				# reverse the bit_number by subtracting from 7
-				#
-				# That is, attribute  7 is byte 0, bit 0
-				#          attribute 17 is byte 2, bit 6
-				#          etc
-
-				byte_number = (attribute_number / 8).to_i
-				bit_number = attribute_number % 8
-				bit_number = 7 - bit_number
-
-				{ :byte => byte_number, :bit => bit_number }
-			end
-			private :attribute_number_to_byte_bit_pair
-
-			def object_has_attribute?(index, attribute_number)
-				entry = object_entry(index)
-
-				location = attribute_number_to_byte_bit_pair(attribute_number)
-				attribute_byte = entry[:attributes][location[:byte]]
-				mask = 1 << location[:bit]
-
-				(attribute_byte & mask) > 0
-			end
-
-			def object_set_attribute(index, attribute_number)
-				entry = object_entry(index)
-
-				location = attribute_number_to_byte_bit_pair(attribute_number)
-				attribute_byte = entry[:attributes][location[:byte]]
-				mask = 1 << location[:bit]
-
-				attribute_byte |= mask
-
-				byte_addr = entry[:attributes_address] + location[:byte]
-				@memory.force_writeb(byte_addr, attribute_byte)
-			end
-
-			def object_clear_attribute(index, attribute_number)
-				entry = object_entry(index)
-
-				location = attribute_number_to_byte_bit_pair(attribute_number)
-				attribute_byte = entry[:attributes][location[:byte]]
-				mask = 1 << location[:bit]
-
-				attribute_byte &= ~mask
-
-				byte_addr = entry[:attributes_address] + location[:byte]
-				@memory.force_writeb(byte_addr, attribute_byte)
-			end
-
-			def object_get_size_and_number(prop_address)
-				size = 0
-				property_number = 0
-				if @header.version <= 3
-					size = @memory.force_readb(prop_address)
-					prop_address += 1
-
-					# when size is 0, this is the end of the list
-					if size == 0
-						return nil
-					end
-
-					# size is considered 32 times the data size minus one
-					# property number is the first 5 bits
-					property_number = size & 0b11111
-
-					size = size >> 5
-					size += 1
-				else
-					# in versions 4+, the size and property number are given
-					# as two bytes.
-					#
-					# if bit 7 is set in the first byte:
-					#    The second byte is read where first 6 bits 
-					#    indicate size, bit 6 is ignored, bit 7 is set
-					# if bit 7 is clear in the first byte:
-					#    bit 6 is clear = size of 1
-					#    bit 6 is set = size of 2
-					#
-					# property number is first 6 bits of first byte
-
-					first_byte = @memory.force_readb(prop_address)
-					prop_address += 1
-
-					property_number = first_byte & 0b111111
-					if first_byte & 0b10000000 > 0
-						# bit 7 is set
-						second_byte = @memory.force_readb(prop_address)
-						prop_address += 1
-
-						size = second_byte & 0b111111
-
-						# a size of 0 is allowed, and will indicate a size of 64
-						if size == 0
-							size = 64
-						end
-					else
-						# bit 7 is clear
-						if first_byte & 0b1000000 > 0
-							# bit 6 is set
-							size = 2
-						else
-							# bit 6 is clear
-							size = 1
-						end
-					end
-				end
-
-				{ :size => size, :property_number => property_number, :property_data_address => prop_address }
-			end
-
-			def object_properties(index)
-				entry = object_entry(index)
-				prop_address = entry[:properties_address]
-
-				# get the length of the string in bytes
-				text_len = @memory.force_readb(prop_address) * 2
-				prop_address += 1
-
-				prop_address += text_len
-
-				properties = {}
-
-				while true do
-					entry_info = object_get_size_and_number(prop_address)
-
-					if entry_info == nil
-						break
-					end
-
-					# regardless of version, we now have the property size and the number
-
-					properties[entry_info[:property_number]] = {:size => entry_info[:size], :property_data_address => entry_info[:property_data_address]}
-					prop_address = entry_info[:property_data_address] + entry_info[:size]
-				end
-
-				properties
-			end
-
-			def object_get_property(index, property_number)
-				properties = object_properties(index)
-
-				property_data = []
-
-				property_info = properties[property_number]
-
-				if property_info == nil
-					property_data = nil
-				else
-					address = property_info[:property_data_address]
-					properties[property_number][:size].times do
-						property_data << @memory.force_readb(address)
-						address += 1
-					end
-				end
-
-				property_data
-			end
-
-			def object_get_property_addr(index, property_number)
-				properties = object_properties(index)
-
-				property_info = properties[property_number]
-
-				if property_info == nil
-					0
-				else
-					property_info[:property_data_address]
-				end
-			end
-
-			def object_get_property_data_size_from_address(address)
-				if @header.version <= 3
-					prop_address = address - 1
-				else
-					first_byte = @memory.force_readb(address-1)
-
-					if first_byte & 0b10000000 > 0
-						prop_address = address - 2
-					else
-						prop_address = address - 1
-					end
-				end
-				object_get_size_and_number(prop_address)[:size]
-			end
-
-			def object_get_property_word(index, property_number)
-				property_data = object_get_property(index, property_number)
-				if property_data == nil
-					property_default(property_number)
-				elsif property_data.size > 1
-					if @endian == 'little'
-						(property_data[1] << 8) | property_data[0]
-					else
-						(property_data[0] << 8) | property_data[1]
-					end
-				else
-					property_data[0]
-				end
-			end
-
-			def object_set_property_word(index, property_number, value)
-				properties = object_properties(index)
-
-				property_info = properties[property_number]
-
-				if property_info == nil
-					raise "put_prop attempted to set a property value for a property that did not exist"
-				else
-					if property_info[:size] == 1
-						value &= 0xff
-						@memory.force_writeb(property_info[:property_data_address], value)
-					elsif property_info[:size] == 2
-						@memory.force_writew(property_info[:property_data_address], value)
-					else
-						raise "put_prop attempted to set a property whose data size is larger than a word"
-					end
-				end
-			end
-		end
-	end
+  module Z
+    class ObjectTable
+      def initialize(memory)
+        @memory = memory
+        @header = Header.new(@memory.contents)
+        @abbreviation_table = AbbreviationTable.new(@memory)
+
+        @address = @header.object_tbl_addr
+
+        if @header.version <= 3
+          # versions 1-3 have 32 entries
+          @num_properties = 31
+        else
+          # versions 4+ have 32 entries
+          @num_properties = 63
+        end
+
+        @object_tree_address = @address + @num_properties*2
+
+        if @header.version <= 3
+          @attributes_size = 4
+          @object_id_size = 1
+
+          # Entry:
+          #
+          # Attributes (4 bytes)
+          # Parent Object ID (1 byte)
+          # Sibling Object ID (1 byte)
+          # Child Object ID (1 byte)
+          # Properties Address (2 bytes)
+        else
+          @attributes_size = 6
+          @object_id_size = 2
+
+          # Entry: (Object IDs are 2 bytes)
+          #
+          # Attributes (6 bytes)
+          # Parent Object ID (2 byte)
+          # Sibling Object ID (2 byte)
+          # Child Object ID (2 byte)
+          # Properties Address (2 bytes)
+        end
+
+        @obj_entry_size = @attributes_size + (@object_id_size * 3) + 2
+
+        # Check machine endianess
+        @endian = [1].pack('S')[0] == 1 ? 'little' : 'big'
+      end
+
+      def property_default(index)
+        index -= 1
+        index %= @num_properties
+
+        # The first thing in the table is the property defaults list
+        # So, simply lookup the 16-bit word at the entry given by index
+        prop_default_addr = @address + index*2
+        @memory.force_readw(prop_default_addr)
+      end
+
+      def object_entry(index)
+        index -= 1
+        obj_entry_addr = @object_tree_address + (index * @obj_entry_size)
+
+        attributes_address = obj_entry_addr
+        cur_addr = attributes_address
+
+        # read the attributes
+        attribute_bytes = []
+        @attributes_size.times do
+          attribute_bytes << @memory.force_readb(cur_addr)
+          cur_addr += 1
+        end
+
+        # read the object ids of associated objects
+        ids = (0..2).map do |i|
+          if @object_id_size == 2
+            id = @memory.force_readw(cur_addr)
+            cur_addr += 2
+          else
+            id = @memory.force_readb(cur_addr)
+            cur_addr += 1
+          end
+          id
+        end
+
+        properties_address = @memory.force_readw(cur_addr)
+
+        # return a hash with the information of the entry
+        {  :attributes_address => attributes_address,
+          :attributes => attribute_bytes, 
+          :parent_id => ids[0], 
+          :sibling_id => ids[1], 
+          :child_id => ids[2], 
+          :properties_address => properties_address  }
+      end
+
+      def object_get_child(index)
+        object_entry(index)[:child_id]
+      end
+
+      def object_get_sibling(index)
+        object_entry(index)[:sibling_id]
+      end
+
+      def object_get_parent(index)
+        object_entry(index)[:parent_id]
+      end
+
+      def object_set_child(index, child_id)
+        entry = object_entry(index)
+        addr = entry[:attributes_address] + @attributes_size + @object_id_size*2
+
+        if @object_id_size == 1
+          @memory.force_writeb(addr, child_id)
+        else
+          @memory.force_writew(addr, child_id)
+        end
+      end
+
+      def object_set_sibling(index, sibling_id)
+        entry = object_entry(index)
+        addr = entry[:attributes_address] + @attributes_size + @object_id_size
+
+        if @object_id_size == 1
+          @memory.force_writeb(addr, sibling_id)
+        else
+          @memory.force_writew(addr, sibling_id)
+        end
+      end
+
+      def object_set_parent(index, parent_id)
+        entry = object_entry(index)
+        addr = entry[:attributes_address] + @attributes_size
+
+        if @object_id_size == 1
+          @memory.force_writeb(addr, parent_id)
+        else
+          @memory.force_writew(addr, parent_id)
+        end
+      end
+
+      def object_insert_object(index, new_child)
+        # remove child from old parent
+        if object_get_parent(new_child) != 0
+          object_remove_object new_child
+        end
+
+        # add to new parent
+        object_set_sibling(new_child, object_get_child(index))
+        object_set_child(index, new_child)
+        object_set_parent(new_child, index)
+      end
+
+      def object_remove_object(index)
+        old_parent = object_get_parent(index)
+        object_set_parent(index, 0)
+
+        if old_parent != 0
+          current_child = object_get_child(old_parent)
+          if current_child == index
+            # if we are the primary child of our parent, we removed
+            # ourselves... so we have to set a new primary child
+            # to be my sibling
+            object_set_child(old_parent, object_get_sibling(index))
+          else
+            # if not, we are within some list of siblings
+            # we need to remove ourself from this linked list
+            # whose head is current_child
+            
+            last = current_child
+            sibling = object_get_sibling(current_child)
+            while sibling != 0
+              if sibling == index
+                # found me!
+                # now, set the sibling of the previous one
+                # to my sibling (removing me from the chain)
+                object_set_sibling(last, object_get_sibling(index))
+
+                # break out of the loop
+                break
+              end
+              last = sibling
+              sibling = object_get_sibling(sibling)
+            end
+          end
+        end
+      end
+
+      def object_short_text(index)
+        entry = object_entry(index)
+        prop_address = entry[:properties_address]
+
+        # text_len is the maximum number of bytes the string can have
+        text_len = @memory.force_readb(prop_address) * 2
+        chrs = @memory.force_readzstr(prop_address+1, text_len)[1]
+
+        ZSCII.translate(0, @header.version, chrs, @abbreviation_table)
+      end
+
+      def attribute_number_to_byte_bit_pair(attribute_number)
+        # get the byte and bit number
+        #
+        # Note: it counts from the MSB, so it has to
+        # reverse the bit_number by subtracting from 7
+        #
+        # That is, attribute  7 is byte 0, bit 0
+        #          attribute 17 is byte 2, bit 6
+        #          etc
+
+        byte_number = (attribute_number / 8).to_i
+        bit_number = attribute_number % 8
+        bit_number = 7 - bit_number
+
+        { :byte => byte_number, :bit => bit_number }
+      end
+      private :attribute_number_to_byte_bit_pair
+
+      def object_has_attribute?(index, attribute_number)
+        entry = object_entry(index)
+
+        location = attribute_number_to_byte_bit_pair(attribute_number)
+        attribute_byte = entry[:attributes][location[:byte]]
+        mask = 1 << location[:bit]
+
+        (attribute_byte & mask) > 0
+      end
+
+      def object_set_attribute(index, attribute_number)
+        entry = object_entry(index)
+
+        location = attribute_number_to_byte_bit_pair(attribute_number)
+        attribute_byte = entry[:attributes][location[:byte]]
+        mask = 1 << location[:bit]
+
+        attribute_byte |= mask
+
+        byte_addr = entry[:attributes_address] + location[:byte]
+        @memory.force_writeb(byte_addr, attribute_byte)
+      end
+
+      def object_clear_attribute(index, attribute_number)
+        entry = object_entry(index)
+
+        location = attribute_number_to_byte_bit_pair(attribute_number)
+        attribute_byte = entry[:attributes][location[:byte]]
+        mask = 1 << location[:bit]
+
+        attribute_byte &= ~mask
+
+        byte_addr = entry[:attributes_address] + location[:byte]
+        @memory.force_writeb(byte_addr, attribute_byte)
+      end
+
+      def object_get_size_and_number(prop_address)
+        size = 0
+        property_number = 0
+        if @header.version <= 3
+          size = @memory.force_readb(prop_address)
+          prop_address += 1
+
+          # when size is 0, this is the end of the list
+          if size == 0
+            return nil
+          end
+
+          # size is considered 32 times the data size minus one
+          # property number is the first 5 bits
+          property_number = size & 0b11111
+
+          size = size >> 5
+          size += 1
+        else
+          # in versions 4+, the size and property number are given
+          # as two bytes.
+          #
+          # if bit 7 is set in the first byte:
+          #    The second byte is read where first 6 bits 
+          #    indicate size, bit 6 is ignored, bit 7 is set
+          # if bit 7 is clear in the first byte:
+          #    bit 6 is clear = size of 1
+          #    bit 6 is set = size of 2
+          #
+          # property number is first 6 bits of first byte
+
+          first_byte = @memory.force_readb(prop_address)
+          prop_address += 1
+
+          property_number = first_byte & 0b111111
+          if first_byte & 0b10000000 > 0
+            # bit 7 is set
+            second_byte = @memory.force_readb(prop_address)
+            prop_address += 1
+
+            size = second_byte & 0b111111
+
+            # a size of 0 is allowed, and will indicate a size of 64
+            if size == 0
+              size = 64
+            end
+          else
+            # bit 7 is clear
+            if first_byte & 0b1000000 > 0
+              # bit 6 is set
+              size = 2
+            else
+              # bit 6 is clear
+              size = 1
+            end
+          end
+        end
+
+        { :size => size, :property_number => property_number, :property_data_address => prop_address }
+      end
+
+      def object_properties(index)
+        entry = object_entry(index)
+        prop_address = entry[:properties_address]
+
+        # get the length of the string in bytes
+        text_len = @memory.force_readb(prop_address) * 2
+        prop_address += 1
+
+        prop_address += text_len
+
+        properties = {}
+
+        while true do
+          entry_info = object_get_size_and_number(prop_address)
+
+          if entry_info == nil
+            break
+          end
+
+          # regardless of version, we now have the property size and the number
+
+          properties[entry_info[:property_number]] = {:size => entry_info[:size], :property_data_address => entry_info[:property_data_address]}
+          prop_address = entry_info[:property_data_address] + entry_info[:size]
+        end
+
+        properties
+      end
+
+      def object_get_property(index, property_number)
+        properties = object_properties(index)
+
+        property_data = []
+
+        property_info = properties[property_number]
+
+        if property_info == nil
+          property_data = nil
+        else
+          address = property_info[:property_data_address]
+          properties[property_number][:size].times do
+            property_data << @memory.force_readb(address)
+            address += 1
+          end
+        end
+
+        property_data
+      end
+
+      def object_get_property_addr(index, property_number)
+        properties = object_properties(index)
+
+        property_info = properties[property_number]
+
+        if property_info == nil
+          0
+        else
+          property_info[:property_data_address]
+        end
+      end
+
+      def object_get_property_data_size_from_address(address)
+        if @header.version <= 3
+          prop_address = address - 1
+        else
+          first_byte = @memory.force_readb(address-1)
+
+          if first_byte & 0b10000000 > 0
+            prop_address = address - 2
+          else
+            prop_address = address - 1
+          end
+        end
+        object_get_size_and_number(prop_address)[:size]
+      end
+
+      def object_get_property_word(index, property_number)
+        property_data = object_get_property(index, property_number)
+        if property_data == nil
+          property_default(property_number)
+        elsif property_data.size > 1
+          if @endian == 'little'
+            (property_data[1] << 8) | property_data[0]
+          else
+            (property_data[0] << 8) | property_data[1]
+          end
+        else
+          property_data[0]
+        end
+      end
+
+      def object_set_property_word(index, property_number, value)
+        properties = object_properties(index)
+
+        property_info = properties[property_number]
+
+        if property_info == nil
+          raise "put_prop attempted to set a property value for a property that did not exist"
+        else
+          if property_info[:size] == 1
+            value &= 0xff
+            @memory.force_writeb(property_info[:property_data_address], value)
+          elsif property_info[:size] == 2
+            @memory.force_writew(property_info[:property_data_address], value)
+          else
+            raise "put_prop attempted to set a property whose data size is larger than a word"
+          end
+        end
+      end
+    end
+  end
 end