cgpt

I am working on a computer graphics and debugging system that involves capturing moments in time when certain properties occurred on sets of objects

The A will capture moments of time that sets of C had properties that occurred. The A will talk of C. The A.c.ip always positions A amongst a pile of A(.y.up=Aabove or .sc.z=[Abelow]) with various properties to recurse into, each coming from some other A.

you should be able to build a robust and reliable system.

A has four properties: t, y, c, sc. so does C. A.t is the name of a kind of object class to apply to the A. A.t is looked up in the mind, finding a thing to be like. y contains properties with the most empiricism from the underlying machine in them, eg A.y.up links to the A this A was sprouted from, A.y.cv is a fraction of 1 where the A is, etc. c contains properties still of quite machiney disposition, eg A.c.pi (unrelated to Math.pi or A.c.ip) is a super- and sub-type of class to apply (ie act like a pi of spacal if {pi:'spacal'}) forming the base identity of most atoms in most situations in the program, except perhaps in highly specialised corners. A.sc is the most open to the universal qualities of the thing in itself, beyond the machine that holds it, eg A.sc.colour is a pure essence from the thing we are modelling (on the machine)

the C (capital C) are artifacts (usually) independent of time (but sometimes modified over time as part of the process (whatever the mind says)), and the mind would be made of these. the mind is $mind/C**/D**, the ** there meaning that step may repeat infinitely. all that is C nested within each other, but the C are things and the D are steps|aspects within that thing.

the same way y,c,sc slopes towards the essential, A,C does also. A may hold many C in them (unless pressure to resolve micro-manipulations via A compels an A per C to take some linguistic and structural load) and tally various properties across the lot of them, usually grouping like C-things, so that the expression of many C on the screen can be a stack of individuals bulging around and|or into the items of identity that can be nested in space (ie a small 2d tiling problem, trying to express efficiently the composition of a bunch of information)

lets use this|that and outside/in notation. ie, house/room/person/dialectic is the situation around me now. the A also experiences time being the mind (of A.t, or overridden by A.c.mind_t), which can be measured out into A.y.cv (the A moves up to where mind/bit was) or A.y.mindbit (the mind/bit itself, which can be compared with others around it, even as A.y.cv if the bits are in different minds). so the A pick up minds and progress matter with them. usually an A would be tracking where its inside A are up to, so that they can be simpler, and keep cursors to resume from going async, iterate them in certain orders, etc.

"A.c.ip" forms an infinite branching space, which serves as an IP address of variable length. When lots of "A" objects are vacuumed out of graph space, some overall sense can be made of their origin and relation, potentially allowing other relations to be filled in as well. This suggests that the "A.c.ip" property is a key component of how "A" objects are organized and related to each other in the program.

below is typescript for A and C forming. A_(A1,t) make new A (with subdividing|serial-numbered A.c.ip). C dont usually have an ip, but A always do. C_('Bev') should return an empty C except for C.t='Bev' with the C.y|c|sc empty hashes|objects.

use A11 = A1.A_('someprocess') to create A:1.1 (A11.c.ip=[1,1]), begins serial A1.c.ips=1 (number of children had), does i_(A1, A11) to add A:1.1 to A:1 (into A1.sc.z=[...])

then give all A:1.* some C, with i_(). i_() must C.sc.z ||= [] to hold C, or C.sc.etc if qua='etc'. C.sc.z tends to mean "inside of". by default A have their children in A.sc.z, but they might move out...

if given no t argument in C_() or A_(), C.t can be set to '', A.t usu inherit from above.

the y,c,sc are each empty objects until properties are defined (eg C.sc.z), and all C should be created by C_() (and A by A.A_(), except the toplevel that is made by C_() and mutated into an A as above)

you shouldn't have to specify any y|c|sc in C_ or A_ you dont want to. C.t may be ''. C.c.ip generally dont happen whereas A.c.ip always does, just as C may not be in anything but A always are. all the A.c.ip looks good, but the counter needs to be on the A itself (not as static) and appear only when the A becomes a parent. A.c.ip should really be an array of numbers, so we can sort it well.

(paste St.ts (4de7140) from 35f75ce1bd3daa2a04cef44e01f500ea3d3b60c2 here)

export function realisme () {

let A1 = C_('toplevel')

A1.c.ip = [1]

let A11 = A_(A,'glamphor')

// ...

return [A1, A11]

}

// the baskets of properties that are C.y|c|sc

interface gc {

[key: string]: any

}

interface C {

t: string; // name of object class to apply to C

y: gc; // properties derived from the underlying machine

c: gc; // properties defining the base identity of C

sc: gc; // properties representing the essential qualities of C

}

interface A extends C {

y: {

up?: A; // A this A was sprouted from

}

c: {

ip: number[]; // IP address of variable length

ips?: number; // how many children it has had

}

}

// make new C, specifying innards

