From 2815b69095f53b912200c75cc7a91caf34bd837c Mon Sep 17 00:00:00 2001 From: Leighton Wallace Date: Sun, 24 Nov 2013 17:35:09 -0800 Subject: [PATCH] Automata and life is good Removed Fertility param from life, 2 is the right number. Added Automata visualization across the array of points. --- L8onWallace.pde | 246 +++++++++++++++++++++++++++++++++++++++++++----- SugarCubes.pde | 8 +- 2 files changed, 224 insertions(+), 30 deletions(-) diff --git a/L8onWallace.pde b/L8onWallace.pde index d3c083f..1c9d849 100644 --- a/L8onWallace.pde +++ b/L8onWallace.pde @@ -1,36 +1,34 @@ -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); + private BasicParameter rateParameter = new BasicParameter("RATE", 122.5, 0.0, 1000.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); // 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); - + private final SinLFO zPos = new SinLFO(0, model.zMax, 2500); + + 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; + } + } + // Contains the state of all cubes by index. private List cube_states; // Contains the amount of time since the last cycle of life. @@ -55,8 +53,8 @@ class L8onLife extends SCPattern { addParameter(randomParameter); addParameter(deadParameter); addParameter(saturationParameter); - addParameter(fertilityParameter); addModulator(xPos).trigger(); + addModulator(zPos).trigger(); } public void run(double deltaMs) { @@ -68,7 +66,7 @@ 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); @@ -93,7 +91,7 @@ class L8onLife extends SCPattern { public void lightLiveCube(Cube cube) { for (LXPoint p : cube.points) { - float hv = max(0, lx.getBaseHuef() - abs(p.x - xPos.getValuef())); + float hv = max(0, lx.getBaseHuef() - abs(p.z - zPos.getValuef())); colors[p.index] = lx.hsb( hv, saturationParameter.getValuef(), @@ -130,7 +128,7 @@ class L8onLife extends SCPattern { List neighbors; boolean alive = false; CubeState cube_state; - this.cube_states = new LinkedList(); + this.cube_states = new ArrayList(); Integer i = 0; for (Cube c : model.cubes) { @@ -197,7 +195,6 @@ 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(); if(cube_state.alive) { if(alive_neighbor_count < 2 || alive_neighbor_count > 3) { @@ -207,7 +204,7 @@ class L8onLife extends SCPattern { } } else { - if(alive_neighbor_count == fetility_count) { + if(alive_neighbor_count == 2) { after_alive = true; } else { after_alive = false; @@ -235,3 +232,200 @@ class L8onLife extends SCPattern { return count; } } + +class L8onAutomata extends SCPattern { + // Controls if the points 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 rate of life algorithm ticks, in milliseconds + private BasicParameter rateParameter = new BasicParameter("RATE", 75.0, 0.0, 1000.0); + + private final SinLFO zPos = new SinLFO(0, model.zMax, 2500); + + public final double MIN_ALIVE_PROBABILITY = 0.2; + public final double MAX_ALIVE_PROBABILITY = 0.9; + + class PointState { + // Index of cube in glucose.model.cubes + public Integer index; + // Boolean which describes if cube is alive. + public boolean alive; + + public PointState(Integer index, boolean alive) { + this.index = index; + this.alive = alive; + } + } + + // 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(GLucose glucose) { + super(glucose); + + //Print debug info about the cubes. + //outputCubeInfo(); + + initPointStates(); + randomizePointStates(); + time_since_last_run = 0; + any_changes_this_run = false; + new_states = new ArrayList(); + + addParameter(randomParameter); + addParameter(rateParameter); + addModulator(zPos).trigger(); + } + + private void initPointStates() { + boolean alive = false; + PointState point_state; + this.point_states = new ArrayList(); + Integer i = 0; + + for (LXPoint p : model.points) { + alive = true; + point_state = new PointState(i, alive); + 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); + } else { + lightDeadPoint(p); + } + + i++; + } + + boolean should_randomize_anyway = (randomParameter.getValuef() > 0.5); + if(should_randomize_anyway || !any_changes_this_run) { + randomizePointStates(); + } else { + applyNewStates(); + } + + if(time_since_last_run >= rateParameter.getValuef()) { + time_since_last_run = 0; + } + } + + public void lightLivePoint(LXPoint p) { + float hv = max(0, lx.getBaseHuef() - abs(p.z - zPos.getValuef())); + colors[p.index] = lx.hsb( + hv, + 90, + 80 + ); + } + + public void lightDeadPoint(LXPoint p) { + colors[p.index] = lx.hsb( + lx.getBaseHuef(), + 0, + 0 + ); + } + + public boolean shouldLightPoint(PointState point_state) { + // Respect rate parameter. + if(time_since_last_run < rateParameter.getValuef()) { + any_changes_this_run = true; + 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; + + 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(before_alive != after_alive) { + any_changes_this_run = true; + } + + return after_alive; + } + + public int countLiveNeighbors(PointState point_state) { + Integer index = point_state.index; + PointState before_neighbor; + PointState after_neighbor; + + int count = 0; + if (index > 0) { + before_neighbor = point_states.get(index - 1); + if(before_neighbor.alive) { + count++; + } + } + + if (index < (point_states.size() - 1)) { + after_neighbor = point_states.get(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); + } + } + +} diff --git a/SugarCubes.pde b/SugarCubes.pde index 81bb283..f3351e0 100644 --- a/SugarCubes.pde +++ b/SugarCubes.pde @@ -25,6 +25,7 @@ LXPattern[] patterns(GLucose glucose) { return new LXPattern[] { + new SineSphere(glucose), //new CubeCurl(glucose), @@ -66,8 +67,6 @@ LXPattern[] patterns(GLucose glucose) { new TimCubes(glucose), // new TimTrace(glucose), new TimSpheres(glucose), - - // Jackie new JackieSquares(glucose), @@ -75,8 +74,9 @@ LXPattern[] patterns(GLucose glucose) { new JackieDots(glucose), // L8on - new L8onLife(glucose), - + new L8onLife(glucose), + new L8onAutomata(glucose), + // Vincent new VSTowers(glucose), -- 2.34.1