X-Git-Url: https://git.piment-noir.org/?p=SugarCubes.git;a=blobdiff_plain;f=L8onWallace.pde;h=a81901617938ddd9c8ff0e16736f5d2b65333586;hp=d3c083f95eb9dc9c0daad60b0325315e99dd74bd;hb=e0b9d8726c661f54f47340449037ac7f6b410de6;hpb=61f677b8fb206d040cd834fb0d8795d1eda14c9b diff --git a/L8onWallace.pde b/L8onWallace.pde index d3c083f..a819016 100644 --- a/L8onWallace.pde +++ b/L8onWallace.pde @@ -1,36 +1,38 @@ -class CubeState { - // Index of cube in glucose.model.cubes - public Integer index; - // Boolean which describes if cube is alive. - public boolean alive; - // List of this cubes neighbors - public List neighbors; - - public CubeState(Integer index, boolean alive, List neighbors) { - this.index = index; - this.alive = alive; - this.neighbors = neighbors; - } -} - class L8onLife extends SCPattern { // Controls the rate of life algorithm ticks, in milliseconds - private BasicParameter rateParameter = new BasicParameter("RATE", 122.5, 0.0, 2000.0); - // Controls if the cubes should be randomized even if something changes. Set above 0.5 to randomize cube aliveness. - private BasicParameter randomParameter = new BasicParameter("RAND", 0.0); - // Controls the brightness of dead cubes. - private BasicParameter deadParameter = new BasicParameter("DEAD", 25.0, 0.0, 100.0); + private BasicParameter rateParameter = new BasicParameter("DELAY", 112.5, 0.0, 1000.0); + // Controls the probability of a mutation in the cycleOfLife + private BasicParameter mutationParameter = new BasicParameter("MUT", 0.000000011, 0.0, 0.1); // Controls the saturation. private BasicParameter saturationParameter = new BasicParameter("SAT", 90.0, 0.0, 100.0); - // Controls the number of neighbors needed to birth a new life. - private BasicParameter fertilityParameter = new BasicParameter("FERT", 2.0, 1.0, 5.0); - public final double MIN_ALIVE_PROBABILITY = 0.2; public final double MAX_ALIVE_PROBABILITY = 0.9; - private final SinLFO xPos = new SinLFO(0, model.xMax, 4500); - + public final float MAX_ALIVE_BRIGHTNESS = 90.0; + + private final SawLFO cubePos = new SawLFO(0, model.cubes.size(), 4000); + + class CubeState { + // Index of cube in glucose.model.cubes + public Integer index; + // Boolean which describes if cube is alive. + public boolean alive; + // Boolean which describes if strip was just changed; + public boolean just_changed; + // Current brightness + public float current_brightness; + // List of this cubes neighbors + public List neighbors; + + public CubeState(Integer index, boolean alive, float current_brightness, List neighbors) { + this.index = index; + this.alive = alive; + this.current_brightness = current_brightness; + this.neighbors = neighbors; + } + } + // Contains the state of all cubes by index. private List cube_states; // Contains the amount of time since the last cycle of life. @@ -40,8 +42,8 @@ class L8onLife extends SCPattern { // Hold the new lives private List new_lives; - public L8onLife(GLucose glucose) { - super(glucose); + public L8onLife(LX lx) { + super(lx); //Print debug info about the cubes. //outputCubeInfo(); @@ -52,11 +54,9 @@ class L8onLife extends SCPattern { new_lives = new ArrayList(); addParameter(rateParameter); - addParameter(randomParameter); - addParameter(deadParameter); + addParameter(mutationParameter); addParameter(saturationParameter); - addParameter(fertilityParameter); - addModulator(xPos).trigger(); + addModulator(cubePos).trigger(); } public void run(double deltaMs) { @@ -68,19 +68,18 @@ class L8onLife extends SCPattern { time_since_last_run += deltaMs; for (Cube cube : model.cubes) { - cube_state = this.cube_states.get(i); + cube_state = this.cube_states.get(i); if(shouldLightCube(cube_state)) { - lightLiveCube(cube); + lightLiveCube(cube, cube_state, deltaMs); } else { - lightDeadCube(cube); + lightDeadCube(cube, cube_state, deltaMs); } i++; } - boolean should_randomize_anyway = (randomParameter.getValuef() > 0.5); - if(should_randomize_anyway || !any_changes_this_run) { + if(!any_changes_this_run) { randomizeCubeStates(); } else { applyNewLives(); @@ -91,26 +90,52 @@ class L8onLife extends SCPattern { } } - public void lightLiveCube(Cube cube) { + public void lightLiveCube(Cube cube, CubeState cube_state, double deltaMs) { + float cube_dist = LXUtils.wrapdistf((float) cube_state.index, cubePos.getValuef(), model.cubes.size()); + float hv = (cube_dist / model.cubes.size()) * 360; + float bv = cube_state.current_brightness; + + if(!cube_state.just_changed || deltaMs >= rateParameter.getValuef()) { + float bright_prop = min(((float) time_since_last_run / rateParameter.getValuef()), 1.0); + bv = min(MAX_ALIVE_BRIGHTNESS, bright_prop * MAX_ALIVE_BRIGHTNESS); + + if(cube_state.current_brightness < bv) { + cube_state.current_brightness = bv; + } else { + bv = cube_state.current_brightness; + } + } + for (LXPoint p : cube.points) { - float hv = max(0, lx.getBaseHuef() - abs(p.x - xPos.getValuef())); colors[p.index] = lx.hsb( hv, saturationParameter.getValuef(), - 75 + bv ); } } - public void lightDeadCube(Cube cube) { + public void lightDeadCube(Cube cube, CubeState cube_state, double deltaMs) { + float cube_dist = LXUtils.wrapdistf((float) cube_state.index, cubePos.getValuef(), model.cubes.size()); + float hv = (cube_dist / (float) model.cubes.size()) * 360; + float bv = cube_state.current_brightness; + + if(!cube_state.just_changed || deltaMs >= rateParameter.getValuef()) { + float bright_prop = 1.0 - min(((float) time_since_last_run / rateParameter.getValuef()), 1.0); + bv = max(0.0, bright_prop * MAX_ALIVE_BRIGHTNESS); + + if(cube_state.current_brightness > bv) { + cube_state.current_brightness = bv; + } else { + bv = cube_state.current_brightness; + } + } + for (LXPoint p : cube.points) { - float hv = max(0, lx.getBaseHuef() - abs(p.x - xPos.getValuef())); - double dead_bright = deadParameter.getValuef() * Math.random(); - colors[p.index] = lx.hsb( hv, saturationParameter.getValuef(), - dead_bright + bv ); } } @@ -130,13 +155,14 @@ class L8onLife extends SCPattern { List neighbors; boolean alive = false; CubeState cube_state; - this.cube_states = new LinkedList(); + this.cube_states = new ArrayList(); + float current_brightness = 0.0; Integer i = 0; - for (Cube c : model.cubes) { + for (Cube c : model.cubes) { neighbors = findCubeNeighbors(c, i); alive = true; - cube_state = new CubeState(i, alive, neighbors); + cube_state = new CubeState(i, alive, current_brightness, neighbors); this.cube_states.add(cube_state); ++i; } @@ -175,6 +201,7 @@ class L8onLife extends SCPattern { // Respect rate parameter. if(time_since_last_run < rateParameter.getValuef()) { any_changes_this_run = true; + cube_state.just_changed = false; return cube_state.alive; } else { boolean new_life = cycleOfLife(cube_state); @@ -197,7 +224,7 @@ class L8onLife extends SCPattern { Integer alive_neighbor_count = countLiveNeighbors(cube_state); boolean before_alive = cube_state.alive; boolean after_alive = before_alive; - int fetility_count = (int) fertilityParameter.getValuef(); + double mutation = Math.random(); if(cube_state.alive) { if(alive_neighbor_count < 2 || alive_neighbor_count > 3) { @@ -207,14 +234,19 @@ class L8onLife extends SCPattern { } } else { - if(alive_neighbor_count == fetility_count) { + if(alive_neighbor_count == 2) { after_alive = true; } else { after_alive = false; } } + if(mutation <= mutationParameter.getValuef()) { + after_alive = !after_alive; + } + if(before_alive != after_alive) { + cube_state.just_changed = true; any_changes_this_run = true; } @@ -235,3 +267,521 @@ class L8onLife extends SCPattern { return count; } } + +class L8onAutomata extends SCPattern { + // Controls the rate of life algorithm ticks, in milliseconds + private BasicParameter rateParameter = new BasicParameter("DELAY", 75.0, 0.0, 1000.0); + // Controls the probability of a mutation in the cycleOfStripperLife + private BasicParameter mutationParameter = new BasicParameter("MUT", 0.000000011, 0.0, 0.1); + // Controls the rate of life algorithm ticks, in milliseconds + private BasicParameter saturationParameter = new BasicParameter("SAT", 90.0, 0.0, 100.0); + + private final SawLFO pointPos = new SawLFO(0, model.points.size(), 8000); + + public final double MIN_ALIVE_PROBABILITY = 0.2; + public final double MAX_ALIVE_PROBABILITY = 0.9; + + public final float MAX_ALIVE_BRIGHTNESS = 90.0; + + class PointState { + // Index of cube in glucose.model.cubes + public Integer index; + // Boolean which describes if cube is alive. + public boolean alive; + // Boolean which describes if strip was just changed; + public boolean just_changed; + // Current brightness + public float current_brightness; + + public PointState(Integer index, boolean alive, float current_brightness) { + this.index = index; + this.alive = alive; + this.current_brightness = current_brightness; + this.just_changed = false; + } + } + + // Contains the state of all cubes by index. + private List point_states; + // Contains the amount of time since the last cycle of life. + private int time_since_last_run; + // Boolean describing if life changes were made during the current run. + private boolean any_changes_this_run; + // Hold the new lives + private List new_states; + + public L8onAutomata(LX lx) { + super(lx); + + //Print debug info about the cubes. + //outputCubeInfo(); + + initPointStates(); + randomizePointStates(); + time_since_last_run = 0; + any_changes_this_run = false; + new_states = new ArrayList(); + + addParameter(mutationParameter); + addParameter(rateParameter); + addParameter(saturationParameter); + addModulator(pointPos).trigger(); + } + + private void initPointStates() { + boolean alive = true; + PointState point_state; + this.point_states = new ArrayList(); + Integer i = 0; + float current_brightness = 0.0; + + for (LXPoint p : model.points) { + point_state = new PointState(i, alive, current_brightness); + this.point_states.add(point_state); + ++i; + } + } + + public void run(double deltaMs) { + Integer i = 0; + PointState point_state; + + any_changes_this_run = false; + new_states.clear(); + time_since_last_run += deltaMs; + + for (LXPoint p : model.points) { + point_state = this.point_states.get(i); + + if(shouldLightPoint(point_state)) { + lightLivePoint(p, point_state, deltaMs); + } else { + lightDeadPoint(p, point_state, deltaMs); + } + i++; + } + + if(!any_changes_this_run) { + randomizePointStates(); + } else { + applyNewStates(); + } + + if(time_since_last_run >= rateParameter.getValuef()) { + time_since_last_run = 0; + } + } + + public void lightLivePoint(LXPoint p, PointState point_state, double deltaMs) { + float point_dist = LXUtils.wrapdistf((float) point_state.index, pointPos.getValuef(), model.points.size()); + float hv = (point_dist / model.points.size()) * 360; + float bv = point_state.current_brightness; + + if(deltaMs >= rateParameter.getValuef() || !point_state.just_changed) { + float bright_prop = min(((float) time_since_last_run / rateParameter.getValuef()), 1.0); + bv = min(MAX_ALIVE_BRIGHTNESS, bright_prop * MAX_ALIVE_BRIGHTNESS); + + if(point_state.current_brightness < bv) { + point_state.current_brightness = bv; + } else { + bv = point_state.current_brightness; + } + } + + colors[p.index] = lx.hsb( + hv, + saturationParameter.getValuef(), + bv + ); + } + + public void lightDeadPoint(LXPoint p, PointState point_state, double deltaMs) { + float point_dist = LXUtils.wrapdistf((float) point_state.index, pointPos.getValuef(), model.points.size()); + float hv = (point_dist / model.points.size()) * 360; + float bv = point_state.current_brightness; + + if(!point_state.just_changed || deltaMs >= rateParameter.getValuef()) { + float bright_prop = 1.0 - min(((float) time_since_last_run / rateParameter.getValuef()), 1.0); + bv = max(0.0, bright_prop * MAX_ALIVE_BRIGHTNESS); + + if(point_state.current_brightness > bv) { + point_state.current_brightness = bv; + } else { + bv = point_state.current_brightness; + } + } + + colors[p.index] = lx.hsb( + hv, + saturationParameter.getValuef(), + bv + ); + } + + public boolean shouldLightPoint(PointState point_state) { + // Respect rate parameter. + if(time_since_last_run < rateParameter.getValuef()) { + any_changes_this_run = true; + point_state.just_changed = false; + return point_state.alive; + } else { + boolean new_state = cycleOfAutomata(point_state); + new_states.add(new_state); + return new_state; + } + } + + public boolean cycleOfAutomata(PointState point_state) { + Integer index = point_state.index; + Integer alive_neighbor_count = countLiveNeighbors(point_state); + boolean before_alive = point_state.alive; + boolean after_alive = before_alive; + double mutation = Math.random(); + + if(point_state.alive) { + if(alive_neighbor_count == 1) { + after_alive = true; + } else { + after_alive = false; + } + + } else { + if(alive_neighbor_count == 1) { + after_alive = true; + } else { + after_alive = false; + } + } + + if(mutation < mutationParameter.getValuef()) { + after_alive = !after_alive; + } + + if(before_alive != after_alive) { + any_changes_this_run = true; + point_state.just_changed = true; + } + + return after_alive; + } + + public int countLiveNeighbors(PointState point_state) { + int count = 0; + + if (point_state.index > 0) { + PointState before_neighbor = point_states.get(point_state.index - 1); + if(before_neighbor.alive) { + count++; + } + } + + if (point_state.index < (point_states.size() - 1)) { + PointState after_neighbor = point_states.get(point_state.index + 1); + if(after_neighbor.alive) { + count++; + } + } + + return count; + } + + private void applyNewStates() { + int index = 0; + for(boolean new_state: new_states) { + PointState point_state = this.point_states.get(index); + point_state.alive = new_states.get(index); + index++; + } + } + + private void randomizePointStates() { + double prob_range = (1.0 - MIN_ALIVE_PROBABILITY) - (1.0 - MAX_ALIVE_PROBABILITY); + double prob = MIN_ALIVE_PROBABILITY + (prob_range * Math.random()); + + //print("Randomizing points! p = " + prob + "\n"); + + for (PointState point_state: this.point_states) { + point_state.alive = (Math.random() <= prob); + point_state.just_changed = true; + } + } +} + +class L8onStripLife extends SCPattern { + // Controls the rate of life algorithm ticks, in milliseconds + private BasicParameter rateParameter = new BasicParameter("DELAY", 112.5, 1.0, 1000.0); + // Controls the probability of a mutation in the cycleOfStripperLife + private BasicParameter mutationParameter = new BasicParameter("MUT", 0.000000011, 0.0, 0.1); + // Controls the saturation. + private BasicParameter saturationParameter = new BasicParameter("SAT", 90.0, 0.0, 100.0); + + public final double MIN_ALIVE_PROBABILITY = 0.4; + public final double MAX_ALIVE_PROBABILITY = 0.9; + + public final float MAX_ALIVE_BRIGHTNESS = 90.0; + + private final SawLFO stripPos = new SawLFO(0, model.strips.size(), 8000); + + class StripState { + // Index of strip in glucose.model.strips + public Integer index; + // Boolean which describes if strip is alive. + public boolean alive; + // Boolean which describes if strip was just changed; + public boolean just_changed; + // Current brightness + public float current_brightness; + // List of this cubes neighbors + public List neighbors; + + public StripState(Integer index, boolean alive, float current_brightness, List neighbors) { + this.index = index; + this.alive = alive; + this.current_brightness = current_brightness; + this.neighbors = neighbors; + this.just_changed = false; + } + } + + // Contains the state of all cubes by index. + private List strip_states; + // Contains the amount of time since the last cycle of life. + private int time_since_last_run; + // Boolean describing if life changes were made during the current run. + private boolean any_changes_this_run; + // Hold the new lives + private List new_lives; + + public L8onStripLife(LX lx) { + super(lx); + + //Print debug info about the strips. + //outputStripInfo(); + + initStripStates(); + randomizeStripStates(); + time_since_last_run = 0; + any_changes_this_run = false; + new_lives = new ArrayList(); + + addParameter(rateParameter); + addParameter(mutationParameter); + addParameter(saturationParameter); + + addModulator(stripPos).trigger(); + } + + public void run(double deltaMs) { + Integer i = 0; + StripState strip_state; + + any_changes_this_run = false; + new_lives.clear(); + time_since_last_run += deltaMs; + + for (Strip strip : model.strips) { + strip_state = this.strip_states.get(i); + + if(shouldLightStrip(strip_state)) { + lightLiveStrip(strip, strip_state, deltaMs); + } else { + lightDeadStrip(strip, strip_state, deltaMs); + } + i++; + } + + if(!any_changes_this_run) { + randomizeStripStates(); + } else { + applyNewLives(); + } + + if(time_since_last_run >= rateParameter.getValuef()) { + time_since_last_run = 0; + } + } + + public void lightLiveStrip(Strip strip, StripState strip_state, double deltaMs) { + float strip_dist = LXUtils.wrapdistf((float) strip_state.index, stripPos.getValuef(), model.strips.size()); + float hv = (strip_dist / model.strips.size()) * 360; + float bv = strip_state.current_brightness; + + if(deltaMs >= rateParameter.getValuef() || !strip_state.just_changed) { + float bright_prop = min(((float) time_since_last_run / rateParameter.getValuef()), 1.0); + bv = min(MAX_ALIVE_BRIGHTNESS, bright_prop * MAX_ALIVE_BRIGHTNESS); + + if(strip_state.current_brightness < bv) { + strip_state.current_brightness = bv; + } else { + bv = strip_state.current_brightness; + } + } + + for (LXPoint p : strip.points) { + colors[p.index] = lx.hsb( + hv, + saturationParameter.getValuef(), + bv + ); + } + } + + public void lightDeadStrip(Strip strip, StripState strip_state, double deltaMs) { + float strip_dist = LXUtils.wrapdistf((float) strip_state.index, stripPos.getValuef(), model.strips.size()); + float hv = (strip_dist / model.strips.size()) * 360; + float bv = strip_state.current_brightness; + + if(!strip_state.just_changed || deltaMs >= rateParameter.getValuef()) { + float bright_prop = 1.0 - min(((float) time_since_last_run / rateParameter.getValuef()), 1.0); + bv = max(0.0, bright_prop * MAX_ALIVE_BRIGHTNESS); + + if(strip_state.current_brightness > bv) { + strip_state.current_brightness = bv; + } else { + bv = strip_state.current_brightness; + } + } + + for (LXPoint p : strip.points) { + colors[p.index] = lx.hsb( + hv, + saturationParameter.getValuef(), + bv + ); + } + } + + public void outputStripInfo() { + int i = 0; + for (Strip strip : model.strips) { + print("Strip " + i + ": " + strip.cx + "," + strip.cy + "," + strip.cz + "\n"); + ++i; + } + } + + private void initStripStates() { + List neighbors; + boolean alive = false; + float current_brightness = 0.0; + StripState strip_state; + this.strip_states = new ArrayList(); + Integer i = 0; + + int total_neighbors = 0; + + for (Strip strip : model.strips) { + neighbors = findStripNeighbors(strip, i); + alive = true; + strip_state = new StripState(i, alive, current_brightness, neighbors); + this.strip_states.add(strip_state); + + total_neighbors += neighbors.size(); + ++i; + } + + float average_neighbor_count = (float) total_neighbors / (float) model.strips.size(); + //print("Average neighbor count: " + average_neighbor_count + "\n"); + } + + private void randomizeStripStates() { + double prob_range = (1.0 - MIN_ALIVE_PROBABILITY) - (1.0 - MAX_ALIVE_PROBABILITY); + double prob = MIN_ALIVE_PROBABILITY + (prob_range * Math.random()); + + //print("Randomizing strips! p = " + prob + "\n"); + + for (StripState strip_state : this.strip_states) { + strip_state.alive = (Math.random() <= prob); + strip_state.just_changed = true; + } + } + + public List findStripNeighbors(Strip strip, Integer index) { + List neighbors = new LinkedList(); + Integer i = 0; + int neighbor_count = 0; + double distance = 0.0; + + for (Strip s : model.strips) { + if( (int)index != (int)i ) { + distance = Math.sqrt( Math.pow((s.cx - strip.cx), 2) + Math.pow((s.cy - strip.cy), 2) + Math.pow((s.cz - strip.cz), 2) ); + + if(distance < ( (double) Cube.EDGE_WIDTH) ) { + //print("Strip " + i + " is a neighbor of " + index + "\n"); + neighbors.add(i); + } + } + i++; + } + + return neighbors; + } + + public boolean shouldLightStrip(StripState strip_state) { + // Respect rate parameter. + if(time_since_last_run < rateParameter.getValuef()) { + any_changes_this_run = true; + strip_state.just_changed = false; + return strip_state.alive; + } else { + boolean new_life = cycleOfStripperLife(strip_state); + new_lives.add(new_life); + return new_life; + } + } + + public void applyNewLives() { + int index = 0; + for(boolean liveliness: new_lives) { + StripState strip_state = this.strip_states.get(index); + strip_state.alive = new_lives.get(index); + index++; + } + } + + public boolean cycleOfStripperLife(StripState strip_state) { + Integer alive_neighbor_count = countLiveNeighbors(strip_state); + boolean before_alive = strip_state.alive; + boolean after_alive = before_alive; + double mutation = Math.random(); + + if(strip_state.alive) { + if(alive_neighbor_count < 2 || alive_neighbor_count > 6) { + after_alive = false; + } else { + after_alive = true; + } + + } else { + if(alive_neighbor_count == 5) { + after_alive = true; + } else { + after_alive = false; + } + } + + if(mutation < mutationParameter.getValuef()) { + after_alive = !after_alive; + } + + if(before_alive != after_alive) { + any_changes_this_run = true; + strip_state.just_changed = true; + } + + return after_alive; + } + + public Integer countLiveNeighbors(StripState strip_state) { + Integer count = 0; + StripState neighbor_strip_state; + + for(Integer neighbor_index: strip_state.neighbors) { + neighbor_strip_state = this.strip_states.get(neighbor_index); + if(neighbor_strip_state.alive) { + count++; + } + } + + return count; + } +}