661 lines
15 KiB
Ruby
661 lines
15 KiB
Ruby
require 'bin_tools'
|
|
require 'json'
|
|
|
|
# Value Types
|
|
# :boolean, :u8, :s16, :s32, :float, :lookup, :bin, :rle
|
|
|
|
$ElementAutoParser = {}
|
|
|
|
class Element
|
|
attr_accessor :package, :name, :attributes, :children, :attributes_value_types;
|
|
def initialize
|
|
@attributes = {}
|
|
@attributes_value_types = {}
|
|
@children = []
|
|
@package = nil
|
|
@name = nil
|
|
end
|
|
def inspect
|
|
disp
|
|
end
|
|
def disp pre=0
|
|
fend = children.size == 0 ? (attributes.size == 0 ? " />" : "/>") : ">"
|
|
pres = ' ' * pre
|
|
fstart = if attributes.size == 0
|
|
"#{pres}<#{name}#{fend}"
|
|
else
|
|
"#{pres}<#{name}\n#{attributes_disp(pre)}\n#{pres}#{fend}"
|
|
end
|
|
if children.size > 0
|
|
"#{fstart}\n#{children_disp(pre)}#{pres}</#{name}>\n"
|
|
else
|
|
"#{fstart}\n"
|
|
end
|
|
end
|
|
def attributes_disp pre=0
|
|
pres = ' ' * (pre + 2)
|
|
attributes.map do |k, v|
|
|
value_type = attributes_value_types[k]
|
|
case value_type
|
|
when :boolean
|
|
if v
|
|
"#{pres}#{k}(#{value_type})"
|
|
else
|
|
"#{pres}#{k}(#{value_type})={#{v}}"
|
|
end
|
|
when :u8, :s16, :s32, :float
|
|
"#{pres}#{k}(#{value_type})={#{v}}"
|
|
when :lookup
|
|
"#{pres}#{k}(#{value_type})=\"#{v}\""
|
|
when :bin
|
|
"#{pres}#{k}(#{value_type})={#{v.inspect}}"
|
|
when :rle
|
|
"#{pres}#{k}(#{value_type})={#{v.inspect}}"
|
|
end
|
|
end.join("\n")
|
|
end
|
|
def children_disp pre=0
|
|
children.map { |c| c.disp(pre + 2) }.join("\n")
|
|
end
|
|
def get_children_by_name child_name
|
|
children.select { |c| c.name == child_name }
|
|
end
|
|
def find_child_by_name child_name
|
|
children.detect { |c| c.name == child_name }
|
|
end
|
|
def [] name
|
|
attributes[name.to_s]
|
|
end
|
|
def set_attribute name, value_type, value
|
|
attributes[name.to_s] = value
|
|
attributes_value_types[name.to_s] = value_type
|
|
end
|
|
def self.auto_type num
|
|
if (num >= 0 && num <= 255)
|
|
:u8
|
|
elsif num >= -32768 && num < 32768
|
|
:s16
|
|
else
|
|
:s32
|
|
end
|
|
end
|
|
|
|
def set_num_attribute name, num
|
|
num = num.to_i(16) if num.is_a? String
|
|
set_attribute name, self.class.auto_type(num), num
|
|
end
|
|
|
|
|
|
|
|
def set_lookup_attribute name, str
|
|
set_attribute name, :lookup, str
|
|
end
|
|
|
|
def set_boolean_attribute name, val
|
|
set_attribute name, :boolean, val
|
|
end
|
|
|
|
def to_h
|
|
{
|
|
'name' => name,
|
|
'package' => package,
|
|
'attributes' => attributes,
|
|
'attribute_types' => attributes_value_types,
|
|
'children' => children.map(&:to_h)
|
|
}
|
|
end
|
|
def strings
|
|
strs = []
|
|
strs << name
|
|
attributes.each do |k, v|
|
|
strs << k
|
|
strs << v if attributes_value_types[k].to_sym == :lookup
|
|
end
|
|
children.each do |c|
|
|
strs += c.strings
|
|
end
|
|
strs.compact.uniq
|
|
end
|
|
def self.from_h obj
|
|
element = self.new
|
|
element.name = obj['name']
|
|
element.package = obj['package']
|
|
element.attributes = obj['attributes']
|
|
element.attributes_value_types = obj['attribute_types']
|
|
extra_children = []
|
|
element.children = obj['children'].map do |c|
|
|
parser = nil
|
|
c.each do |k, v|
|
|
parser = $ElementAutoParser[k] if $ElementAutoParser[k]
|
|
end
|
|
z = if parser
|
|
parser.from_h c
|
|
else
|
|
if c.has_key?('repeat')
|
|
clones = (0..c['repeat']).each do |rr|
|
|
nn = c.clone
|
|
nn['attributes'] = nn['attributes'].clone
|
|
nn['attribute_types'] = nn['attribute_types'].clone
|
|
c['repeat_attributes'].each do |k, v|
|
|
nn['attributes'][k] += (rr + 1) * v
|
|
nn['attribute_types'][k] = 's16'
|
|
end
|
|
extra_children << from_h(nn)
|
|
end
|
|
end
|
|
from_h c
|
|
end
|
|
if z.is_a? Array
|
|
z.each_with_index do |zz, i|
|
|
extra_children << zz if i > 0
|
|
end
|
|
z.first
|
|
else
|
|
z
|
|
end
|
|
end
|
|
element.children += extra_children
|
|
element
|
|
end
|
|
end
|
|
|
|
|
|
class CelesteMap
|
|
attr_accessor :debug, :rom, :package, :string_lookup, :root, :writer
|
|
def initialize fn, fmt: :bin, debug: false
|
|
@debug = debug
|
|
case fmt
|
|
when :bin
|
|
@rom = BinTools::Reader.from_file(fn)
|
|
raise "Not a celeste map" unless rom.read_str_varlen == 'CELESTE MAP'
|
|
@package = rom.read_str_varlen
|
|
@string_lookup = (0...rom.read_u16_le).map { rom.read_str_varlen }
|
|
@root = read_element
|
|
@root.package = @package
|
|
when :json
|
|
obj = File.open(fn, 'rb') { |f| JSON.parse(f.read) }
|
|
raise "Not a celeste map" unless obj['type'] == 'CELESTE MAP'
|
|
@root = Element.from_h(obj['root'])
|
|
@package = @root.package
|
|
else
|
|
raise "unknown fmt #{fmt}"
|
|
end
|
|
end
|
|
|
|
def write fn
|
|
@writer = BinTools::BinWriter.new(fn)
|
|
@string_lookup = root.strings
|
|
writer.write_str_varlen 'CELESTE MAP'
|
|
writer.write_str_varlen root.package
|
|
writer.write_u16_le string_lookup.size
|
|
string_lookup.each do |s|
|
|
writer.write_str_varlen s
|
|
end
|
|
write_element root
|
|
writer.close
|
|
end
|
|
|
|
def write_json fn
|
|
File.open(fn, 'wb') do |f|
|
|
f.write JSON.pretty_generate(
|
|
obj = {
|
|
'type' => 'CELESTE MAP',
|
|
'root' => root.to_h
|
|
}
|
|
)
|
|
end
|
|
end
|
|
|
|
def write_element element
|
|
writer.write_u16_le string_lookup.index(element.name)
|
|
writer.write_byte element.attributes.size
|
|
element.attributes.each do |k, v|
|
|
writer.write_u16_le string_lookup.index(k)
|
|
vt = element.attributes_value_types[k]
|
|
case vt.to_sym
|
|
when :boolean
|
|
writer.write_byte 0
|
|
writer.write_bool v
|
|
when :u8
|
|
writer.write_byte 1
|
|
writer.write_byte v
|
|
when :s16
|
|
writer.write_byte 2
|
|
writer.write_s16_le v
|
|
when :s32
|
|
writer.write_byte 3
|
|
writer.write_s32_le v
|
|
when :float
|
|
writer.write_byte 4
|
|
writer.write_f32_le v
|
|
when :lookup
|
|
writer.write_byte 5
|
|
writer.write_u16_le string_lookup.index(v)
|
|
when :bin
|
|
writer.write_byte 6
|
|
writer.write_varlen_le v.size
|
|
v.each do |b|
|
|
writer.write_byte b
|
|
end
|
|
when :rle
|
|
writer.write_byte 7
|
|
rle = []
|
|
count = 0
|
|
lb = -1
|
|
v.each do |b|
|
|
if b != lb
|
|
if lb >= 0
|
|
rle << count
|
|
rle << lb
|
|
end
|
|
count = 0
|
|
lb = b
|
|
end
|
|
count += 1
|
|
end
|
|
if lb >= 0
|
|
rle << count
|
|
rle << lb
|
|
end
|
|
writer.write_u16_le rle.size
|
|
rle.each do |b|
|
|
writer.write_byte b
|
|
end
|
|
else
|
|
raise "unknown value type #{vt} for key #{k} with value #{v}"
|
|
end
|
|
|
|
end
|
|
writer.write_u16_le element.children.size
|
|
element.children.each do |child|
|
|
write_element child
|
|
end
|
|
end
|
|
|
|
def read_element pre=0
|
|
element = Element.new
|
|
element.name = string_lookup[rom.read_u16_le]
|
|
dputs "#{" " * pre}<#{element.name}"
|
|
rom.read_byte.times do |i|
|
|
key = string_lookup[rom.read_u16_le]
|
|
value_type_enc = rom.read_byte
|
|
value = nil
|
|
value_type = nil
|
|
case value_type_enc
|
|
when 0
|
|
value = rom.read_bool
|
|
if value
|
|
dputs "#{" " * (pre + 2)}#{key}"
|
|
else
|
|
dputs "#{" " * (pre + 2)}#{key}={#{value}}"
|
|
end
|
|
value_type = :boolean
|
|
when 1
|
|
value = rom.read_byte
|
|
dputs "#{" " * (pre + 2)}#{key}={#{value}}"
|
|
value_type = :u8
|
|
when 2
|
|
value = rom.read_s16_le
|
|
dputs "#{" " * (pre + 2)}#{key}={#{value}}"
|
|
value_type = :s16
|
|
when 3
|
|
value = rom.read_s32_le
|
|
dputs "#{" " * (pre + 2)}#{key}={#{value}}"
|
|
value_type = :s32
|
|
when 4
|
|
value = rom.read_f32_le
|
|
dputs "#{" " * (pre + 2)}#{key}={#{value}}"
|
|
value_type = :float
|
|
when 5
|
|
value = string_lookup[rom.read_u16_le]
|
|
dputs "#{" " * (pre + 2)}#{key}=\"#{value}\""
|
|
value_type = :lookup
|
|
when 6
|
|
count = rom.read_varlen_le
|
|
base = rom.tell
|
|
bin = []
|
|
while rom.tell < base + count
|
|
bin << rom.read_byte
|
|
end
|
|
# value = rom.read_str_varlen
|
|
dputs "#{" " * (pre + 2)}#{key}=\"#{value}\""
|
|
dputs "#{" " * (pre + 2)}#{key}={bin#{bin.inspect}}"
|
|
value = bin
|
|
value_type = :bin
|
|
when 7
|
|
count = rom.read_u16_le
|
|
base = rom.tell
|
|
bin = []
|
|
while rom.tell < base + count
|
|
num = rom.read_byte
|
|
val = rom.read_byte
|
|
num.times { bin << val }
|
|
end
|
|
value = bin
|
|
dputs "#{" " * (pre + 2)}#{key}={rle#{bin.inspect}}"
|
|
value_type = :rle
|
|
else
|
|
raise "unknown value type byte #{value_type_enc} for key #{key}"
|
|
end
|
|
element.attributes[key] = value
|
|
element.attributes_value_types[key] = value_type
|
|
end
|
|
dputs "#{" " * pre}>"
|
|
rom.read_u16_le.times do |j|
|
|
element.children << read_element(pre + 2)
|
|
end
|
|
dputs "#{" " * pre}</#{element.name}>"
|
|
element
|
|
end
|
|
def inspect
|
|
"<Bin #{package} />"
|
|
end
|
|
def dputs s
|
|
puts s if @debug
|
|
end
|
|
end
|
|
|
|
class NodeElement < Element
|
|
def self.with_xy x, y
|
|
e = self.new
|
|
e.name = 'node'
|
|
e.set_num_attribute 'x', x
|
|
e.set_num_attribute 'y', y
|
|
e
|
|
end
|
|
end
|
|
|
|
class EntityElement < Element
|
|
def self.gen_id key
|
|
@gen_id = {} unless @gen_id
|
|
@gen_id[key] = 0 unless @gen_id[key]
|
|
@gen_id[key] = @gen_id[key] + 1
|
|
@gen_id[key]
|
|
end
|
|
|
|
def self.reset_id key
|
|
@gen_id = {} unless @gen_id
|
|
@gen_id[key] = 0
|
|
end
|
|
|
|
def set_gen_id key
|
|
set_num_attribute 'id', self.class.gen_id(key)
|
|
end
|
|
|
|
def set_auto_name obj
|
|
self.name = obj['__entity']
|
|
end
|
|
|
|
def set_auto_num_attribute obj, name
|
|
set_num_attribute name, obj[name]
|
|
end
|
|
|
|
def set_auto_lookup_attribute obj, name
|
|
set_lookup_attribute name, obj[name]
|
|
end
|
|
|
|
def set_auto_boolean_attribute obj, name
|
|
set_boolean_attribute name, obj[name]
|
|
end
|
|
|
|
def set_auto_xy obj, oX = 0, oY = 0
|
|
x = obj['x']
|
|
y = obj['y']
|
|
x = x.to_i(16) if x.is_a? String
|
|
y = y.to_i(16) if y.is_a? String
|
|
|
|
set_num_attribute 'x', x + oX
|
|
set_num_attribute 'y', y + oY
|
|
end
|
|
|
|
def set_auto_width obj
|
|
set_auto_num_attribute obj, 'width'
|
|
end
|
|
|
|
def set_auto_height obj
|
|
set_auto_num_attribute obj, 'height'
|
|
end
|
|
|
|
def set_auto_wh obj
|
|
set_auto_width obj
|
|
set_auto_height obj
|
|
end
|
|
|
|
def set_origin x, y
|
|
set_num_attribute 'originX', x
|
|
set_num_attribute 'originY', y
|
|
end
|
|
|
|
def self.parse_player obj
|
|
e = self.new
|
|
e.set_auto_name obj
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_num_attribute 'width', 8
|
|
e.set_origin 4, 8
|
|
e
|
|
end
|
|
|
|
def self.parse_badeline_chaser obj
|
|
e = self.new
|
|
e.name = 'darkChaser'
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_origin 4, 8
|
|
e
|
|
end
|
|
|
|
def self.parse_booster obj
|
|
e = self.new
|
|
e.set_auto_name obj
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_auto_boolean_attribute obj, 'red'
|
|
e.set_origin 4, 4
|
|
e
|
|
end
|
|
|
|
def self.parse_move_block obj
|
|
e = self.new
|
|
e.name = 'moveBlock'
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_auto_wh obj
|
|
e.set_auto_lookup_attribute obj, 'direction'
|
|
e.set_auto_boolean_attribute obj, 'canSteer'
|
|
e.set_auto_boolean_attribute obj, 'fast'
|
|
e.set_origin 0, 0
|
|
e
|
|
end
|
|
|
|
def self.parse_black_gem obj
|
|
e = self.new
|
|
e.name = 'blackGem'
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_auto_boolean_attribute obj, 'removeCameraTriggers'
|
|
e.set_origin 6, 6
|
|
e
|
|
end
|
|
|
|
def self.parse_golden_berry obj
|
|
e = self.new
|
|
e.name = 'goldenBerry'
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_origin 8, 8
|
|
e
|
|
end
|
|
|
|
def self.parse_dream_block obj
|
|
e = self.new
|
|
e.name = 'dreamBlock'
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_auto_wh obj
|
|
e.set_auto_boolean_attribute obj, 'fastMoving'
|
|
e.set_origin 0, 0
|
|
e
|
|
end
|
|
|
|
def self.parse_kevin obj
|
|
e = self.new
|
|
e.name = 'crushBlock'
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_auto_wh obj
|
|
e.set_auto_lookup_attribute obj, 'axes'
|
|
e.set_auto_boolean_attribute obj, 'chillout'
|
|
e.set_origin 0, 0
|
|
e
|
|
end
|
|
|
|
def self.parse_water obj
|
|
e = self.new
|
|
e.name = 'water'
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_auto_wh obj
|
|
e.set_auto_boolean_attribute obj, 'steamy'
|
|
e.set_auto_boolean_attribute obj, 'hasBottom'
|
|
e.set_origin 0, 0
|
|
e
|
|
end
|
|
|
|
def self.parse_jump_thru obj
|
|
e = self.new
|
|
e.name = 'jumpThru'
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_auto_width obj
|
|
e.set_origin 0, 0
|
|
e
|
|
end
|
|
|
|
def self.parse_zip_mover obj
|
|
e = self.new
|
|
e.name = 'zipMover'
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_auto_wh obj
|
|
e.set_origin 0, 0
|
|
e.children << NodeElement.with_xy(obj['x2'], obj['y2'])
|
|
e
|
|
end
|
|
|
|
def self.parse_switch_gate obj
|
|
e = self.new
|
|
e.name = 'switchGate'
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_auto_wh obj
|
|
e.set_auto_boolean_attribute obj, 'persistent'
|
|
e.set_auto_lookup_attribute obj, 'sprite'
|
|
e.set_origin 0, 0
|
|
e.children << NodeElement.with_xy(obj['x2'], obj['y2'])
|
|
e
|
|
end
|
|
|
|
def self.parse_bumper obj
|
|
e = self.new
|
|
e.name = 'bigSpinner'
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_origin 16, 16
|
|
e
|
|
end
|
|
|
|
def self.parse_cloud obj
|
|
e = self.new
|
|
e.set_auto_name obj
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_auto_boolean_attribute obj, 'fragile'
|
|
e.set_origin 16, 0
|
|
e
|
|
end
|
|
|
|
def self.parse_spikes obj
|
|
e = self.new
|
|
e.name = 'spikes' + obj['direction']
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_auto_lookup_attribute obj, 'type'
|
|
case obj['direction']
|
|
when 'Up'
|
|
e.set_auto_width obj
|
|
e.set_origin 0, 4
|
|
when 'Down'
|
|
e.set_auto_width obj
|
|
e.set_origin 0, 0
|
|
when 'Left'
|
|
e.set_auto_height obj
|
|
e.set_origin 4, 0
|
|
when 'Right'
|
|
e.set_auto_height obj
|
|
e.set_origin 0, 0
|
|
end
|
|
e
|
|
end
|
|
|
|
def self.parse_touch_switch obj
|
|
e = self.new
|
|
e.name = 'touchSwitch'
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_xy obj
|
|
e.set_origin 4, 4
|
|
e
|
|
end
|
|
|
|
def self.parse_spinner obj
|
|
nY = obj['nY'] || 1
|
|
nX = obj['nX'] || 1
|
|
dY = obj['dY'] || 16
|
|
dX = obj['dX'] || 16
|
|
elements = []
|
|
nY.times do |iY|
|
|
nX.times do |iX|
|
|
e = self.new
|
|
e.set_auto_name obj
|
|
e.set_gen_id 'entity'
|
|
e.set_auto_boolean_attribute obj, 'attachToSolid'
|
|
e.set_auto_xy obj, iX * dX, iY * dY
|
|
e.set_origin 8, 8
|
|
elements << e
|
|
end
|
|
end
|
|
elements
|
|
end
|
|
|
|
def self.from_h obj
|
|
self.send("parse_#{obj['__entity']}", obj)
|
|
end
|
|
end
|
|
|
|
$ElementAutoParser['__entity'] = EntityElement
|
|
|
|
class SolidsElement < Element
|
|
def set_auto_xy obj, oX = 0, oY = 0
|
|
x = obj['offsetX'] || 0
|
|
y = obj['offsetY'] || 0
|
|
x = x.to_i(16) if x.is_a? String
|
|
y = y.to_i(16) if y.is_a? String
|
|
|
|
set_num_attribute 'offsetX', x + oX
|
|
set_num_attribute 'offsetY', y + oY
|
|
end
|
|
|
|
def self.from_h obj
|
|
e = self.new
|
|
e.name = 'solids'
|
|
e.set_auto_xy obj
|
|
inner = obj['map'].map do |str|
|
|
str.split('').map { |ch| ch.ord == 32 && '0'.ord || ch.ord } + [10]
|
|
end.flatten
|
|
e.set_attribute 'innerText', :rle, inner
|
|
e
|
|
end
|
|
end
|
|
|
|
$ElementAutoParser['__solids'] = SolidsElement
|