create new instances

This commit is contained in:
Synthasmagoria 2026-11-11 15:55:26 +01:00
commit 41b9eb7af0
2 changed files with 140 additions and 32 deletions

View file

@ -1,20 +1,36 @@
defaultLayer: "Instances" layer: "Instances"
objects: { objects: {
spikeUp: { spike_up: {
layer: "Threats", layer: "Threats",
objectName: "objSpikeUp", object_name: "objSpikeUp",
}, },
spikeDown: { spike_down: {
layer: "Threats", layer: "Threats",
objectName: "objSpikeDown", object_name: "objSpikeDown",
}, },
spikeLeft: { spike_left: {
layer: "Threats", layer: "Threats",
objectName: "objSpikeLeft", object_name: "objSpikeLeft",
}, },
spikeRight: { spike_right: {
layer: "Threats", layer: "Threats",
objectName: "objSpikeRight", object_name: "objSpikeRight",
},
spike_up: {
layer: "Threats",
object_name: "objSpikeUp",
},
spike_down: {
layer: "Threats",
object_name: "objSpikeDown",
},
spike_left: {
layer: "Threats",
object_name: "objSpikeLeft",
},
spike_right: {
layer: "Threats",
object_name: "objSpikeRight",
}, },
} }

138
main.odin
View file

