[SugarCubes.git] / AntonK.pde

/**************************************************************
 * WORKING PATTERNS
 **************************************************************/

class AKPong extends SCPattern
{
    private final BasicParameter speed = new BasicParameter("Speed", 0);
    private final BasicParameter leftKnob = new BasicParameter("Left", 0.5);
    private final BasicParameter rightKnob = new BasicParameter("Right", 0.5);
    private final float R = 20;
    private final float W = 20;
    private final float H = 80;
    private final float PADDLE_STEP = 5;
    private float oldLeft = leftKnob.getValuef();
    private float oldRight = rightKnob.getValuef();
        
    private Paddle left = new Paddle(model.xMin, model.cy - H / 2, model.xMin + W, model.cy + H / 2);
    private Paddle right = new Paddle(model.xMax - W, model.cy - H / 2, model.xMax, model.cy + H / 2);
    private Ball ball = new Ball();
    
    class Paddle
    {
        float x1, y1, x2, y2;
        public Paddle(float x1, float y1, float x2, float y2)
        { this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2; }
        public boolean contains(LXPoint p)
        { return p.x > x1 && p.x < x2 && p.y > y1 && p.y < y2; }
        public void moveUp()
        {
            float adj = 9 * speed.getValuef();
            if (y2 + PADDLE_STEP < model.yMax)
            {
                y1 += PADDLE_STEP + adj;
                y2 += PADDLE_STEP + adj;
            }
            else
            {
                y1 = model.yMax - H;
                y2 = model.yMax;
            }
        }
        public void moveDown()
        {
            float adj = 15 * speed.getValuef();
            if (y2 - PADDLE_STEP > model.yMin)
            {
                y1 -= PADDLE_STEP + adj;
                y2 -= PADDLE_STEP + adj;
            }
            else
            {
                y1 = model.yMin;
                y2 = model.yMin + H;
            }
        }
        
        public void moveTo(float y)
        {
            y1 = (model.yMax - H) * y;
            y2 = (model.yMax * y + H *(1 - y));
        }
    }
    
    class Ball
    {
        float x = model.cx, y = model.cy, z = model.cz;
        int xDir = 1, yDir = 1;
        int c = 0;
        public boolean contains(LXPoint p)
        { return sqrt(sq(p.x - ball.x) + sq(p.y - y) + sq(p.z - z)) < R; }
        public boolean step()
        {
            ++c;
            if (c > 360)
                c = 0;

            // Collision with floor/ceiling
            if (y + R > model.yMax || y - R < model.yMin)
                ball.yDir *= -1;
            // Collision with right wall
            if (x + R > model.xMax)
            {
                // Check if paddle is here
                if (y < right.y2 && y > right.y1)
                    xDir *= -1;
                else
                    return false;
            }
            // Collision with left wall
            if (x - R < model.xMin)
            {
                // Check if paddle is here
                if (y < left.y2 && y > left.y1)
                    xDir *= -1;
                else
                    return false;
            }
            x += xDir + xDir * 9 * speed.getValuef();
            y += yDir + yDir * 9 * speed.getValuef();
            return true;
        }
    }

    public boolean noteOn(Note note)
    {
        switch (note.getPitch())
        {
            case 49:    // W -> left paddle up
                left.moveUp();
                break;
            case 50:    // S -> left paddle down
                left.moveDown();
                break;
            case 61:    // O -> right paddle up
                right.moveUp();
                break;
            case 62:    // L -> right paddle down
                right.moveDown();
                break;
        }
        return true;
    }

    public AKPong(GLucose glucose)
    {
        super(glucose);
        addParameter(speed);
        addParameter(leftKnob);
        addParameter(rightKnob);
    }
    
