DagBall

menu (Esc)

displayLogs

top var= pause

TODO numDimsInACreature+1 pics generated in gpu, and 1 1millisecond gpu call per creatureType 
				(shares scalarField but can have multiple instances in par) make this kind of game object that, 
				so maybe up to 15 creature types and few instances of each, computed at once. 
				interacts mostly with eachother and turn off the other object types with a checkbox. take creatures as far 
				as they can go without balls cuz its all pixels they touch. leave most creatures nonmoving far off screen. 
				lay them out as world to explore thru. go 1-bit precision of dagball creatures. 200x200. maybe 100x100. 
				etc. each gpu thread can return 96 bits of is the creature there yes/no 
				TODO replace apCall.eval() and .evan() with 5 kinds of eval that put optimizations in 
				apCall.compiled.evalGpuMain, .evalCpuDiffeq, .evalCpuDiffeqParloc, .evanCpuMain, .evanCpuMainParloc. 
				TODO creatures that are each made of 1 moving circ and b balls it controls. B can differ between 
				Make creatures. The code can vary between creatures as they are normally cpucircs. Creatures can grab eachother by 
				one creatures balls get into a valley (energyWell) of another creature. From there they can stretch, squash, 
				twist, vibrate etc eachother. The outline color of a creatures balls should be the same color as its circs 
				border. Many circs will not be creatures (just normal circs with no balls) and many will. Creatures can 
				interact with all circs, but noncreature circs can only interact with balls (unless neuralGoo which as of 
				2024-6-13 isnt built). Make a doCreatures checkbox, vs just sim creatures if they exist? Its very important 
				that the circ move by physics as it will have position and velocity of x y angle. Figure out a way to 
				make the physics work with angle, which will require more code, maybe new kind of gradient code, for the 
				balls to apply force on the circs x y and angle. Auto wrap the angle by its position but dont wrap during 
				gradient of angle. Creatures must be able to climb, stack, and wrestle eachother. This must work with diffeq 
				but diffeq is optional for creatures. Diffeq like the pinball bumper *.dagball files but moving custom ways. 
				There will be an array in such a circ that has ball y and x positions OR maybe should recompile it to use the 
				existing balls array? Could do similar thing as EdJoint does for eds but between the multiple balls arrays?
			TODO:[[[
				New apc fields:
				* bit inEvaParloc_fillLocWithAll0sRightAfterCreate.
				* ape apeParloc.

Fields to remove from apc: beforeCode, code, compileToLang, preferCpu.

Fields to remove from ape: preferCpu.

Global fields to remove from Ap: Ap.lang.

New kinds of apc eval: evalGpuMain evalCpuDiffeq evalCpuDiffeqParloc evanCpuMain evanCpuMainParloc evalCpuDiffeqParloc.

Changes to gpu codeMaker and cpucirc code generator:
				* include hdr as parlocMem, and code that copies from it to y$ x$ etc, but do it by modifying ape, and make a variant of Ap.lazyEval that returns ape (likely already is one) instead of returns apc (Ap.Call) where apc.ape is that ape.
			]]]

DONE 2024-5-20: 2024-5-17TodoIsolateTheNaNErrorInTinyGLSL make TinyGlsl.callListener = callOfSimpleAs=>{...} and a button in dagball to set .callListener to something that looks for par having no nans and returned floats having at least 1 nan, and in that case does dagball.displayTxt('TinyGlsl.simple(code...etc...Float32Array.of(...)...)') of the call it did, including all params and returned floats. Display it with txt: in the main textarea in dagball as soon as that happens after pushing the button. also it might be useful for searching for other calls of tinyglsl.simple.

very simple 3d voxel system similar to https://github.com/benrayfield/statvoxel , that around each near local area has a 2d grid of voxels, 1 per direction that would be seen from screen there (bucket in that direction, keep nearest that matches, when loop thru other near "near local area"s to copy relevant voxels into here). Do that and make some fun 3d shapes of twisty caves and bridges etc. for monkeyball-like and snakepass-like games etc. will hook in ape language for various stuff maybe NPCs.

Maybe I should define small tensors of up to 9 dimensions (normally 1 or 2 sometimes 3 rarely 4) as colored dots on screen in an affine transform pattern, with its forexample 3 dimension vectors outward from the position of the tensor on screen, and adjust it automatically so fewer of them overlap in (y,x) on screen after aftransed. Have just 1 edge between that and circ. like (radiusesAndPhases parrMem (freqs 10) (floatsPerFreq 2)) is a 10x2 tensor so would be 20 dots on screen and just 1 line. VERY IMPORTANT: tensor contents are shown as brightness of those dots (few pixels wide dot each) live, in a different color than the background.

I like that 2+ circs could share tensors that way, BUT i likely also need ability to split off a subrange of them or individual float vars.

And I want parrFloat and localparFloat types, while float is stack. parrFloat would be like a tensor of 0 dimensions with 1 float in it. So maybe just define it as (name parrMem) since thats how you give 0 dimensions?

Do I want n dimensional tensor subranges? Convolution skipping of n rows m cols etc? This could get complicated

I can probably handle 2 levels of dag in the existsVoting and medianVoting. I'd figure out a way. lowest level being tensors/floats and layer above that being circleWithCode that points at such tensors/floats nearby.

