479 lines
17 KiB
JavaScript
479 lines
17 KiB
JavaScript
// The strains (EVOLUTION.md M2.7) — the song decides how many kinds of minds
|
|
// its world needs, then writes them.
|
|
//
|
|
// There are no castes and no tribes. The population is ONE species whose
|
|
// density is partitioned by *strain* — a personality, a LittleVM program the
|
|
// song compiled for it. A biofilm, not three societies: specialists working
|
|
// the same ground, and the mix itself evolves (the world runs local selection
|
|
// on the strain proportions).
|
|
//
|
|
// The VM is small and total: senses → registers → branches → actions, run
|
|
// per coarse decision block, every substep. Senses now include the body the
|
|
// local organisms belong to (KIN: same body, other strains; FOE: other
|
|
// bodies), the living wells (proximity + recharge), and the section's PEACE —
|
|
// so a program can literally branch on "war or truce".
|
|
//
|
|
// Everything compiles deterministically from (analysis summary, genome, seed
|
|
// stream): same song, same seed → same programs, bit for bit.
|
|
|
|
export const S_FOOD = 0;
|
|
export const S_SELF = 1; // own strain, this block
|
|
export const S_KIN = 2; // same body, other strains
|
|
export const S_FOE = 3; // other bodies' presence
|
|
export const S_TRAIL = 4; // own body's trail here
|
|
export const S_LAW = 5; // section's spawn operator
|
|
export const S_HUNGER = 6;
|
|
export const S_EDGE = 7;
|
|
export const S_TIME = 8;
|
|
export const S_TOTAL = 9;
|
|
export const S_WELL = 10; // nearest living well's pull
|
|
export const S_PEACE = 11; // section's peace operator (war ↔ truce)
|
|
export const S_ROCK = 12; // rock under this block: the quarriable ground
|
|
export const S_GARDEN = 13; // cultivated ground here: is this stone worked yet?
|
|
export const SENSE_COUNT = 14;
|
|
|
|
// Gradient fields, two slots each (x, y): food, own strain, kin, foe, well.
|
|
export const G_FOOD = 0;
|
|
export const G_SELF = 1;
|
|
export const G_KIN = 2;
|
|
export const G_FOE = 3;
|
|
export const G_WELL = 4;
|
|
export const G_ROCK = 5;
|
|
export const G_GARDEN = 6;
|
|
export const G_FIELDS = 7;
|
|
export const GRAD_COUNT = G_FIELDS * 2;
|
|
|
|
export const A_MOVE_X = 0;
|
|
export const A_MOVE_Y = 1;
|
|
export const A_EXCRETE = 2;
|
|
export const A_EAT = 3;
|
|
export const A_HIT = 4;
|
|
export const A_SPAWN = 5;
|
|
export const A_DRIFT = 6; // gradual direction change following a gradient
|
|
export const A_ACCELERATE = 7; // speed up / slow down
|
|
export const A_DIG = 8; // quarry rock here (rock → carried → soil)
|
|
export const A_BUILD = 9; // deposit carried rock as a wall
|
|
export const A_TILL = 10; // work stone into a garden (a food generator)
|
|
export const A_TEND = 11; // tend a garden: it yields far more while tended
|
|
export const A_AIM_X = 12; // aim the work: act ahead along x (set, not add)
|
|
export const A_AIM_Y = 13; // aim the work: act ahead along y
|
|
export const ACTION_COUNT = 14;
|
|
export const REGS = 6;
|
|
|
|
export const MAX_INSTR = 56;
|
|
export const MAX_STEPS = 64;
|
|
|
|
export const OP = {
|
|
SET: 0, ADD: 1, MUL: 2, SUB: 3, CLAMP: 4, LERP: 5,
|
|
SENSE: 6, GRAD: 7, IFGT: 8, IFLT: 9, IFEQ: 10, IFNEQ: 11, ACT: 12, HALT: 13,
|
|
};
|
|
|
|
const clamp01 = (v) => (v < 0 ? 0 : v > 1 ? 1 : v);
|
|
const clamp = (v, a, b) => (v < a ? a : v > b ? b : v);
|
|
|
|
// ---- a tiny assembler -------------------------------------------------------
|
|
//
|
|
// Programs are built from motifs; jumps need patching, so the assembler hands
|
|
// out patch slots and labels. No control flow beyond the VM's own.
|
|
|
|
class Asm {
|
|
constructor() { this.code = []; }
|
|
label() { return this.code.length; }
|
|
emit(...ins) { this.code.push(ins); return this.code.length - 1; }
|
|
// Conditional jumps return a patch slot; call .jump(patch, target) later.
|
|
ifgt(reg, thr) { return this.emit(OP.IFGT, reg, thr, 0); }
|
|
iflt(reg, thr) { return this.emit(OP.IFLT, reg, thr, 0); }
|
|
jump(patch, target) { this.code[patch][3] = target; return this; }
|
|
sense(reg, s, w = 1) { return this.emit(OP.SENSE, reg, s, w); }
|
|
grad(reg, field, axis, w = 1) { return this.emit(OP.GRAD, reg, field, axis, w); }
|
|
act(a, reg, w = 1) { return this.emit(OP.ACT, a, reg, w); }
|
|
mul(reg, k) { return this.emit(OP.MUL, reg, k); }
|
|
halt() { return this.emit(OP.HALT); }
|
|
}
|
|
|
|
// ---- roles ------------------------------------------------------------------
|
|
//
|
|
// Each role is a motif family plus the economy the world needs to run it.
|
|
// The song picks which roles exist (m of them) and tunes every threshold;
|
|
// the numbers below are bases, not destiny.
|
|
|
|
const ROLES = {
|
|
builder: {
|
|
base: { speed: 0.038, deposit: 1.50, cap: 1.25, growth: 0.90, eat: 0.032 },
|
|
hungryAt: 0.70, spawnW: 0.30,
|
|
},
|
|
grazer: {
|
|
base: { speed: 0.095, deposit: 0.75, cap: 1.00, growth: 1.00, eat: 0.042 },
|
|
hungryAt: 0.60, spawnW: 0.45,
|
|
},
|
|
scout: {
|
|
base: { speed: 0.155, deposit: 0.18, cap: 0.80, growth: 1.05, eat: 0.046 },
|
|
hungryAt: 0.75, spawnW: 0.60,
|
|
},
|
|
sentinel: {
|
|
base: { speed: 0.070, deposit: 0.55, cap: 1.00, growth: 0.85, eat: 0.040 },
|
|
hungryAt: 0.70, spawnW: 0.25, foeAt: 0.10,
|
|
},
|
|
breeder: {
|
|
base: { speed: 0.062, deposit: 0.50, cap: 0.90, growth: 1.25, eat: 0.036 },
|
|
hungryAt: 0.70, spawnW: 0.85, kinAt: 0.12,
|
|
},
|
|
farmer: {
|
|
base: { speed: 0.055, deposit: 0.40, cap: 0.95, growth: 1.05, eat: 0.038 },
|
|
hungryAt: 0.65, spawnW: 0.45, gardenAt: 0.15,
|
|
},
|
|
};
|
|
|
|
/** How many minds the song needs: independent voices, texture, seed. */
|
|
function strainCount(summary, genome, rng) {
|
|
const density = clamp01(summary.onsetDensity / 6);
|
|
const noise = clamp01(summary.flatness);
|
|
// A band that lives its own life (weak correlation to the others) is an
|
|
// independent voice — it earns its own specialist.
|
|
let independent = 0;
|
|
const corr = summary.bandCorrelation || [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
|
|
for (let i = 0; i < corr.length; i++) {
|
|
let maxOff = -2;
|
|
for (let j = 0; j < corr.length; j++) if (j !== i) maxOff = Math.max(maxOff, corr[i][j] ?? 0);
|
|
if (maxOff < 0.6) independent++;
|
|
}
|
|
let m = 2
|
|
+ (density > 0.35 ? 1 : 0) // a busy arrangement needs hands
|
|
+ (independent >= 1 ? 1 : 0) // a self-willed voice needs a mind
|
|
+ (noise > 0.5 ? 1 : 0); // dense texture: more specialists
|
|
if (rng.next() < 0.35) m += 1; // the seed may add one more voice
|
|
return clamp(m, 2, 5);
|
|
}
|
|
|
|
/**
|
|
* Compile the population's strains for a song.
|
|
* @returns {Array<{name, role, code, init, speed, deposit, cap, growth, eat}>}
|
|
*/
|
|
export function compileStrains(summary, genome, rng) {
|
|
const m = strainCount(summary, genome, rng);
|
|
const density = clamp01(summary.onsetDensity / 6);
|
|
const pace = genome.pace;
|
|
const cohesion = genome.cohesion;
|
|
const balance = summary.bandBalance || [0.33, 0.33, 0.33];
|
|
const noise = clamp01(summary.flatness);
|
|
|
|
// The role order is the song's; the seed rotates the casting so two
|
|
// similar songs still differ in who they specialised.
|
|
const order = Object.keys(ROLES);
|
|
const rot = rng.int(0, order.length - 1);
|
|
const roles = order.slice(rot).concat(order.slice(0, rot)).slice(0, m);
|
|
|
|
return roles.map((role, i) => {
|
|
const spec = ROLES[role];
|
|
const band = balance[i % 3];
|
|
const asm = new Asm();
|
|
// R0 hunger, R1 law(spawn), R2 well pull, R3 peace, R4 kin, R5 foe.
|
|
asm.sense(0, S_HUNGER, 1);
|
|
asm.sense(1, S_LAW, 1);
|
|
asm.sense(2, S_WELL, 1);
|
|
asm.sense(3, S_PEACE, 1);
|
|
|
|
// ---- the sentinel's war branch: a body at war fights before it
|
|
// eats. PEACE decides strike vs shadow; the branch sits at the end,
|
|
// so the fall-through below is the ordinary life.
|
|
let foePatch = -1;
|
|
if (spec.foeAt !== undefined) {
|
|
asm.sense(5, S_FOE, 1);
|
|
foePatch = asm.ifgt(5, spec.foeAt * (0.8 + 0.4 * rng.next()));
|
|
}
|
|
|
|
// ---- the breeder's bloom branch: breed only in a fed crowd.
|
|
let kinPatch = -1;
|
|
if (spec.kinAt !== undefined) {
|
|
asm.sense(4, S_KIN, 1);
|
|
kinPatch = asm.ifgt(4, spec.kinAt * (0.8 + 0.4 * rng.next()));
|
|
}
|
|
|
|
// ---- hungry: follow the smell of food — and WORK on the way,
|
|
// because for a mason or a husbandman work IS foraging: the aimed
|
|
// ground pays wages in food.
|
|
const hungryPatch = asm.iflt(0, spec.hungryAt);
|
|
asm.grad(4, G_FOOD, 0, 1);
|
|
asm.grad(5, G_FOOD, 1, 1);
|
|
asm.act(A_MOVE_X, 4, 1);
|
|
asm.act(A_MOVE_Y, 5, 1);
|
|
asm.act(A_AIM_X, 4, 1);
|
|
asm.act(A_AIM_Y, 5, 1);
|
|
asm.act(A_EAT, 0, 1);
|
|
if (role === 'builder' || role === 'farmer') {
|
|
// The husbandman tends first (a tended bed pays best), the
|
|
// mason breaks stone first; both eat their wages.
|
|
if (role === 'farmer') {
|
|
asm.sense(5, S_GARDEN, 1);
|
|
const bedH = asm.ifgt(5, 0.05);
|
|
asm.sense(5, S_ROCK, 1);
|
|
const seamH = asm.ifgt(5, 0.06);
|
|
asm.halt();
|
|
const tendH = asm.label();
|
|
asm.jump(bedH, tendH);
|
|
asm.act(A_TEND, 5, 1);
|
|
asm.act(A_EAT, 0, 1);
|
|
asm.halt();
|
|
const tillH = asm.label();
|
|
asm.jump(seamH, tillH);
|
|
asm.act(A_TILL, 5, 1.2);
|
|
asm.act(A_EAT, 0, 1);
|
|
asm.halt();
|
|
} else {
|
|
asm.sense(5, S_ROCK, 1);
|
|
const seamH = asm.ifgt(5, 0.06);
|
|
asm.sense(5, S_GARDEN, 1);
|
|
const spentH = asm.ifgt(5, 0.15);
|
|
asm.halt();
|
|
const tillH = asm.label();
|
|
asm.jump(seamH, tillH);
|
|
asm.act(A_TILL, 5, 1.2);
|
|
asm.act(A_EAT, 0, 1);
|
|
asm.halt();
|
|
const digH = asm.label();
|
|
asm.jump(spentH, digH);
|
|
asm.act(A_DIG, 5, 1.2);
|
|
asm.act(A_EAT, 0, 1);
|
|
asm.halt();
|
|
}
|
|
} else {
|
|
asm.halt();
|
|
}
|
|
|
|
// ---- fed: the role's own work.
|
|
const fed = asm.label();
|
|
asm.jump(hungryPatch, fed);
|
|
if (role === 'builder') {
|
|
// The mason: it smells stone and walks to it; its WORK lands
|
|
// AHEAD of it, along its aim — it carves the face of the wall,
|
|
// not the ground beneath its feet. On fresh stone ahead it
|
|
// tills (a garden: food for a while, then stone again); on
|
|
// spent ground it quarries (burden for the walls); on clear
|
|
// ground it builds what the burden brought.
|
|
asm.sense(4, S_ROCK, 1);
|
|
const quarry = asm.ifgt(4, 0.06);
|
|
// Clear ground: toward the stone.
|
|
asm.grad(4, G_ROCK, 0, 1);
|
|
asm.grad(5, G_ROCK, 1, 1);
|
|
asm.act(A_MOVE_X, 4, 0.6);
|
|
asm.act(A_MOVE_Y, 5, 0.6);
|
|
asm.act(A_AIM_X, 4, 1);
|
|
asm.act(A_AIM_Y, 5, 1);
|
|
asm.sense(5, S_FOOD, 1);
|
|
asm.act(A_BUILD, 5, 1.5);
|
|
asm.act(A_EXCRETE, 3, 1.0);
|
|
asm.act(A_SPAWN, 1, spec.spawnW);
|
|
asm.halt();
|
|
const onRock = asm.label();
|
|
asm.jump(quarry, onRock);
|
|
// Aim INTO the stone face ahead.
|
|
asm.grad(4, G_ROCK, 0, 1);
|
|
asm.grad(5, G_ROCK, 1, 1);
|
|
asm.act(A_AIM_X, 4, 1);
|
|
asm.act(A_AIM_Y, 5, 1);
|
|
// Fresh stone becomes a garden: worked, it will feed the body
|
|
// for a while — and then petrify back to rock.
|
|
asm.sense(5, S_GARDEN, 1);
|
|
const spent = asm.ifgt(5, 0.15);
|
|
asm.act(A_TILL, 4, 1.6);
|
|
asm.halt();
|
|
const dig = asm.label();
|
|
asm.jump(spent, dig);
|
|
// Worked-out ground: quarry what is left for the walls.
|
|
asm.act(A_DIG, 4, 1.6);
|
|
asm.act(A_EXCRETE, 3, 0.3);
|
|
asm.halt();
|
|
} else if (role === 'grazer') {
|
|
// Commutes: follows the food edge, leaves a road behind.
|
|
asm.grad(4, G_FOOD, 0, 0.7);
|
|
asm.grad(5, G_FOOD, 1, 0.7);
|
|
asm.act(A_MOVE_X, 4, 0.9);
|
|
asm.act(A_MOVE_Y, 5, 0.9);
|
|
asm.act(A_EXCRETE, 3, 0.6);
|
|
asm.act(A_SPAWN, 1, spec.spawnW);
|
|
asm.halt();
|
|
} else if (role === 'scout') {
|
|
// Restless: re-aims every step, speeds up, writes almost nothing.
|
|
asm.grad(4, G_FOOD, 0, 0.5);
|
|
asm.act(A_DRIFT, 4, 1.4);
|
|
asm.act(A_ACCELERATE, 3, 1);
|
|
asm.act(A_SPAWN, 1, spec.spawnW * (0.6 + 0.8 * noise));
|
|
asm.halt();
|
|
} else if (role === 'sentinel') {
|
|
// Patrol: sweeps along the body's frontier, never parked.
|
|
asm.grad(4, G_KIN, 0, 0.8);
|
|
asm.grad(5, G_KIN, 1, 0.8);
|
|
asm.act(A_MOVE_X, 4, 0.6);
|
|
asm.act(A_MOVE_Y, 5, 0.6);
|
|
asm.grad(4, G_SELF, 0, 0.5);
|
|
asm.act(A_DRIFT, 4, 1);
|
|
asm.act(A_EXCRETE, 3, 0.5);
|
|
asm.act(A_SPAWN, 1, spec.spawnW);
|
|
asm.halt();
|
|
} else if (role === 'farmer') {
|
|
// The husbandman: walks the field row, its work ahead of it —
|
|
// tending the bed it is walking toward (a tended bed yields
|
|
// far more), opening new beds into fresh stone.
|
|
asm.sense(4, S_GARDEN, 1);
|
|
const field = asm.ifgt(4, spec.gardenAt * (0.8 + 0.4 * rng.next()));
|
|
asm.sense(5, S_ROCK, 1);
|
|
const seam = asm.ifgt(5, 0.06);
|
|
// roam toward the fields, aiming where we walk
|
|
asm.grad(4, G_GARDEN, 0, 1);
|
|
asm.grad(5, G_GARDEN, 1, 1);
|
|
asm.act(A_MOVE_X, 4, 0.8);
|
|
asm.act(A_MOVE_Y, 5, 0.8);
|
|
asm.act(A_AIM_X, 4, 1);
|
|
asm.act(A_AIM_Y, 5, 1);
|
|
asm.act(A_TEND, 4, 1);
|
|
asm.act(A_SPAWN, 1, spec.spawnW * 0.5);
|
|
asm.halt();
|
|
const tillNew = asm.label();
|
|
asm.jump(seam, tillNew);
|
|
asm.grad(4, G_ROCK, 0, 1);
|
|
asm.grad(5, G_ROCK, 1, 1);
|
|
asm.act(A_AIM_X, 4, 1);
|
|
asm.act(A_AIM_Y, 5, 1);
|
|
asm.act(A_TILL, 5, 1);
|
|
asm.halt();
|
|
const tend = asm.label();
|
|
asm.jump(field, tend);
|
|
asm.grad(4, G_GARDEN, 0, 1);
|
|
asm.grad(5, G_GARDEN, 1, 1);
|
|
asm.act(A_AIM_X, 4, 1);
|
|
asm.act(A_AIM_Y, 5, 1);
|
|
asm.act(A_TEND, 4, 1);
|
|
asm.act(A_EXCRETE, 3, 0.4);
|
|
asm.act(A_SPAWN, 1, spec.spawnW);
|
|
asm.halt();
|
|
} else { // breeder
|
|
// Follows the crowd it feeds on; spawns when the law allows.
|
|
asm.grad(4, G_KIN, 0, 1);
|
|
asm.grad(5, G_KIN, 1, 1);
|
|
asm.act(A_MOVE_X, 4, 0.7);
|
|
asm.act(A_MOVE_Y, 5, 0.7);
|
|
asm.act(A_SPAWN, 1, spec.spawnW * (0.8 + 0.6 * density));
|
|
asm.act(A_EXCRETE, 3, 0.4);
|
|
asm.halt();
|
|
}
|
|
|
|
// ---- the breeder's bloom tail (reached only from the kin branch).
|
|
if (kinPatch >= 0) {
|
|
const bloom = asm.label();
|
|
asm.jump(kinPatch, bloom);
|
|
asm.act(A_SPAWN, 1, spec.spawnW * (0.7 + 0.9 * density));
|
|
asm.act(A_EXCRETE, 3, 0.4);
|
|
asm.halt();
|
|
}
|
|
|
|
// ---- the sentinel's war tail (reached only from the foe branch):
|
|
// peace low → close and strike; peace high → shadow the border.
|
|
if (foePatch >= 0) {
|
|
const war = asm.label();
|
|
asm.jump(foePatch, war);
|
|
const strike = asm.iflt(3, 0.45);
|
|
// truce: fall back from the border, keep writing.
|
|
asm.grad(4, G_FOE, 0, -0.8);
|
|
asm.grad(5, G_FOE, 1, -0.8);
|
|
asm.act(A_MOVE_X, 4, 0.5);
|
|
asm.act(A_MOVE_Y, 5, 0.5);
|
|
asm.act(A_EXCRETE, 3, 0.5);
|
|
asm.halt();
|
|
const strikeLabel = asm.label();
|
|
asm.jump(strike, strikeLabel);
|
|
asm.grad(4, G_FOE, 0, 1);
|
|
asm.grad(5, G_FOE, 1, 1);
|
|
asm.act(A_MOVE_X, 4, 1);
|
|
asm.act(A_MOVE_Y, 5, 1);
|
|
asm.act(A_HIT, 5, 1.2);
|
|
asm.halt();
|
|
}
|
|
|
|
// Economy: the track tunes the role's body.
|
|
const bandBoost = 0.7 + 0.6 * band;
|
|
return {
|
|
name: role,
|
|
role,
|
|
code: asm.code.slice(0, MAX_INSTR),
|
|
init: [0, 0, 0, 0, 0, 0],
|
|
speed: spec.base.speed * (0.35 + 1.10 * pace) * (role === 'scout' ? 1 : bandBoost),
|
|
deposit: spec.base.deposit * (0.35 + 1.25 * cohesion),
|
|
cap: 10 * spec.base.cap * (1.20 - 0.30 * density),
|
|
growth: ((0.92 / (1 + 0.10 * density)) + 0.24) * spec.base.growth,
|
|
eat: spec.base.eat * (0.85 + 0.4 * genome.aggression),
|
|
};
|
|
});
|
|
}
|
|
|
|
// ---- the VM -----------------------------------------------------------------
|
|
|
|
function clampVM(v) { return v < 0 ? 0 : v > 1 ? 1 : v; }
|
|
|
|
/**
|
|
* Run one strain program for one block. Registers live in `memBuf` at `off`
|
|
* (persistent across substeps — that is the strain's memory); `senses` and
|
|
* `grads` are this block's read of the world; `act` accumulates the decision.
|
|
*/
|
|
export function runProgram(memBuf, off, senses, grads, act, code) {
|
|
let pc = 0;
|
|
let steps = 0;
|
|
const n = code.length;
|
|
act[0] = 0; act[1] = 0; act[2] = 0; act[3] = 1; act[4] = 0; act[5] = 0;
|
|
act[6] = 0; act[7] = 0; act[8] = 0; act[9] = 0;
|
|
act[12] = 0; act[13] = 0;
|
|
const mem = memBuf;
|
|
while (steps++ < MAX_STEPS && pc < n) {
|
|
const ins = code[pc];
|
|
const op = ins[0];
|
|
switch (op) {
|
|
case OP.SET: mem[off + ins[1]] = ins[2]; break;
|
|
case OP.ADD: mem[off + ins[1]] += mem[off + ins[2]]; break;
|
|
case OP.MUL: mem[off + ins[1]] *= ins[2]; break;
|
|
case OP.SUB: mem[off + ins[1]] -= mem[off + ins[2]]; break;
|
|
case OP.CLAMP: mem[off + ins[1]] = clampVM(mem[off + ins[1]]); break;
|
|
case OP.LERP: mem[off + ins[1]] += (mem[off + ins[2]] - mem[off + ins[1]]) * ins[3]; break;
|
|
case OP.SENSE: mem[off + ins[1]] = senses[ins[2]] * ins[3]; break;
|
|
case OP.GRAD: mem[off + ins[1]] = grads[ins[2] * 2 + ins[3]] * (ins[4] ?? 1); break;
|
|
case OP.IFGT:
|
|
if (mem[off + ins[1]] > ins[2]) { pc = ins[3]; continue; }
|
|
break;
|
|
case OP.IFLT:
|
|
if (mem[off + ins[1]] < ins[2]) { pc = ins[3]; continue; }
|
|
break;
|
|
case OP.IFEQ:
|
|
if (mem[off + ins[1]] == ins[2]) { pc = ins[3]; continue; }
|
|
break;
|
|
case OP.IFNEQ:
|
|
if (mem[off + ins[1]] != ins[2]) { pc = ins[3]; continue; }
|
|
break;
|
|
case OP.ACT: {
|
|
const drive = mem[off + ins[2]];
|
|
const w = ins[3] ?? 1;
|
|
switch (ins[1]) {
|
|
case A_MOVE_X: act[0] += drive * w; break;
|
|
case A_MOVE_Y: act[1] += drive * w; break;
|
|
case A_EXCRETE: act[2] += Math.max(0, drive) * w * 1.5; break;
|
|
case A_EAT: act[3] *= drive * w + 1; break;
|
|
case A_HIT: act[4] += Math.max(0, drive) * w * 0.02; break;
|
|
case A_SPAWN: act[5] += Math.max(0, drive) * w * 0.012; break;
|
|
case A_DRIFT: act[0] += drive * w * 0.1; act[1] += drive * w * 0.1; break;
|
|
case A_ACCELERATE: act[3] *= drive * w + 1; break;
|
|
case A_DIG: act[6] += Math.max(0, drive) * w; break;
|
|
case A_BUILD: act[7] += Math.max(0, drive) * w; break;
|
|
case A_TILL: act[8] += Math.max(0, drive) * w; break;
|
|
case A_TEND: act[9] += Math.max(0, drive) * w; break;
|
|
case A_AIM_X: act[12] = drive; break; // aim is SET, not summed
|
|
case A_AIM_Y: act[13] = drive; break;
|
|
default: break;
|
|
}
|
|
break;
|
|
}
|
|
case OP.HALT:
|
|
default:
|
|
return act;
|
|
}
|
|
pc++;
|
|
}
|
|
return act;
|
|
}
|