    public void run(double deltsMs)
    {
        float newLeft = leftKnob.getValuef();
        float newRight = rightKnob.getValuef();
        
        if (newLeft != oldLeft)
        {
            left.moveTo(newLeft);
            oldLeft = newLeft;
        }
        if (newRight != oldRight)
        {
            right.moveTo(newRight);
            oldRight = newRight;
        }
        if (! ball.step())
            ball = new Ball();
        for (LXPoint p : model.points)
        {
            if (ball.contains(p))
                colors[p.index] = lx.hsb(ball.c, 100, 100);
            else if (left.contains(p))
                colors[p.index] = lx.hsb(0, 0, 100);
            else if (right.contains(p))
                colors[p.index] = lx.hsb(0, 0, 100);
            else
                colors[p.index] = 0;
        }
    }
}


///////////////////////////////////////////////////////////////////////////////

/**************************************************************
 * WORKS IN PROGRESS
 **************************************************************/

class AKInvader extends SCPattern
{
    private final SawLFO h = new SawLFO(0, 1, 5000);
    public AKInvader(GLucose glucose)
    {
        super(glucose);
        addModulator(h).trigger();
    }
    
    public void run(double deltaMs)
    {
        color c = lx.hsb(h.getValuef() * 360, 100, 100);
        int nTowers = model.towers.size();
        int tower = nTowers / 2;
        // tower 0
        for (int cube = 1; cube <= 3; ++cube)
            for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
                colors[p.index] = c;
        // tower 1
        ++tower;
        for (int cube = 2; cube <= 3; ++cube)
            for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
                colors[p.index] = c;
//        for (LXPoint p : model.towers.get(tower).cubes.get(5).points)
//            colors[p.index] = c;
        // tower 2
        ++tower;
        for (int cube = 1; cube <= 5; ++cube)
            for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
                colors[p.index] = c;
        // tower 3
        ++tower;
        for (LXPoint p : model.towers.get(tower).cubes.get(0).points)
            colors[p.index] = c;
        for (int cube = 2; cube <= 3; ++cube)
            for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
                colors[p.index] = c;
        for (LXPoint p : model.towers.get(tower).cubes.get(5).points)
            colors[p.index] = c;
        // tower 4
        ++tower;
        for (int cube = 2; cube <= 5; ++cube)
            for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
                colors[p.index] = c;
        // tower 5
        ++tower;
        for (LXPoint p : model.towers.get(tower).cubes.get(0).points)
            colors[p.index] = c;
        for (int cube = 2; cube <= 3; ++cube)
            for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
                colors[p.index] = c;
        for (LXPoint p : model.towers.get(tower).cubes.get(5).points)
            colors[p.index] = c;
        // tower 6
        ++tower;
        for (int cube = 1; cube <= 5; ++cube)
            for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
                colors[p.index] = c;
        // tower 7
        ++tower;
        for (int cube = 2; cube <= 3; ++cube)
            for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
                colors[p.index] = c;
//        for (LXPoint p : model.towers.get(tower).cubes.get(5).points)
//            colors[p.index] = c;
        // tower 8
        ++tower;
        for (int cube = 1; cube <= 3; ++cube)
            for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
                colors[p.index] = c;
    }
}


class AKTetris extends SCPattern
{
    // Movement increments
    private final float STEP_Y = 1;
    private final float STEP_X = 10;
    // Block dimensions
    private final float D = 10;

    private Shape shape = new Box();

    class Block
    {
        float x, y;      // Block position, lower left corner
        public Block(float x, float y)
        {
            this.x = x;
            this.y = y;
        }
    }

    abstract class Shape
    {
        List<Block> blocks;    // Blocks comprising this shape
        float x, y;            // Shape position, lower left corner
        float h, w;            // Effective Shape dimensions
        color c;
        
        public boolean contains(LXPoint p)
        {
            for (Block b : blocks)
                if (p.x > b.x && p.x < b.x + D && p.y > b.y && p.y < b.y + D)
                    return true;
            return false;
        }
        
        public void dropDown(float inc)
        {
            for (Block b : blocks)
                b.y -= inc;
            y -= inc;
        }
        
