-- The Synapsis: As synopsis of the game Part IIIb

[dolf]

-- The Synapsis: As synopsis of the game Part III

When it comes to implementing rules, this is how I'm proposing to define
them using the memeBrain function.

Here the notion of an “Undefined Virtual Idea” is computed as follows:

@memeBrain [Telos: #1482, Super: #70 - Difficulty in Knowing How,
Obtuse; I-Ching: H53 - Gradual Progress; Tetra: 14 - Penetration, Ego:
#24 - Important Distinctions, Trouble from Indulgence; I-Ching: H5 -
Delay; Tetra: 18 - Waiting]

And this can be defined simply as an array object:
70: {
24: {
1482: {"Undefined Virtual Idea": {}}
}
}
Whereas the text value: "Undefined Id" is computed as follows:

@memeBrain [Telos: #446, Super: #5 - Natural Guidance, Function of
Emptiness; I-Ching: H63 - Completion & After; Tetra: 73 - Completion,
Ego: #41 - Playing with Reversal, Sameness in Difference; I-Ching: H26 -
Restraining Force; Tetra: 60 - Accumulation]

And this can also be defined as an array object:
5: {
41: {
446: {"Undefined Id": {}}
}
}
So this statement “When it comes to implementing rules, this is how I'm
proposing to define them using the memeBrain function."

Would appear on face value to be only two rules:

Rule #1: “When it comes to implementing rules,"

@memeBrain [Telos: #2280, Super: #50 - Fantasies of Avoiding Death,
Value of Life; I-Ching: H2 - Passive Principle/Earth; Tetra: 77 -
Compliance, Ego: #12 - Numbing Effect of the Conventional, Abstaining
from Desire; I-Ching: H6 - Conflict; Tetra: 25 - Contention]
50: {
12 : {
2280: {"When it comes to implementing rules": {}}
}
}
Rule #2: “this is how I'm proposing to define them using the memeBrain
function."

@memeBrain [Telos: #3750, Super: #50 - Fantasies of Avoiding Death,
Value of Life; I-Ching: H2 - Passive Principle/Earth; Tetra: 77 -
Compliance, Ego: #24 - Important Distinctions, Trouble from Indulgence;
I-Ching: H5 - Delay; Tetra: 18 - Waiting]
50: {
24 : {
3750: {"this is how I'm proposing to define them using the
memeBrain function": {}}
}
}
Which then equals:
100: {
36 : {
12: {2280: {}},
24: {3750: {}},
36: {2280: {}, 3750: {}},
50: {2280: {}, 3750: {}},
100: {2280: {}, 3750: {}},
2280: {"When it comes to implementing rules": {12: {}, 36: {},
50: {}, 100: {}}},
3750: {"this is how I'm proposing to define them using the
memeBrain function": {24: {}, 36: {}, 50: {}, 100: {}}}
}
}
We may have to look further at a #81 reduction on the #100 value which
then becomes #19.

@memeBrain [Telos: #19, Super: #19 - Argument for Ethical Anarchism,
Returning to Simplicity; I-Ching: H57 - Gentle Penetration; Tetra: 58 -
Gathering In, Ego: #19 - Argument for Ethical Anarchism, Returning to
Simplicity; I-Ching: H57 - Gentle Penetration; Tetra: 58 - Gathering In]:
19: {
36 : {
12: {2280: {}},
19: {2280: {}, 3750: {}},
24: {3750: {}},
36: {2280: {}, 3750: {}},
50: {2280: {}, 3750: {}},
100: {2280: {}, 3750: {}},
2280: {"When it comes to implementing rules": {12: {}, 36: {},
50: {}, 100: {}}},
3750: {"this is how I'm proposing to define them using the
memeBrain function": {19: {}, 24: {}, 36: {}, 50: {}, 100: {}}}
}
}

Or as the synapse #81 reducted form:

19: {
36 : {
12: {12: {}},
19: {12: {}, 24: {}},
24: {24: {}},
36: {12: {}, 24: {}},
50: {12: {}, 24: {}},
100: {12: {}, 24: {}},
2280: {"When it comes to implementing rules": {12: {}, 36: {},
50: {}, 100: {}}},
3750: {"this is how I'm proposing to define them using the
memeBrain function": {19: {}, 24: {}, 36: {}, 50: {}, 100: {}}}
}
}
As I said, “Get Cozy lads!” I think I've had fuck all to do with them
and I know of no "kind and sympathetic act" ever from any of them or
their crowds--Mine is an everlasting hatred for you the Forgotten.

We want our human rights. Now and not just tomorrow! Start showing respect.

#26 / .jackNote@zen: 7, row: 2, col: 2, nous: 14 [Super: #305 / #33 -
Achievable Goals, Virtue of Discrimination; I-Ching: H9 - Minor
Restraint; Tetra: 35 - Gathering, Ego: #352 / #14 - Praising the
Mysterious (Metaphysics); I-Ching: H19 - Approaching; Tetra: 9 -
Branching Out]

But we are just prototyping at the present time...

function createDaemonRules(ruleSet) {

// Dummy constructor

var createDaemonRules = function() {};

// Enumerated values inherit from this object

var proto = createDaemonRules.prototype = {
constructor: createDaemonRules,
toString: function() { return this.id; },
valueOf: function() { return this.item; },
toJSON: function() { return this.item; },
hasFired: function() { return this.fired; },
toFire: function() { return this.fire; },

};

// Set the enumerated value data objects

createDaemonRules.$names = [];
createDaemonRules.$error = [];

// Now create the instances of this new type

for (var supernal in ruleSet) {

for (var ego in ruleSet[supernal]) {

for (var telos in ruleSet[supernal][ego]) {

for (var rule in ruleSet[supernal][ego][telos]) {

var e = inherit(proto);

switch (true) {
case (typeof(createDaemonRules[supernal]) == "undefined"):
createDaemonRules[supernal] = {};

case (typeof(createDaemonRules[supernal][ego]) == "undefined"):
createDaemonRules[supernal][ego] = {};

case (typeof(createDaemonRules[supernal][ego][telos]) == "undefined"):
createDaemonRules[supernal][ego][telos] = {}

case (typeof(createDaemonRules[supernal][ego][telos][rule]) ==
"undefined"):
createDaemonRules[supernal][ego][telos][rule] = {}

default:
e.id = {supernal: supernal, ego: ego, telos: telos};
e.item = rule;
e.fired = false;
e.fire = true;
createDaemonRules[supernal][ego][telos][rule] = e;
createDaemonRules.$names[createDaemonRules.$names.length] = e.id;
}
}
}
}
}

return createDaemonRules;
}

function inherit(p) {

try {

switch (true) {

case (p == null):
throw {
71: {
14: {
1310: {"Type Error": {}}
}
}
};

case (typeof(p) == "object" && typeof(p.length) != "undefined"): // array
return (new Object(p));

case (typeof(p) == "object" && typeof(p.length) == "undefined"): // date

case (typeof(p) == "function"):
function f() {};
f.prototype = p;
return (new f());

case (typeof(p) == "string"):
return (new String(p));

case (typeof(p) == "number"):
return (new Number(p));

default:
throw {
71: {
14: {
1310: {"Type Error": {}}
}
}
}

}

} catch (err) {

switch(true) {
case (err[71][14][1310]["Type Error"]):
return {
71: {
14: {
1310: {"Type Error": {"Unknown inherited object type": typeof(p)}}
}
}
}

default:
return {
15: {
69: {
1365: {"Unknown Error": {}}
}
}
}
}
}
}