Have circ tensorEds point at the (0,0,0...) index corner of each tensor/float. For a float its just 1 corner, a few pixels wide dot of live varying brightness either way.

If you want to split them, then maybe should have to do so in the code, so only whole tensors are used.

Imagine it with circle perimeter usually not displayed, but its center is, and (0,0,0... index) of each small tensor is displayed similarly, a bipartitle graph.
Each tensor and each circ has a name, so they get automatically connected when using that name in code. Automatic funcs you can click a button or keyboard shortcuts to find names, rename a bunch of things together, etc. Circs have position chosen by user, but arrays position is springy, wants to be near whichever circs ape code points at it.

Or instead of nd aftrans, could display tensor as flattened to 1d, with some marks on it to show where the dimensions start/end, like a 2x20 would be mark 10 mark 10 -> around to the first mark, on its perimeter. YES, i like it. so its all circs.

DONE: 2023-10-7 FIXME keyboard events are not showing up often since I put in that second div/textarea acting
			as a textarea on the right. Need to fix that ASAP before any more Ape code stuff, cuz it will get harder
			to fix the longer it takes to track down, and i need to do diffs with recent code files.

[[[
			SOLUTION: This makes it straightforward to code asap. DO IT...

* Do this: I could index it as only * and + and pow etc, in the abstract math, but in practice compute it as triangle loops etc. So in the math forestCurveFit would use square loop and at runtime in that math it would just decide not to do anything when c>=b but in generated glsl code it would be loop b up to something, loop c up to b. In those timeCycles in the math model where c>=b it would be a noOp. That way, its all alot easier to index, and forestCurveFit only gets misestimated as twice as many timeCycles as it actually does. Do this. YES. That means THERE IS NO TRIANGLE APETYPE but can get optimized to that. Since triangle loops will be less than 10% of all apes, it would be ok to put an IF in there even if it still gets optimized in generated code to a triangle loop (which would be best if it does). loop b, loop c, if b<c do loopbody, should get compiled to loop b, loop c up to b, loopbody, but very important that in the "outerjoin(thread,time,mems) is the core model of dagball.Ape" math model its all loops of constant size that dont depend on eachothers _i, only on eachothers _s.

* each ape has a constant size/_s and a single counter/_i.

* an ape's contents can not refer to its own name (for _s or _i).

* an ape can only be looped over once at a time (in a stack) but can occur again as siblings like if u wanted to loop over matDimB then that finishes then loop over matDimB again. If you want to loop over matDimB twice in a double loop, use {copy matDimB} for one of them.

* An apes childs can be loop vars, like in {* matDimA matDimC {+ ...}} that causes matDimA_i and matDimC_i to change inside the {+ ...}.

* Ptr arithmetic can use {somethingABC {p- matDimB 3}] meaning somethingABC[matDimB_i-3].

* Ptr arithmetic will use pairs of even/odd index in Float64Array as fromIncl toExcl ranges, and prove the possible mem read and mem write and if is read before written in localparMem or fill localparMem earlier with 0s of the sizes proved to readandorwrite.

* outerjoin(thread,time,mems) is the core model of dagball.Ape. Given input mems, it deterministiclyExceptRoundoff defines which float is at each index up to numThreads*numTimeCycles*memSize-1, and that can be treesearched in time by each ape knowing its _s.
			]]]

TODO write Ape code for a simpler form of ForestCurveFit, using the 2 triangle arrays in a square array,
			AND do similar for hypercubewave and raymarching 3d mandelbulb fractal. Those are the prototypes.

TODO write usecases for the union andOr unionMax dagball.Ape opcodes,
			then make them work in ape code in the manifold editor.
			This is needed to make dagball flexible enuf for what will be built later.
			Its a safe alternative to pointer arithmetic,
			and pointer arithmetic can still kind of be done but only in ways that dont cross into memory they shouldnt,
			and not all of those ways but most of them that have predictable read/write patterns at compile time.

The dagball.Player object with the votes for exists and median vote for priority
			will be useful even in single player, compared to the circs not working at all. Do it asap,
			and make some fun prototypes.

blah blah
			TODO check how long since last user input (mouse movement, keyboard, etc) and if its been longer than 10 minutes, stop simulating, cuz wasting GPU power. Make this user adjustable.

Dagball
Make a simpler demo, different code in dagball.Game constructor. Make elevators, gears, or something simple.

Dagball
A big part of the game will be exploring big areas that have unique stuff in them,
So i need a way to compute it solparsrly in 2d.
And might wantscrewballsctamblelike controls on some parts. Either that or a heavy ball that u can push to switch some parts by physics.
Start with just sparse bellcurveorrectanglewindowed glsl code that i can type in an editor in browser at chosen 2d positions.
Also consider LLMs helping design the game. But do it myself at first.
There will only be 1 kernelpair per near 2d area, sum of whichever are near.
So its smooth.
Some areas will emit balls. Some will consume balls.
Some will limit number of balls. Etc.
Object of the game will be to get a certain few balls, colored differently, to the end of the game far away, using many disposable balls along the way.
Also consider rubberbandlike paths as a weaker substitute for qlearning.
Plan is to port it to wikib later but it goviral soon first.

Dagball get working in mobile too