#+feature dynamic-literals package main import "base:runtime" import "core:os" import "core:fmt" import "core:encoding/json" import "core:strings" import "core:strconv" import "core:mem" /* ### SWITCHES */ SwitchDefinition :: struct { name: string, fullname: string, shortname: string, usage: string, description: string, no_argument: bool, callback: proc(value: string, args: ^byte) -> (ok: bool), } SwitchSplitError :: enum { None, Empty, MissingDash, MissingStartQuote, MissingEndQuote, } switch_split :: proc(str: string) -> (name, value: string, err: SwitchSplitError) { name = "" value = "" err = .None if len(str) == 0 { err = .Empty return } if str[0] != '-' { err = .MissingDash return } colon_index := strings.index_rune(str, ':') if colon_index == -1 { name = str[1:] return } name = str[1:colon_index] value = str[colon_index + 1:] if value[0] != '"' && value[len(value) - 1] == '"' { err = .MissingStartQuote return } else if value[0] == '"' && value[len(value) - 1] != '"' { err = .MissingEndQuote return } if value[0] == '"' && value[len(value) - 1] == '"' { value = value[1:len(value) - 2] } return } process_switches :: proc(switch_definitions: []SwitchDefinition, args: []string, args_out: ^byte, temp_allocator := context.temp_allocator) -> (_ok: bool) { _ok = true error_state: bool switch_map := make(map[string]SwitchDefinition, temp_allocator) for switch_definition in switch_definitions { shortname := switch_definition.shortname shortname_length := len(shortname) if shortname_length > 0 { if shortname in switch_map { _ok = false existing_switch_definition := switch_map[shortname] fmt.eprintln("Argument error: Switch for ", switch_definition.name, " (", shortname, ") already existed for '", existing_switch_definition.name, sep = "") } else { switch_map[shortname] = switch_definition } } fullname := switch_definition.fullname fullname_length := len(fullname) if fullname_length > 0 { if fullname in switch_map { _ok = false existing_switch_definition := switch_map[fullname] fmt.eprintln("Argument error: Switch for ", switch_definition.name, " (", fullname, ") already existed for '", existing_switch_definition.name, sep = "") } else { switch_map[fullname] = switch_definition } } if shortname_length == 0 && fullname_length == 0 { _ok = false fmt.eprintln("Switch definition error: ", switch_definition.name, " had no shortname or fullname", sep = "") } } for arg in args[1:] { name, value, err := switch_split(arg) if err != .None { _ok = false fmt.eprintln("Argument error: ", err, " (", arg, ")", sep = "") continue } if name not_in switch_map { _ok = false fmt.eprintln("Argument error: Non-existent switch", name, sep = "") continue } switch_map[name].callback(value, args_out) } return _ok } /* ### GAMEMAKER RESOURCE HANDLING */ GAMEMAKER_RESOURCE_JSON5_MARSHAL_OPTIONS :: json.Marshal_Options { spec = .JSON5, pretty = true, sort_maps_by_key = true, indentation = 0, spaces = 4, use_spaces = true, } ResourceError :: union { os.Error, json.Error, json.Marshal_Error, } ResourceType :: enum { Extension, Font, Note, Object, Particle, Path, Room, Script, Sequence, Shader, Sound, Sprite, Tileset, } @rodata resource_type_folder_names := [ResourceType]string { .Extension = "extensions", .Font = "fonts", .Note = "notes", .Object = "objects", .Particle = "particles", .Path = "paths", .Room = "rooms", .Script = "scripts", .Sequence = "sequences", .Shader = "shaders", .Sound = "sound", .Sprite = "sprites", .Tileset = "tilesets", } RoomLayerType :: enum { Background, Instance, Tile, Path, Asset, Effects, UI, _Invalid, } @rodata room_layer_type_identifier := [RoomLayerType]string { .Background = "GMRBackgroundLayer", .Instance = "GMRInstanceLayer", .Tile = "GMRTileLayer", .Path = "GMRPathLayer", .Asset = "GMRAssetLayer", .Effects = "GMREffectsLayer", .UI = "GMRUiLayer", ._Invalid = "", } resource_read :: proc(path: string) -> (object: json.Object, err: ResourceError) { data := os.read_entire_file(path, context.allocator) or_return resource := json.parse(data, .JSON5, true) or_return object = resource.(json.Object) return } resource_write :: proc(path: string, data: json.Value) -> ResourceError { str := json.marshal(data, GAMEMAKER_RESOURCE_JSON5_MARSHAL_OPTIONS) or_return os.write_entire_file(path, str) or_return return nil } resource_get_version :: proc(resource: json.Object) -> string { return resource["resourceVersion"].(json.String) } resource_project_find_asset :: proc(project: json.Object, name: string, type: ResourceType) -> json.Value { resources := project["resources"].(json.Array) for resource in resources { id := resource.(json.Object)["id"].(json.Object) if id["name"].(json.String) != name { continue } if strings.split(id["path"].(json.String), "/")[0] != resource_type_folder_names[type] { continue } return resource } return nil } resource_room_layer_get_type :: proc(layer: json.Object) -> RoomLayerType { type_name := layer["resourceType"].(json.String) for type in RoomLayerType { if type_name == room_layer_type_identifier[type] { return type } } return ._Invalid } resource_path_is_type :: proc(path: string, type: ResourceType) -> bool { path := strings.split(path, "/") return path[0] == resource_type_folder_names[type] } /* ### PROGRAM */ /* ### PROGRAM */ HELP_MESSAGE :: """ --- GAMEMAKER JMAP IMPORTER --- Usage: [other flags...] """ main :: proc() { args := os.args switch len(args) { case 0, 1, 2, 3: fmt.println("ERROR: Too few arguments") fmt.println(HELP_MESSAGE) case: yyp_path := os.args[1] jmap_path := os.args[2] jmap_config_path := os.args[3] error := program(yyp_path, jmap_path, jmap_config_path) if error != nil { error := error.(ProgramError) fmt.println("ERROR:", error.message) fmt.println(error.location) } } } ProgramErrorError :: enum { JmapBadObjectList, } ProgramErrorType :: union { ProgramErrorError, JmapObjectListError, os.Error, json.Error } ProgramError :: struct { type: ProgramErrorType, message: string, location: runtime.Source_Code_Location, } program_error_create :: proc(error: ProgramErrorType, message: string, loc := #caller_location) -> ProgramError { return {type = error, message = message, location = loc} } program :: proc(yyp_path, jmap_path, jmap_config_path: string) -> Maybe(ProgramError) { yyp_string, yyp_read_error := os.read_entire_file_from_path(yyp_path, context.allocator) if yyp_read_error != nil { return program_error_create(yyp_read_error, fmt.tprint("Couldn't open GameMaker project path at '", yyp_path, "'", sep = "")) } yyp, yyp_parse_error := json.parse_bytes(yyp_string, allocator = context.allocator) if yyp_parse_error != nil { return program_error_create(yyp_parse_error ,"Failed to parse yyp project json") } jmap, jmap_read_error := os.read_entire_file_from_path(jmap_path, context.allocator) if jmap_read_error != nil { 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) switch jmap_object_list_error { case .None: case .NoStartMarker: return program_error_create(jmap_object_list_error, "Couldn't find start marker in jmap") case .NoEndMarker: return program_error_create(jmap_object_list_error, "Couldn't find end marker in jmap") case .BadListLength: return program_error_create(jmap_object_list_error, "Object list was not of a correct length") case .BadObject: return program_error_create(jmap_object_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) 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 nil } JmapObjectListError :: enum { None, NoStartMarker, NoEndMarker, BadListLength, BadObject, } JmapObjectInstance :: struct { 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) { object_start_marker := "objects: (x, y, type)\n" object_start_marker_index := strings.index(text, object_start_marker) if object_start_marker_index == -1 { return {}, .NoStartMarker } object_start_index := object_start_marker_index + len(object_start_marker) object_end_marker := "version:" object_end_index := strings.index(text, object_end_marker) if object_end_index == -1 { return {}, .NoEndMarker } object_list_string := text[object_start_index:object_end_index] object_list_split := strings.split(object_list_string, sep = " ", allocator = temp_allocator) if len(object_list_split) % 3 != 0 { return {}, .BadListLength } object_list := make([]JmapObjectInstance, len(object_list_split) / 3, allocator) for i := 0; i < len(object_list); i += 1 { x, x_ok := strconv.parse_int(strings.trim_space(object_list_split[i * 3 + 0]), 10) if !x_ok { fmt.println("ERROR: Couldn't parse x of object '", object_list_split[i * 3 + 0], "'", sep = "") return {}, .BadObject } y, y_ok := strconv.parse_int(strings.trim_space(object_list_split[i * 3 + 1]), 10) if !y_ok { fmt.println("ERROR: Couldn't parse y of object '", object_list_split[i * 3 + 1], "'", sep = "") return {}, .BadObject } object_index, object_index_ok := strconv.parse_int(strings.trim_space(object_list_split[i * 3 + 2]), 10) if !object_index_ok { fmt.println("ERROR: Couldn't parse object_index of object '", object_list_split[i * 3 + 2], "'", sep = "") return {}, .BadObject } object_list[i] = {x, y, object_index} } return object_list, .None } jmap_object_map := map[int]string { 1 = "block", 2 = "miniBlock", 3 = "spikeUp", 4 = "spikeRight", 5 = "spikeLeft", 6 = "spikeDown", 7 = "miniSpikeUp", 8 = "miniSpikeRight", 9 = "miniSpikeLeft", 10 = "miniSpikeDown", 11 = "fruit", 12 = "save", 13 = "platform", 14 = "water1", 15 = "water3", 16 = "vineR", 17 = "vineL", 18 = "killerBlock", 20 = "playerStart", 21 = "warp", 22 = "jumpRefresher", 23 = "water2", 24 = "gravityFlipperUp", 25 = "gravityFlipperDown", 26 = "saveFlipped", 27 = "bulletBlocker", 28 = "sidewaysPlatform", 30 = "miniWater1", 31 = "miniWater3", 32 = "miniWater2", 33 = "miniCatharsisWater", 34 = "waterNekoron", 35 = "miniWaterNekoron", 36 = "spikeUp", 37 = "spikeRight", 38 = "spikeLeft", 39 = "spikeDown", 40 = "spikeUp", 41 = "spikeRight", 42 = "spikeLeft", 43 = "spikeDown", 44 = "lineBlockHorizontal", 45 = "lineBlockVertical", 46 = "miniLineBlockHorizontal", 47 = "miniLineBlockVertical", } jmap_object_map_reverse: map[string]int