432 lines
11 KiB
Odin
432 lines
11 KiB
Odin
#+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: <program> <yyp_path> <jmap_path> <jmap_config_path> [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_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_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
|
|
}
|