Got some feedback (which I agreed with), suggesting not being able to trigger the impulsion while jumping was frustrating, so changed it. That change alone is going to affect level design a lot, but it's probably for the best!

#indiedev #gamedev #solodev #pixelart #haxe

Haxe 5 is pretty awesome. This macro function adds a bunch of functions to `Iterable` by adding metadata to it's type declaration specifying where to get the functions from. It's loaded automatically when the library loads. (using extraParams.hxml)

```haxe
static public macro function use(){
Compiler.addGlobalMetadata("Iterable",'@:using("stx.lift.IterableUses")');
return macro {};
}
```

#Haxe #Coding

I've long wanted to implement properly the paper "Combinators for bidirectional tree transformations" but I got snagged on their treatment of lists (which is to turn everything into a tree).

I think there's something I might be able to pull together by going back to extended set theory, namely set operations as ternary operations.

I have *some* of it, I did write two implementations, one over EDN, but I'm pretty sure it'll handle vectors like shit because it's optimised for records.

I also think I might be able to pull out an Arrow,
we've got Sequence (then) and XFork (first?) in the grammer, looking to externalise some the access operations.

#Coding #Haxe

So, here's this weeks spare time result:

A Multitouch PhotoTile App built with #haxe #Lime and #SDL3 running on a #RaspberryPi 5 with the #Wayland Video Driver and #Labwc ..

Oh and the photos are mine..
shot with a cheap clipon smartphone lens over the last couple of years.

A project I call "DichtbijKijker"

-> dutch compound word meaning a person looking up close , but also a wordplay on the dutch word for Binoculars: "Verrekijker" with the opposite meaning

Back working on Glot. Now I've got a description of macros that doesn't use positions and can live as datastructures outside of the macro context, I now have to be able to spell them out.

The whole lot can be described as enum constructors using ECall and object declarations using EObjectDecl, then encoded in JSON using the Haxe Object Notation, which is done (encode/decode)

Then I'm coming back the other way, using the Tiny Algebraic Schema Language (Haxe port) to describe types, which can produce Glot spellings which can then be ingested at macro time for type-checkable Haxe code, or as HScript at runtime.

#Haxe #Coding

Oh, hello?

#gamedev #indiedev #pixelart #solodev #haxe

The map between Haxe enumerations and `Hasl` is almost perfect. Objects go in `products` and Enums go in `coproducts`. lubberly.

#Haxe

I've got `Glot` which lets me turn macro expressions and type definitions into object/enum declarations (nearly there) and back to macros, and then `Hon` (Haxe Object Notation) which lets me encode enumerations into Json and parse that back in.

Then I've got `Hasl` (Haxe Algebraic Schema Language) which is a minimal type definition language, so the next step is to transform the `Hasl` AST into `Glot` which can then serve as a basis for sourcing and storing type definitions of all kinds at macro time.

Then I scrap pretty much everything I had in `Schema` and base DB schema on a particular instance of `Hasl`

#Haxe #Coding

I've got a pretty good sketch of what I call Haxe Object Notation, (HON) which is Class and Enum constructors encoded in Json, plus paths to handle circular references.

The EDN encoding is pretty nice as I can use tagged elements and use the ability to write reader functions in Clojures EDN parser, and given I've already got an EDN parser, that gives me calling into Babashka from Haxe and interpreting the return values.

My Haxe CLI stuff is a bit underdeveloped, so calling Haxe from Babashka is the next bit to work on, and that's where I'll get the nice Typed/Untyped balance I'm after, and of course there's SCI (Simple Clojure Interpreter) uses where Haxe and SCI compatible Clojurescript will be able coexist in the same runtime using EDN as an intermediary in the browser or node.

A proper knock-on-wood type system where you need it, and live-reload repl juiciness for building things out.

#Haxe #Clojure #Edn #Babashka #SCI #Nodejs #Clojurescript