@ -4,6 +4,8 @@ package main
import "base:runtime" import "base:runtime"
import "core:os" import "core:os"
import "core:math"
import "core:math/rand"
import "core:fmt" import "core:fmt"
import "core:encoding/json" import "core:encoding/json"
import "core:strings" import "core:strings"
@ -230,14 +232,59 @@ resource_room_layer_get_type :: proc(layer: json.Object) -> RoomLayerType {
return ._Invalid return ._Invalid
} }
resource_room_get_by_name :: proc(layers: json.Array, name: string) -> (_layer: json.Object, _ok: bool) {
for layer in layers {
layer := layer.(json.Object)
layer_name := layer["name"].(json.String)
if name == layer_name {
return layer, true
}
}
return {}, false
}
resource_path_is_type :: proc(path: string, type: ResourceType) -> bool { resource_path_is_type :: proc(path: string, type: ResourceType) -> bool {
path := strings.split(path, "/") path := strings.split(path, "/")
return path[0] == resource_type_folder_names[type] return path[0] == resource_type_folder_names[type]
} }
/* ### resource_room_layer_create_instance :: proc(version, resource_version, object_name: string, x, y: f64, allocator := context.allocator) -> json.Object {
PROGRAM instance_id_number := math.clamp(rand.uint64(), 0x10000000, 0xffffffff)
*/ instance_id_hex_buffer: [8]byte
instance_id_hex := strconv.write_uint(instance_id_hex_buffer[:], instance_id_number, 16)
instance_id := strings.concatenate({"inst_", instance_id_hex}, allocator)
instance := make(json.Object, allocator)
instance["$GMRInstance"] = version
instance["%Name"] = instance_id
instance["colour"] = 4294967295// 32 bit number
instance["frozen"] = false
instance["hasCreationCode"] = false
instance["ignore"] = false
instance["imageIndex"] = 0
instance["imageSpeed"] = 1.0
instance["inheritCode"] = false
instance["inheritedItemId"] = nil
instance["inheritItemSettings"] = false
instance["isDnd"] = false
instance["name"] = instance_id
object_id := make(json.Object, allocator)
object_id["name"] = object_name
object_id["path"] = "" // todo get object resource path
instance["objectId"] = object_id
instance["properties"] = json.Array({})
instance["resourceType"] = "GMRinstance"
instance["resourceVersion"] = resource_version
instance["rotation"] = 0.0
instance["scaleX"] = 1.0
instance["scaleY"] = 1.0
instance["x"] = x
instance["y"] = y
return instance
}
/* ### /* ###
PROGRAM PROGRAM
@ -245,7 +292,7 @@ resource_path_is_type :: proc(path: string, type: ResourceType) -> bool {
HELP_MESSAGE :: """ HELP_MESSAGE :: """
--- GAMEMAKER JMAP IMPORTER --- --- GAMEMAKER JMAP IMPORTER ---
Usage: <program> <yyp_path> <jmap_path> <jmap_config_path> [other flags...] Usage: <program> <room_resource_path> <jmap_path> <jmap_config_path> [other flags...]
""" """
main :: proc() { main :: proc() {
@ -255,10 +302,10 @@ main :: proc() {
fmt.println("ERROR: Too few arguments") fmt.println("ERROR: Too few arguments")
fmt.println(HELP_MESSAGE) fmt.println(HELP_MESSAGE)
case: case:
yyp_path := os.args[1] room_resource_path := os.args[1]
jmap_path := os.args[2] jmap_path := os.args[2]
jmap_config_path := os.args[3] jmap_config_path := os.args[3]
error := program(yyp_path, jmap_path, jmap_config_path) error := program(room_resource_path, jmap_path, jmap_config_path)
if error != nil { if error != nil {
error := error.(ProgramError) error := error.(ProgramError)
fmt.println("ERROR:", error.message) fmt.println("ERROR:", error.message)
@ -269,6 +316,9 @@ main :: proc() {
ProgramErrorError :: enum { ProgramErrorError :: enum {
JmapBadObjectList, JmapBadObjectList,
BadJmapConfig,
RoomLayerNotFound,
RoomLayerNotInstance,
} }
ProgramErrorType :: union { ProgramErrorType :: union {
@ -288,44 +338,72 @@ program_error_create :: proc(error: ProgramErrorType, message: string, loc := #c
return {type = error, message = message, location = loc} return {type = error, message = message, location = loc}
} }
program :: proc(yyp_path, jmap_path, jmap_config_path: string) -> Maybe(ProgramError) { program :: proc(room_resource_path, jmap_path, jmap_config_path: string) -> Maybe(ProgramError) {
yyp_string, yyp_read_error := os.read_entire_file_from_path(yyp_path, context.allocator) room_resource_string, room_resource_read_error := os.read_entire_file_from_path(room_resource_path, context.allocator)
if yyp_read_error != nil { if room_resource_read_error != nil {
return program_error_create(yyp_read_error, fmt.tprint("Couldn't open GameMaker project path at '", yyp_path, "'", sep = "")) return program_error_create(room_resource_read_error, fmt.tprint("Couldn't open GameMaker project path at '", room_resource_path, "'", sep = ""))
} }
yyp, yyp_parse_error := json.parse_bytes(yyp_string, allocator = context.allocator) room_resource_json, room_resource_parse_error := json.parse_bytes(room_resource_string, allocator = context.allocator)
if yyp_parse_error != nil { if room_resource_parse_error != nil {
return program_error_create(yyp_parse_error ,"Failed to parse yyp project json") return program_error_create(room_resource_parse_error ,"Failed to parse yyp project json")
} }
jmap, jmap_read_error := os.read_entire_file_from_path(jmap_path, context.allocator) jmap_json, jmap_read_error := os.read_entire_file_from_path(jmap_path, context.allocator)
if jmap_read_error != nil { if jmap_read_error != nil {
return program_error_create(jmap_read_error, fmt.tprint("Couldn't open jmap path at '", jmap_path, "'", sep = "")) return program_error_create(jmap_read_error, fmt.tprint("Couldn't open jmap path at '", jmap_path, "'", sep = ""))
} }
jmap_object_list, jmap_object_list_error := jmap_object_list_from_text(string(jmap), context.allocator, context.temp_allocator) jmap_instance_list, jmap_instance_list_error := jmap_instance_list_from_text(string(jmap_json), context.allocator, context.temp_allocator)
switch jmap_object_list_error { switch jmap_instance_list_error {
case .None: case .None:
case .NoStartMarker: case .NoStartMarker:
return program_error_create(jmap_object_list_error, "Couldn't find start marker in jmap") return program_error_create(jmap_instance_list_error, "Couldn't find start marker in jmap")
case .NoEndMarker: case .NoEndMarker:
return program_error_create(jmap_object_list_error, "Couldn't find end marker in jmap") return program_error_create(jmap_instance_list_error, "Couldn't find end marker in jmap")
case .BadListLength: case .BadListLength:
return program_error_create(jmap_object_list_error, "Object list was not of a correct length") return program_error_create(jmap_instance_list_error, "Object list was not of a correct length")
case .BadObject: case .BadObject:
return program_error_create(jmap_object_list_error, "Bad object in jmap object list") return program_error_create(jmap_instance_list_error, "Bad object in jmap object list")
} }
fmt.println(jmap_object_list)
jmap_config_text, jmap_config_read_error := os.read_entire_file_from_path(jmap_config_path, allocator = context.allocator) jmap_config_text, jmap_config_read_error := os.read_entire_file_from_path(jmap_config_path, allocator = context.allocator)
if jmap_config_read_error != nil { if jmap_config_read_error != nil {
return program_error_create(jmap_read_error, fmt.tprint("Couldn't open jmap config path at '", jmap_config_path, "'", sep = "")) return program_error_create(jmap_read_error, fmt.tprint("Couldn't open jmap config path at '", jmap_config_path, "'", sep = ""))
} }
jmap_config_json, jmap_config_parse_error := json.parse_bytes(jmap_config_text, allocator = context.allocator)
if jmap_config_parse_error != nil {
return program_error_create(jmap_config_parse_error, "Failed to parse jmap config");
}
jmap_config, jmap_config_ok := jmap_config_get_from_json(jmap_config_json)
if !jmap_config_ok {
return program_error_create(ProgramErrorError.BadJmapConfig, "Malformed jmap config")
}
room_resource := room_resource_json.(json.Object)
room_layers := room_resource["layers"].(json.Array)
room_layer, room_layer_found := resource_room_get_by_name(room_layers, jmap_config.layer)
if !room_layer_found {
return program_error_create(ProgramErrorError.RoomLayerNotFound, fmt.aprint("Couldn't find room layer '", jmap_config.layer, "'", sep = ""))
}
if room_layer_type := resource_room_layer_get_type(room_layer); room_layer_type != .Instance {
return program_error_create(ProgramErrorError.RoomLayerNotInstance, fmt.aprint("Found room layer '", jmap_config.layer, "' was not an instance layer", sep = ""))
}
for jmap_instance in jmap_instance_list {
}
return nil return nil
} }
JmapImportConfig :: struct {
layer: string,
}
JmapObjectListError :: enum { JmapObjectListError :: enum {
None, None,
NoStartMarker, NoStartMarker,
@ -338,7 +416,7 @@ JmapObjectInstance :: struct {
x, y, object_index: int, x, y, object_index: int,
} }
jmap_object_list_from_text :: proc(text: string, allocator: mem.Allocator, temp_allocator: mem.Allocator) -> (_object_list: []JmapObjectInstance, _error: JmapObjectListError) { jmap_instance_list_from_text :: proc(text: string, allocator: mem.Allocator, temp_allocator: mem.Allocator) -> (_object_list: []JmapObjectInstance, _error: JmapObjectListError) {
object_start_marker := "objects: (x, y, type)\n" object_start_marker := "objects: (x, y, type)\n"
object_start_marker_index := strings.index(text, object_start_marker) object_start_marker_index := strings.index(text, object_start_marker)
if object_start_marker_index == -1 { if object_start_marker_index == -1 {
@ -383,6 +461,20 @@ jmap_object_list_from_text :: proc(text: string, allocator: mem.Allocator, temp_
return object_list, .None return object_list, .None
} }
jmap_config_get_from_json :: proc(root: json.Value) -> (_config: JmapImportConfig, _ok: bool) {
_ok = true
root := root.(json.Object)
if layer, layer_ok := root["layer"]; !layer_ok {
fmt.println("ERROR: Couldn't find 'layer' property in jmap config")
_ok = false
} else {
_config.layer = layer.(json.String)
}
return _config, _ok
}
JmapObject :: enum { JmapObject :: enum {
Block = 1, Block = 1,
MiniBlock = 2, MiniBlock = 2,