        public void moveLeft(float inc)
        {
            for (Block b : blocks)
                b.x -= inc;
            x -= inc;
        }
        
        public void moveRight(float inc)
        {
            for (Block b : blocks)
                b.x += inc;
            x += inc;
        }
    }
    
    class Box extends Shape
    {
        public Box()
        {
            /**
             * [2][3]
             * [0][1]
             * red
             */
             blocks = new LinkedList<Block>();
             blocks.add(new Block(model.cx - D, model.yMax));
             blocks.add(new Block(model.cx, model.yMax));
             blocks.add(new Block(model.cx - D, model.yMax + D));
             blocks.add(new Block(model.cx, model.yMax + D));
             w = h = 2 * D;
             c = lx.hsb(0, 100, 100);
             x = model.cx - w / 2;
             y = model.yMax;
        }
    }
    
    public AKTetris(GLucose glucose)
    {
        super(glucose);
    }
    
    public boolean noteOn(Note note)
    {
        switch (note.getPitch())
        {
            case 48:    // A -> left
                shape.moveLeft(STEP_X);
                break;
            case 52:    // D -> right
                shape.moveRight(STEP_X);
                break;
        }
        return true;
    }
    
    public void run(double deltaMs)
    {
        for (LXPoint p : model.points)
        {
            if (shape.contains(p))
                colors[p.index] = shape.c;
            else
                colors[p.index] = 0;
        }
        if (shape.y > model.yMin)
            shape.dropDown(STEP_Y);
    }
}


class AKMatrix extends SCPattern
{    
    private List<TowerStrip> towerStrips = new ArrayList<TowerStrip>(0);

    class TowerStrip
    {
        List<LXPoint> points = new ArrayList<LXPoint>(0);
    }
    
    class DXPoint
    {
        LXPoint left, right;
        public DXPoint(LXPoint left, LXPoint right)
        {
            this.left = left;
            this.right = right;
        }
    }

    public AKMatrix(GLucose glucose)
    {
        super(glucose);
//        for (Tower t : model.towers)
        {
            Tower t = model.towers.get(0);
            for (int i = 0; i < 4; ++i)
                towerStrips.add(new TowerStrip());
            
//            int i = 0;
//            for (Strip s : t.strips)
            {
                for (int i = 1; i <= 13; i += 2)
                {
                    Strip s = t.strips.get(i);
                {
                    for (LXPoint p : s.points)
                        colors[p.index] = lx.hsb(80 * (i % 4), 100, 100);
                }
                }
//                ++i;
            }
        }
    }
    
    public void run(double deltaMs)
    {
    }
}


class AKEgg extends SCPattern
{
    private final SinLFO xRadius = new SinLFO(0.01, 1, 1500);
    private final SinLFO yRadius = new SinLFO(0.01, 1, 2000);
    private final SinLFO zRadius = new SinLFO(0.01, 1, 2500);
    
    private LXPoint center;
    private float t;
    private final float X = model.xMax / 2;
    private final float Y = model.yMax / 2;
    private final float Z = model.zMax / 2;

    public AKEgg(GLucose glucose)
    {
        super(glucose);
        addModulator(xRadius).trigger();
        addModulator(yRadius).trigger();
        addModulator(zRadius).trigger();
        
        center = new LXPoint(model.cx, model.cy, model.cz);
        t = 10;
    }
    
    public void run(double deltaMs)
    {
        for (LXPoint p : model.points)
        {
            float v = sqrt(sq(p.x - center.x) + sq(p.y - center.y) + sq(p.z - center.z));
            float r = sqrt(sq(xRadius.getValuef() * X) + sq(yRadius.getValuef() * Y) + sq(zRadius.getValuef() * Z));
            if (v > r - t && v < r)
                colors[p.index] = lx.hsb(0, 0, 100);
            else
                colors[p.index] = 0;
        }
    }
}


class AKCubes extends SCPattern
{
    private Cube cube;
    private int sec;
    