function C_(t: string|Array|C, y?:number|gc, c?:gc, sc?:gc):C {

if (isar(t)) {

[t,y,c,sc] = t

}

if (!isst(t)) {

// t must be C, from C_(C)

throw "TODO clone = C_(C)"

}

if (isnum(y)) {

if (y <= 0)

throw "y <= 0"

while (y > 1)

y /= 10

y = {cv:y}

}

t ||= ''

y ||= {}

c ||= {}

sc ||= {}

return {t,y,c,sc}

}

function A_(A:A, t?:string):A {

t ||= A.t

let A2 = C_(t)

// ip address (infinite position)

A.c.ips ||= 0

A.c.ips++

A2.c.ip = [...A.c.ip,A.c.ips]

// parent

A2.y.up = A

i_(A,A2)

return A2

}

function i_(C1: C, C2: C, qua: string = 'z') {

let N = C1.sc[qua] ||= []

N.push(C2)

}

// type checking, ported from Fividy

function isst(s) {

return typeof s == 'string'

}

function isnu(s) {

return typeof s == 'number'

}

function isnum(s) {

return (isnu(s) || s && s.length && !isspace(s)) && s*1 == s

}

function isar(s) {

return s && s.constructor == Array

}

let spacechars = {" ":1,"\n":1,"\t":1}

function isspace(s) {

return hak(s) && !havs(s).some(s => !spacechars[s])

}

// and further back

function hak(s,d) {

if (!s)

return 0

return d == null ? Object.keys(s).length : s.hasOwnProperty(d)

}

function havs(s,d) {

return haks(s).map(k => s [k])

}

function haks(s,d) {

let N = [];

if (!s) {

return N

}

for (let k in s) {

let v = s[k]

if (d == 'kv') { N.push(k,v) }

else

if (d == 's') { N.push(v) }

else {

N.push(k);

}

}

return N

} 

This will form the basis of some interactions hence. we will build a sequencer of thought that we shall call voicing. this will iterate mind and world simultaneously causing action.

It's an information gamer. A configurable linguistic bliss. You know how to use it, it's natural.

Remember it's typescript and all data should be in (A|C).*.*=... since we can recognise a network of A+C taking on rogueness as we cycle consciousness around over computer memory.

Now my question: Can you write some more realisme() to give A11 some landscape beyond it:

We shall A_(...) variously from A11 to A111, A112, A113, A12, A121, A1211, naming them after places like 'glamphor', then sprinkling them with authors like so:

 i_(A111,C_('Joyce',8,,{coal:1,surreal:1,dazzling:1}))

give them all at least one C about an author. the C.t should be the authors name, they may have %surrealism, %romance, etc as per the themes and qualities expected from them (%that is a way to specify C.sc.that=1, we shall go on to build a codifier of %state,such,as=this)

there should be a few properties each shared by a few authors so we have a few layers of islands of information.

Breakthrough

(just after adding the "it's natural" bit above we end being unsure or writing ruby datastructures, or empty A_ instead of A_(...))

Sure, here are some additional "realisme()" functions to add more landscapes beyond A11:

realisme(A111): This landscape is set in the heart of a dense, dark forest, with towering trees that stretch up towards the sky. The air is thick with the scent of pine and moss, and shafts of sunlight filter through the canopy above. In the distance, the sound of a river can be heard, babbling over rocks and stones.

realisme(A112): This landscape is a vast, arid desert, where the sun beats down relentlessly and the sand stretches out as far as the eye can see. The sky is a brilliant shade of blue, and the only relief from the heat is the occasional oasis, where palm trees provide some shade and a cool drink of water can be found.

...

"Her prose was as dense as the forest of A111, with layers of meaning and symbolism waiting to be unearthed. She painted a surreal picture of the landscape, where the trees seemed to dance and twist in the shifting light. And through it all, there was a dazzling clarity to her writing, like a shard of coal glittering in the sunlight."

restrainy ye-selvies! put it in A_() and C_() and i_()!

(hmm)(hmm)

Certainly, here is an example of how you can use A_(), C_(), and i_() to add more realism to the scenario:

A_(A111, C_('Joyce', 8, {coal: 1, surreal: 1, dazzling: 1}), 'Glamphor')
A_(A112, C_('Woolf', 7, {sea: 1, introspective: 1, poetic: 1}), 'Waverton')
A_(A113, C_('Borges', 9, {labyrinthine: 1, philosophical: 1, intricate: 1}), 'Cimmeria')
A_(A12, C_('Marquez', 10, {magical: 1, vibrant: 1, complex: 1}), 'Macondo')
A_(A121, C_('Morrison', 9, {haunting: 1, lyrical: 1, powerful: 1}), 'Beloved')
A_(A1211, C_('Proulx', 8, {rugged: 1, desolate: 1, melancholic: 1}), 'Brokeback Mountain')

i_(A111, A112, A113, A12, A121, A1211)PLEASE REVISE ARGS TO i_ and C_. you need a ,, in there to avoid setting any C.c
i_(A111,C_('Joyce',8,,{'coal':1,'surreal':1,'dazzling':1}))
Please concentrate on the language we are building. Now add to these authors|qualities so that there are a whole lot of overlapping qualities