Skip to content

Commit

Permalink
feat: no more type warnings!
Browse files Browse the repository at this point in the history 
Still plenty of bugs tho
  • Loading branch information
@russmatney
russmatney committed Feb 1, 2025
1 parent a28b47c commit 84309b3
Show file tree
Hide file tree
Showing 2 changed files with 83 additions and 82 deletions.
2 changes: 1 addition & 1 deletion src/Store.gd
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,7 +30,7 @@ func load_game() -> void:
events = initial_events()
else:
events.assign((data.events as Array)\
.filter(func(ev: Event) -> bool: return ev != null)\
.filter(func(ev: Variant) -> bool: return ev != null)\
# TODO handle crashes when events can't deserialize
.map(Pandora.deserialize))

Expand Down
163 changes: 82 additions & 81 deletions src/parse/ParsedGame.gd
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,63 +19,64 @@ func parse(contents: String) -> Dictionary:

# force a similar prelude header
contents = "=======\nPRELUDE\n=======\n\n" + contents
var raw_sections = contents.split("\n\n=")
for raw_s in raw_sections:
var chunks = raw_s.split("\n\n")
var header = chunks[0].split("\n")
var raw_sections := contents.split("\n\n=")
for raw_s: String in raw_sections:
var chunks: Array = Array(raw_s.split("\n\n"))
var header_rows: Array = (chunks[0] as String).split("\n")
chunks.remove_at(0)
header = header[1] # middle line
var parser = section_parsers.get(header.to_lower())
var header: String = header_rows[1] # middle line
var parser: Callable = section_parsers.get(header.to_lower())
if parser:
chunks = Array(chunks).map(func(c): return c.split("\n"))
chunks = chunks.map(func(chunk):
return Array(chunk).filter(func(c):
var chunkses: Array = Array(chunks).map(func(c: String) -> Array: return c.split("\n"))
var trimmed_chunks := chunkses.map(func(chunk_lines: Array) -> Array:
return chunk_lines.filter(func(c: String) -> bool:
return c != "" and c != "\t" and c != "\t\t" and c != "\t\t\t")
).filter(func(chunk): return len(chunk) > 0)
parsed[header.to_lower()] = parser.call(chunks)
).filter(func(chunk: Array) -> bool: return len(chunk) > 0)
parsed[header.to_lower()] = parser.call(trimmed_chunks)
return parsed

func parse_metadata(lines):
var data = {}
for l in lines:
func parse_metadata(lines: Array) -> Dictionary:
var data := {}
for l: String in lines:
if l == "":
continue
var parts = l.split(" ", false, 1)
var key = parts[0]
var parts := l.split(" ", false, 1)
var key := parts[0]
parts.remove_at(0)
var val = true
var val: Variant = true
if parts.size() > 0:
val = " ".join(parts)
data[key] = val
return data

## prelude #########################################################

func parse_prelude(chunks):
var lines = chunks.reduce(func(acc, x):
func parse_prelude(chunks: Array) -> Dictionary:
@warning_ignore("untyped_declaration")
var lines: Array = chunks.reduce(func(acc: Array, x: Array) -> Array:
acc.append_array(x)
# fking update-in-place with no return bs
return acc, [])
var prelude = {}
for l in lines:
var prelude := {}
for l: String in lines:
if l == "":
continue
var parts = l.split(" ", false, 1)
var key = parts[0]
var parts := l.split(" ", false, 1)
var key := parts[0]
parts.remove_at(0)
var val = true
var val: Variant = true
if parts.size() > 0:
val = " ".join(parts)
prelude[key] = val
return prelude

## objects #########################################################

func parse_objects(chunks):
var objs = {}
for lines in chunks:
var obj = {}
var nm_parts = lines[0].split(" ")
func parse_objects(chunks: Array) -> Dictionary:
var objs := {}
for lines: Array[String] in chunks:
var obj := {}
var nm_parts := lines[0].split(" ")
obj.name = nm_parts[0]
if nm_parts.size() > 1:
obj.symbol = nm_parts[1]
Expand All @@ -89,10 +90,10 @@ func parse_objects(chunks):

return objs

func parse_shape(lines, parse_int=false):
var shape = []
for l in lines:
var row = []
func parse_shape(lines: Array, parse_int: bool = false) -> Array:
var shape := []
for l: String in lines:
var row := []
for c in l:
if c == ".":
row.append(null)
Expand All @@ -106,108 +107,108 @@ func parse_shape(lines, parse_int=false):

## legend #########################################################

func parse_legend(chunks):
var legend = {}
for lines in chunks:
for l in lines:
var parts = l.split(" = ")
func parse_legend(chunks: Array) -> Dictionary:
var legend := {}
for lines: Array in chunks:
for l: String in lines:
var parts := l.split(" = ")
# support 'or' ?
var val_parts = parts[1].split(" and ")
var val_parts := parts[1].split(" and ")
legend[parts[0]] = Array(val_parts)

return legend

## sounds #########################################################

func parse_sounds(chunks):
var sounds = []
for lines in chunks:
for l in lines:
var parts = l.split(" ")
func parse_sounds(chunks: Array) -> Array:
var sounds := []
for lines: Array in chunks:
for l: String in lines:
var parts := l.split(" ")
sounds.append(Array(parts))
return sounds

## collision_layers #########################################################

func parse_collision_layers(chunks):
var layers = []
for lines in chunks:
for l in lines:
var parts = l.split(", ")
func parse_collision_layers(chunks: Array) -> Array:
var layers := []
for lines: Array in chunks:
for l: String in lines:
var parts := l.split(", ")
layers.append(Array(parts))
return layers

## rules #########################################################

func parse_rules(chunks):
var rules = []
for lines in chunks:
for l in lines:
var parts = l.split(" -> ")
var new_rule = {pattern=parse_pattern(parts[0])}
func parse_rules(chunks: Array) -> Array:
var rules := []
for lines: Array in chunks:
for l: String in lines:
var parts := l.split(" -> ")
var new_rule := {pattern=parse_pattern(parts[0])}
if len(parts) > 1:
new_rule["update"] = parse_pattern(parts[1])
rules.append(new_rule)
return rules

func parse_pattern(rule_pattern_str):
var initial_terms = []
func parse_pattern(rule_pattern_str: String) -> Array:
var initial_terms := []
# initial terms
if not rule_pattern_str.begins_with("["):
var parts = rule_pattern_str.split(" ")
for p in parts:
var parts := rule_pattern_str.split(" ")
for p: String in parts:
if p.begins_with("["):
break
else:
initial_terms.append(p)

# parse between the brackets
var regex = RegEx.new()
var regex := RegEx.new()
regex.compile("\\[\\s*(.*)\\s*\\]")
var res = regex.search(rule_pattern_str)
var res := regex.search(rule_pattern_str)

if res == null:
return initial_terms

var inner = res.get_string(1)
var inner := res.get_string(1)

var inner_cells = inner.split(" | ")
var cells = []
var inner_cells := inner.split(" | ")
var cells := []
for c in inner_cells:
var parts = c.split(" ")
var cell = []
var parts := c.split(" ")
var cell := []
for p in parts:
if len(p) > 0:
cell.append(p)
cells.append(cell)

var pattern = []
var pattern := []
pattern.append_array(initial_terms)
pattern.append_array(cells)
return pattern

## win_conditions #########################################################

func parse_win_conditions(chunks):
var conds = []
for lines in chunks:
for l in lines:
var parts = l.split(" ")
func parse_win_conditions(chunks: Array) -> Array:
var conds := []
for lines: Array in chunks:
for l: String in lines:
var parts := l.split(" ")
conds.append(Array(parts))
return conds

## puzzles #########################################################

func parse_puzzle(shape_lines: Array, raw_meta: Array = []) -> Dictionary:
var meta = parse_metadata(raw_meta)
var raw_shape
var meta := parse_metadata(raw_meta)
var raw_shape: Variant = null
if shape_lines:
raw_shape = parse_shape(shape_lines)
var line_count: int = 0
if shape_lines:
line_count = len(shape_lines)

var puzzle = {
var puzzle := {
meta=meta,
shape=raw_shape,
height=line_count,
Expand All @@ -220,20 +221,20 @@ func parse_puzzle(shape_lines: Array, raw_meta: Array = []) -> Dictionary:
# maybe want to optimize away from this?
return puzzle.duplicate(true)

func parse_puzzles(chunks):
var puzzles = []
var skip = false
func parse_puzzles(chunks: Array) -> Array:
var puzzles: Array = []
var skip := false
for i in len(chunks):
if skip:
skip = false
continue
# NOTE this is precarious and weird!!
if chunks[i][0][0] in [".", "#", "a", "b", "o", "t", "x", "y"]:
puzzles.append(parse_puzzle(chunks[i]))
puzzles.append(parse_puzzle(chunks[i] as Array))
skip = false
else:
var raw_meta = chunks[i]
var shape_lines
var raw_meta: Array = chunks[i]
var shape_lines: Array = []
if i + 1 < len(chunks):
shape_lines = chunks[i+1]
puzzles.append(parse_puzzle(shape_lines, raw_meta))
Expand Down

0 comments on commit 84309b3

Please sign in to comment.