    public AKCubes(GLucose glucose)
    {
        super(glucose);
        cube = model.cubes.get((int) random(model.cubes.size()));
        sec = 0;
    }


    public void run(double deltaMs)
    {
        sec += deltaMs;
        if (sec >= 1000)
        {
            for (LXPoint p : cube.points)
                colors[p.index] = 0;
            cube = model.cubes.get((int) random(model.cubes.size()));
            sec = 0;
        }
        for (LXPoint p : cube.points)
            colors[p.index] = lx.hsb(0, 0, 100);
    }
}


class AKSpiral extends SCPattern
{
    private int ms;
    public AKSpiral(GLucose glucose)
    {
        super(glucose);
        ms = 0;
    }
    
    public void run(double deltaMs)
    {
//        colors[new LXPoint(model.cx, model.cy, model.cz).index] = lx.hsb(0, 0, 100);
    }
}


class AKSpace extends SCPattern
{
    private LinkedList<Star> stars;

    class Star
    {
        // Current coordinates
        float x, y, z;
        // Ending coordinates
//        final float xEnd, yEnd, zEnd;
        // Radius
        final float r;
        // Speed
        float xInc, yInc, zInc;
        
        Star()
        {
            // Set radius
            this.r = 10;
            // Set starting coords at center
            this.reset();
        }
        
        public void reset()
        {
            this.x = model.cx;
            this.y = model.cy;
            this.z = model.zMax + this.r;
            
            // Direction of movement
            float angle = random(0, TWO_PI);
            // Calculate speed of travel
            this.xInc = cos(angle);
            this.yInc = sin(angle);
            // Star must cover full z range in the time it takes to cover dist
            this.zInc = this.z / min(abs(model.xMax * cos(angle)), abs(model.yMax * sin(angle)));
        }
        
        public void increment()
        {
            this.x += this.xInc;
            this.y += this.yInc;
            this.z -= this.zInc;
        }
        
        public boolean outOfBounds()
        {
            return (this.x > model.xMax || this.x < model.xMin || this.y > model.yMax || this.y < model.yMin);
        }
    }
    
    public AKSpace(GLucose glucose)
    {
        super(glucose);
        stars = new LinkedList<Star>();
        for (int i = 0; i < 50; ++i)
            stars.add(new Star());
    }
    
