Because the world really needs another planner app... I've just released a new one for free at itch.io:
https://jonaspeheim.itch.io/scatterplan
#solodev #gamedev #haxe #openfl

🛠️ Title: HaxeFlixel
🦊️ What's: A libre library for developing 2D games with the OpenFL and Haxe languages
🏡️ https://haxeflixel.com/
🐣️ https://github.com/HaxeFlixel
🔖 #LinuxGameDev #Library #Haxe
📦️ #Libre
📕️ https://lebottinlinux.vps.a-lec.org/LO.html

🥁️ Update: 6.1.2
⚗️ Signific. vers. 🦍️
📌️ Changes: https://github.com/HaxeFlixel/flixel/blob/dev/CHANGELOG.md
🦣️ From: 🛜️ https://github.com/HaxeFlixel/flixel/releases.atom

🐹️ https://www.youtube.com/embed/0ERcNEg61Lg
🐹️ https://www.youtube.com/embed/7jUKDSL2L6E
🎮️ https://www.youtube.com/embed/3sZokWGYMcI
🎮️ https://www.youtube.com/embed/wVmax3XesjQ
🎮️ https://www.youtube.com/embed/_2YqmbaKqv0

Seven days into this #AdventOfCode as primarily a #Haxe programmer, I'm quite annoyed that five of the puzzles so far have required me to use Int64, which is not as smooth of a process in Haxe as it is in other languages. I guess I should just assume I need to provide my answer in Int64 going forward, even if it doesn't look like it's necessary to do so.

I got as far as just passing the arguments straight through
```bash
bb -m zoot/apply --run Test
```
is effectively
```bash
haxe --run Test
```

noice.

#Haxe

Found `process/exec` today, which means I can run babashka, accumulate arguments for the haxe compiler, and have the babashka script replace it's own process with a call to haxe, as if I'd called haxe directly.

#Haxe

#WIP
A game with #haxeflixel ; I love the progress
#card #cardgame #game #programming #haxe #code #art #cardgamedevelopment #developer #gamedev #gamedevs

many brain farts today.

I'm describing the AST of Haxe in HASL (Haxe Algebraic Schema Language), so plenty of parameter parameters, and type types.
Took too long to figure out that the type of a three value array can be seen as a 3-tuple of string.

Because I wrote HON (Haxe Object Notation) to take care of enumerations classes and reference loops that were getting lost in Json.stringify, I'm using those constructors internally so, and here's the thing I'm looking to get to:

Write a HASL definition (EDN or JSON), and it should be able to inflate to a Haxe AST (called Glot) outside of the macro context.

Then if I want it in a program, I can hand Haxe that AST during the macro phase and it'll do type checking on it.

Because it's parent, TASL isn't too fussed about what constitutes a type, (A Uri is fine), it should be good for assembling all sorts of things in a typed way using the Haxe type system to do the heavy lifting.

#Haxe

I've left a type hole in so I can extend it elsewhere to test things.

Things like closed/open types, objects and such come to mind.

I think `Val` is the original https://tasl.io spec.

#Haxe #Coding

Right, progress on Haxe Algebraic Schema Language. I've plumbed it in such that I can do path based error reporting later on.

State now carries around the declarations so that I can iterate elsewhere, add to the declarations and then decode the lot.

It's a bit wordy but this is all explicit constructors atm.

#Haxe

Using `ComplexType` type to wrap my head around how Tiny Algebraic Schema Language looks in practice.

There's unnamed enums in TASL which you don't find in Haxe, but to my mind that's a private enum with a derived name.

I need a better algorithm for taking the declarations (Which is currently a DSL but doesn't have to be) and turning them into HASL (Haxe Algebraic Schema Language) AST though.

HASL classes should resolve to `TypeDefinition`,which get registered internally as the algorithm builds the `ComplexType` representation.

Something like that

#Haxe #Coding

Spent most of the afternoon trying to figure out how to get vscode to properly detect and handle both absolute and relative file paths so I can run the haxe compiler from a babashka repl session rather than the terminal, lots of internal mess I can't get to. (don't know where cwd is for file resolution from plugins)

I was about to give up when I updated the haxe nightly build and error messages are now all absolute, so I can use the vscode "link patterns" plugin, and redirect to a "file://" call which vscode gracefully handles.

#Haxe #Coding #Babashka #VsCode

This is as complicated as a show function needs to be. If I'm on a sys target, it passes it through `prettier`

#Haxe #Coding

A few hours messing about with #PlugData and #Lua. Can't get my head around luapath right now and there's a couple dependencies that Haxe pulls in that I'd rather not mess with.

#PureData #Haxe

Finally got a relay going for structured logging.

#Haxe #Coding

Whipping the parser combinator into shape.

#Haxe #Coding

Starting to look like a DSL.

#Haxe #Coding

Here's the reflection api

https://codeberg.org/ohmrun/stx_reflection

#Haxe

The test system just blasts out test results as log entries with a `stx.test` tag.

This is towards having a bunch of libraries do their testing back to back and have it as jsonl

Next to have a thing that looks in the `haxelib.json` picks out the dependencies, get the TestSuites and runs through the lot.

Once that's done, I can start publishing these packages.

#Haxe

Finally got something reasonably robust for output. I've a type which turns any Haxe value into a json value, and so I can now use external tools to do log parsing and such.

#Haxe #Programming #Coding

Been digging into BespokeSynth again.

This time to get to know the Python interpreter. Haxe compiles to Python ok, so I can develop the next phase of the Metaharmony stuff this way with a live input/output to test with.

I know puredata has a Lua interpreter (another Haxe target), and I may get around to that, but the development loop
is tighter here and it feels easier to scaffold.

#MusicProduction #Programming #MetaHarmony #Haxe #Coding