Merge branch 'master' of https://github.com/sugarcubes/SugarCubes
[SugarCubes.git] / AntonK.pde
CommitLineData
69f25521 1/**************************************************************
2 * WORKING PATTERNS
3 **************************************************************/
4
5class 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
170class 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
244class 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
356class 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
406class 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
444class 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
473class 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
489class 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}