    public void run(double deltaMs)
    {
        for (LXPoint p : model.points)
            colors[p.index] = 0;

        for (Star star : stars)
        {
            if (star.x > model.xMax || star.x < model.xMin || star.y > model.yMax || star.y < model.yMin)
                star.reset();
            else
            {
                star.x += star.xInc;
                star.y += star.yInc;
                star.z -= star.zInc;
            }
            // Draw stars on model
            for (LXPoint p : model.points)
            {
                // Check if point falls within star
                if (sqrt(sq(p.x - star.x) + sq(p.y - star.y) + sq(p.z - star.z)) <= star.r)
                    colors[p.index] = lx.hsb(0, 0, 100);
            }
        }
    }
}
Commit	Line	Data
69f25521	1	/**************************************************************
	2	* WORKING PATTERNS
	3	**************************************************************/
	4
	5	class AKPong extends SCPattern
	6	{
	7	private final BasicParameter speed = new BasicParameter("Speed", 0);
	8	private final BasicParameter leftKnob = new BasicParameter("Left", 0.5);
	9	private final BasicParameter rightKnob = new BasicParameter("Right", 0.5);
	10	private final float R = 20;
	11	private final float W = 20;
	12	private final float H = 80;
	13	private final float PADDLE_STEP = 5;
	14	private float oldLeft = leftKnob.getValuef();
	15	private float oldRight = rightKnob.getValuef();
	16
	17	private Paddle left = new Paddle(model.xMin, model.cy - H / 2, model.xMin + W, model.cy + H / 2);
	18	private Paddle right = new Paddle(model.xMax - W, model.cy - H / 2, model.xMax, model.cy + H / 2);
	19	private Ball ball = new Ball();
	20
	21	class Paddle
	22	{
	23	float x1, y1, x2, y2;
	24	public Paddle(float x1, float y1, float x2, float y2)
	25	{ this.x1 = x1; this.y1 = y1; this.x2 = x2; this.y2 = y2; }
	26	public boolean contains(LXPoint p)
	27	{ return p.x > x1 && p.x < x2 && p.y > y1 && p.y < y2; }
	28	public void moveUp()
	29	{
	30	float adj = 9 * speed.getValuef();
	31	if (y2 + PADDLE_STEP < model.yMax)
	32	{
	33	y1 += PADDLE_STEP + adj;
	34	y2 += PADDLE_STEP + adj;
	35	}
	36	else
	37	{
	38	y1 = model.yMax - H;
	39	y2 = model.yMax;
	40	}
	41	}
	42	public void moveDown()
	43	{
	44	float adj = 15 * speed.getValuef();
	45	if (y2 - PADDLE_STEP > model.yMin)
	46	{
	47	y1 -= PADDLE_STEP + adj;
	48	y2 -= PADDLE_STEP + adj;
	49	}
	50	else
	51	{
	52	y1 = model.yMin;
	53	y2 = model.yMin + H;
	54	}
	55	}
	56
	57	public void moveTo(float y)
	58	{
	59	y1 = (model.yMax - H) * y;
	60	y2 = (model.yMax * y + H *(1 - y));
	61	}
	62	}
	63
	64	class Ball
65	{
66	float x = model.cx, y = model.cy, z = model.cz;
67	int xDir = 1, yDir = 1;
68	int c = 0;
69	public boolean contains(LXPoint p)
70	{ return sqrt(sq(p.x - ball.x) + sq(p.y - y) + sq(p.z - z)) < R; }
71	public boolean step()
72	{
73	++c;
74	if (c > 360)
75	c = 0;
76
77	// Collision with floor/ceiling
78	if (y + R > model.yMax \|\| y - R < model.yMin)
79	ball.yDir *= -1;
80	// Collision with right wall
81	if (x + R > model.xMax)
82	{
83	// Check if paddle is here
84	if (y < right.y2 && y > right.y1)
85	xDir *= -1;
86	else
87	return false;
88	}
89	// Collision with left wall
90	if (x - R < model.xMin)
91	{
92	// Check if paddle is here
93	if (y < left.y2 && y > left.y1)
94	xDir *= -1;
95	else
96	return false;
97	}
98	x += xDir + xDir * 9 * speed.getValuef();
99	y += yDir + yDir * 9 * speed.getValuef();
100	return true;
101	}
102	}
103
104	public boolean noteOn(Note note)
105	{
106	switch (note.getPitch())
107	{
108	case 49: // W -> left paddle up
109	left.moveUp();
110	break;
111	case 50: // S -> left paddle down
112	left.moveDown();
113	break;
114	case 61: // O -> right paddle up
115	right.moveUp();
116	break;
117	case 62: // L -> right paddle down
118	right.moveDown();
119	break;
120	}
121	return true;
122	}
123
124	public AKPong(GLucose glucose)
125	{
126	super(glucose);
127	addParameter(speed);
128	addParameter(leftKnob);
129	addParameter(rightKnob);
130	}
131
132	public void run(double deltsMs)
133	{
134	float newLeft = leftKnob.getValuef();
135	float newRight = rightKnob.getValuef();
136
137	if (newLeft != oldLeft)
138	{
139	left.moveTo(newLeft);
140	oldLeft = newLeft;
141	}
142	if (newRight != oldRight)
143	{
144	right.moveTo(newRight);
145	oldRight = newRight;
146	}
147	if (! ball.step())
148	ball = new Ball();
149	for (LXPoint p : model.points)
150	{
151	if (ball.contains(p))
152	colors[p.index] = lx.hsb(ball.c, 100, 100);
153	else if (left.contains(p))
154	colors[p.index] = lx.hsb(0, 0, 100);
155	else if (right.contains(p))
156	colors[p.index] = lx.hsb(0, 0, 100);
157	else
158	colors[p.index] = 0;
159	}
160	}
161	}
162
163
164	///////////////////////////////////////////////////////////////////////////////
165
166	/**************************************************************
167	* WORKS IN PROGRESS
168	**************************************************************/
169
170	class AKInvader extends SCPattern
171	{
172	private final SawLFO h = new SawLFO(0, 1, 5000);
173	public AKInvader(GLucose glucose)
174	{
175	super(glucose);
176	addModulator(h).trigger();
177	}
178
179	public void run(double deltaMs)
180	{
181	color c = lx.hsb(h.getValuef() * 360, 100, 100);
182	int nTowers = model.towers.size();
183	int tower = nTowers / 2;
184	// tower 0
185	for (int cube = 1; cube <= 3; ++cube)
186	for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
187	colors[p.index] = c;
188	// tower 1
189	++tower;
190	for (int cube = 2; cube <= 3; ++cube)
191	for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
192	colors[p.index] = c;
193	// for (LXPoint p : model.towers.get(tower).cubes.get(5).points)
194	// colors[p.index] = c;
195	// tower 2
196	++tower;
197	for (int cube = 1; cube <= 5; ++cube)
198	for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
199	colors[p.index] = c;
200	// tower 3
201	++tower;
202	for (LXPoint p : model.towers.get(tower).cubes.get(0).points)
203	colors[p.index] = c;
204	for (int cube = 2; cube <= 3; ++cube)
205	for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
206	colors[p.index] = c;
207	for (LXPoint p : model.towers.get(tower).cubes.get(5).points)
208	colors[p.index] = c;
209	// tower 4
210	++tower;
211	for (int cube = 2; cube <= 5; ++cube)
212	for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
213	colors[p.index] = c;
214	// tower 5
215	++tower;
216	for (LXPoint p : model.towers.get(tower).cubes.get(0).points)
217	colors[p.index] = c;
218	for (int cube = 2; cube <= 3; ++cube)
219	for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
220	colors[p.index] = c;
221	for (LXPoint p : model.towers.get(tower).cubes.get(5).points)
222	colors[p.index] = c;
223	// tower 6
224	++tower;
225	for (int cube = 1; cube <= 5; ++cube)
226	for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
227	colors[p.index] = c;
228	// tower 7
229	++tower;
230	for (int cube = 2; cube <= 3; ++cube)
231	for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
232	colors[p.index] = c;
233	// for (LXPoint p : model.towers.get(tower).cubes.get(5).points)
234	// colors[p.index] = c;
235	// tower 8
236	++tower;
237	for (int cube = 1; cube <= 3; ++cube)
238	for (LXPoint p : model.towers.get(tower).cubes.get(cube).points)
239	colors[p.index] = c;
240	}
241	}
242
243
244	class AKTetris extends SCPattern
245	{
246	// Movement increments
247	private final float STEP_Y = 1;
248	private final float STEP_X = 10;
249	// Block dimensions
250	private final float D = 10;
251
252	private Shape shape = new Box();
253
254	class Block
255	{
256	float x, y; // Block position, lower left corner
257	public Block(float x, float y)
258	{
259	this.x = x;
260	this.y = y;
261	}
262	}
263
264	abstract class Shape
265	{
266	List<Block> blocks; // Blocks comprising this shape
267	float x, y; // Shape position, lower left corner
268	float h, w; // Effective Shape dimensions
269	color c;
270
271	public boolean contains(LXPoint p)
272	{
273	for (Block b : blocks)
274	if (p.x > b.x && p.x < b.x + D && p.y > b.y && p.y < b.y + D)
275	return true;
276	return false;
277	}
278
279	public void dropDown(float inc)
280	{
281	for (Block b : blocks)
282	b.y -= inc;
283	y -= inc;
284	}
285
286	public void moveLeft(float inc)
287	{
288	for (Block b : blocks)
289	b.x -= inc;
290	x -= inc;
291	}
292
293	public void moveRight(float inc)
294	{
295	for (Block b : blocks)
296	b.x += inc;
297	x += inc;
298	}
299	}
300
301	class Box extends Shape
302	{
303	public Box()
304	{
305	/**
306	* [2][3]
307	* [0][1]
308	* red
309	*/
310	blocks = new LinkedList<Block>();
311	blocks.add(new Block(model.cx - D, model.yMax));
312	blocks.add(new Block(model.cx, model.yMax));
313	blocks.add(new Block(model.cx - D, model.yMax + D));
314	blocks.add(new Block(model.cx, model.yMax + D));
315	w = h = 2 * D;
316	c = lx.hsb(0, 100, 100);
317	x = model.cx - w / 2;
318	y = model.yMax;
319	}
320	}
321
322	public AKTetris(GLucose glucose)
323	{
324	super(glucose);
325	}
326
327	public boolean noteOn(Note note)
328	{
329	switch (note.getPitch())
330	{
331	case 48: // A -> left
332	shape.moveLeft(STEP_X);
333	break;
334	case 52: // D -> right
335	shape.moveRight(STEP_X);
336	break;
337	}
338	return true;
339	}
340
341	public void run(double deltaMs)
342	{
343	for (LXPoint p : model.points)
344	{
345	if (shape.contains(p))
346	colors[p.index] = shape.c;
347	else
348	colors[p.index] = 0;
349	}
350	if (shape.y > model.yMin)
351	shape.dropDown(STEP_Y);
352	}
353	}
354
355
356	class AKMatrix extends SCPattern
357	{
358	private List<TowerStrip> towerStrips = new ArrayList<TowerStrip>(0);
359
360	class TowerStrip
361	{
362	List<LXPoint> points = new ArrayList<LXPoint>(0);
363	}
364
365	class DXPoint
366	{
367	LXPoint left, right;
368	public DXPoint(LXPoint left, LXPoint right)
369	{
370	this.left = left;
371	this.right = right;
372	}
373	}
374
375	public AKMatrix(GLucose glucose)
376	{
377	super(glucose);
378	// for (Tower t : model.towers)
379	{
380	Tower t = model.towers.get(0);
381	for (int i = 0; i < 4; ++i)
382	towerStrips.add(new TowerStrip());
383
384	// int i = 0;
385	// for (Strip s : t.strips)
386	{
387	for (int i = 1; i <= 13; i += 2)
388	{
389	Strip s = t.strips.get(i);
390	{
391	for (LXPoint p : s.points)
392	colors[p.index] = lx.hsb(80 * (i % 4), 100, 100);
393	}
394	}
395	// ++i;
396	}
397	}
398	}
399
400	public void run(double deltaMs)
401	{
402	}
403	}
404
405
406	class AKEgg extends SCPattern
407	{
408	private final SinLFO xRadius = new SinLFO(0.01, 1, 1500);
409	private final SinLFO yRadius = new SinLFO(0.01, 1, 2000);
410	private final SinLFO zRadius = new SinLFO(0.01, 1, 2500);
411
412	private LXPoint center;
413	private float t;
414	private final float X = model.xMax / 2;
415	private final float Y = model.yMax / 2;
416	private final float Z = model.zMax / 2;
417
418	public AKEgg(GLucose glucose)
419	{
420	super(glucose);
421	addModulator(xRadius).trigger();
422	addModulator(yRadius).trigger();
423	addModulator(zRadius).trigger();
424
425	center = new LXPoint(model.cx, model.cy, model.cz);
426	t = 10;
427	}
428
429	public void run(double deltaMs)
430	{
431	for (LXPoint p : model.points)
432	{
433	float v = sqrt(sq(p.x - center.x) + sq(p.y - center.y) + sq(p.z - center.z));
434	float r = sqrt(sq(xRadius.getValuef() * X) + sq(yRadius.getValuef() * Y) + sq(zRadius.getValuef() * Z));
435	if (v > r - t && v < r)
436	colors[p.index] = lx.hsb(0, 0, 100);
437	else
438	colors[p.index] = 0;
439	}
440	}
441	}
442
443
444	class AKCubes extends SCPattern
445	{
446	private Cube cube;
447	private int sec;
448
449	public AKCubes(GLucose glucose)
450	{
451	super(glucose);
452	cube = model.cubes.get((int) random(model.cubes.size()));
453	sec = 0;
454	}
455
456
457	public void run(double deltaMs)
458	{
459	sec += deltaMs;
460	if (sec >= 1000)
461	{
462	for (LXPoint p : cube.points)
463	colors[p.index] = 0;
464	cube = model.cubes.get((int) random(model.cubes.size()));
465	sec = 0;
466	}
467	for (LXPoint p : cube.points)
468	colors[p.index] = lx.hsb(0, 0, 100);
469	}
470	}
471
472
473	class AKSpiral extends SCPattern
474	{
475	private int ms;
476	public AKSpiral(GLucose glucose)
477	{
478	super(glucose);
479	ms = 0;
480	}
481
482	public void run(double deltaMs)
483	{
484	// colors[new LXPoint(model.cx, model.cy, model.cz).index] = lx.hsb(0, 0, 100);
485	}
486	}
487
488
489	class AKSpace extends SCPattern
490	{
491	private LinkedList<Star> stars;
492
493	class Star
494	{
495	// Current coordinates
496	float x, y, z;
497	// Ending coordinates
498	// final float xEnd, yEnd, zEnd;
499	// Radius
500	final float r;
501	// Speed
502	float xInc, yInc, zInc;
503
504	Star()
505	{
506	// Set radius
507	this.r = 10;
508	// Set starting coords at center
509	this.reset();
510	}
511
512	public void reset()
513	{
514	this.x = model.cx;
515	this.y = model.cy;
516	this.z = model.zMax + this.r;
517
518	// Direction of movement
519	float angle = random(0, TWO_PI);
520	// Calculate speed of travel
521	this.xInc = cos(angle);
522	this.yInc = sin(angle);
523	// Star must cover full z range in the time it takes to cover dist
524	this.zInc = this.z / min(abs(model.xMax * cos(angle)), abs(model.yMax * sin(angle)));
525	}
526
527	public void increment()
528	{
529	this.x += this.xInc;
530	this.y += this.yInc;
531	this.z -= this.zInc;
532	}
533
534	public boolean outOfBounds()
535	{
536	return (this.x > model.xMax \|\| this.x < model.xMin \|\| this.y > model.yMax \|\| this.y < model.yMin);
537	}
538	}
539
540	public AKSpace(GLucose glucose)
541	{
542	super(glucose);
543	stars = new LinkedList<Star>();
544	for (int i = 0; i < 50; ++i)
545	stars.add(new Star());
546	}
547
548	public void run(double deltaMs)
549	{
550	for (LXPoint p : model.points)
551	colors[p.index] = 0;
552
553	for (Star star : stars)
554	{
555	if (star.x > model.xMax \|\| star.x < model.xMin \|\| star.y > model.yMax \|\| star.y < model.yMin)
556	star.reset();
557	else
558	{
559	star.x += star.xInc;
560	star.y += star.yInc;
561	star.z -= star.zInc;
562	}
563	// Draw stars on model
564	for (LXPoint p : model.points)
565	{
566	// Check if point falls within star
567	if (sqrt(sq(p.x - star.x) + sq(p.y - star.y) + sq(p.z - star.z)) <= star.r)
568	colors[p.index] = lx.hsb(0, 0, 100);
569	}
570	}
571	}
572	}