IAT 167 - Digital Games

ArrayList ribbonParticles = new ArrayList();
    					LeadParticle lead;
    					int boundaryExpansion = 1024;
    					int addSpeed = 12, addTick = 0;

void setup() {
    					size(fullWidth, fullHeight);
    					noStroke();
    					imageMode(CENTER);
    					//smooth();

lead = new LeadParticle();
    				}

void draw() {
    				background(64);

if (mousePressed) {
    				addTick++;
    				lead.pos.set(mouseX, mouseY, 0);
    				if (addTick === addSpeed) {
    				addTick = 0;
    				if (ribbonParticles.size() < 64) {
    				ribbonParticles.add(new RibbonParticle());
    			}
    		}
    	}

lead.perlin(0.4);
    	lead.walls();
    	lead.update();
    	lead.drawMe();

for (int i = 0; i < ribbonParticles.size(); i++) {
    	RibbonParticle p = (RibbonParticle) ribbonParticles.get(i);

p.beginFlock();
    	for (int j = i+1; j < ribbonParticles.size(); j++) {
    	RibbonParticle p2 = (RibbonParticle) ribbonParticles.get(j);
    	p.flock(p2);
    }
    p.endFlock();
    //p.perlin(ribbonPerlin);
    p.particleAttract(lead, 160, 64);
    //p.mouseAttract(64, 16);
    //p.repeat();
    p.update();
    p.drawMe();
}
}

class Particle {
	//fields
	PVector pos, vel, acc, sepAcc, alignAcc, cohAcc;
	float mass, damp;
	int life, boundX, boundY, boundW, boundH, sepCount, alignCount, cohCount;
	color c;

//constructor
	Particle() {
	//pos = new PVector(random(width), random(height));
	//vel = new PVector(random(-8, 8), random(-8, 8));
	pos = new PVector(mouseX, mouseY);
	vel = new PVector(0, 0);
	acc = new PVector(0,0);
	mass = random(4, 16);
	damp = 0.98;
	life = 128;
	boundX = 0;
	boundY = 0;
	boundW = width;
	boundH = height;
	sepAcc = new PVector(0,0);
	alignAcc = new PVector(0,0);
	cohAcc = new PVector(0,0);
	c = color(random(255), random(255), random(255));
}

void repel(Particle o, int strength, int cutoff) {
PVector dir = PVector.sub(pos, o.pos);
float distSq = sq(dir.mag());
if (distSq > cutoff) {
dir.normalize();
float f = 1/distSq * strength;

acc.add( PVector.mult( dir, f ) );
o.acc.sub( PVector.mult( dir, f ) );
}
}

void repelledBy(Particle o, int strength, int cutoff) {
PVector dir = PVector.sub(pos, o.pos);
float distSq = sq(dir.mag());
if (distSq > cutoff) {
dir.normalize();
float f = 1/distSq * strength;
acc.add( PVector.mult( dir, f ) );
}
}

void mouseAttract(int strength, int cutoff) {
PVector diff = PVector.sub(new PVector(mouseX, mouseY), pos);
if (diff.mag() > cutoff) {
diff.mult(strength * 1/PVector.dot(diff, diff));
if (mousePressed) {
acc.sub(diff);
}
else {
acc.add(diff);
}
}
}

void particleAttract(Particle p, int strength, int cutoff) {
PVector diff = PVector.sub(new PVector(p.pos.x, p.pos.y), pos);
if (diff.mag() > cutoff) {
diff.mult(strength * 1/PVector.dot(diff, diff));
acc.add(diff);
}
}

void beginFlock() {
sepCount = 0;
alignCount = 0;
cohCount = 0;
sepAcc.set(0,0,0);
alignAcc.set(0,0,0);
cohAcc.set(0,0,0);
}
void flock(Particle other) {
float distance = pos.dist(other.pos);
if ((distance > 0) && (distance < 32)) //flockDist
{
	//Separation
	PVector diff = PVector.sub(pos, other.pos);
	diff.normalize();
	diff.div(distance);
	sepAcc.add(diff);
	sepCount++;
	other.sepAcc.add(diff);
	other.sepCount++;
	//Alignment
	alignAcc.add(other.vel);
	alignCount++;
	other.alignAcc.add(vel);
	other.alignCount++;
	//Cohesion
	cohAcc.add(other.pos);
	cohCount++;
	other.cohAcc.add(pos);
	other.cohCount++;
}
}
void endFlock() {
if (sepCount > 0)
{
	sepAcc.div(sepCount);
}
if (sepAcc.mag() > 0)
{
	sepAcc.normalize();
	sepAcc.mult(16); //strength
	sepAcc.sub(vel);
	sepAcc.limit(1); //control
}

if (alignCount > 0)
{
	alignAcc.div(alignCount);
}
if (alignAcc.mag() > 0)
{
	alignAcc.normalize();
	alignAcc.mult(16); //strength
	alignAcc.sub(vel);
	alignAcc.limit(1); //control
}

if (cohCount > 0)
{
	cohAcc.div(cohCount);
	PVector desired = PVector.sub(cohAcc, pos);
	float distance = desired.mag();
	boolean slowDown = true; //control
	int slowDownCutoff = 64; //control
	if (distance > 0)
	{
	desired.normalize();
	if (slowDown && distance < slowDownCutoff)
	{
	desired.mult(16 * (distance/slowDownCutoff));
}
else
{
	desired.mult(16); //strength
}
cohAcc = PVector.sub(desired, vel);
cohAcc.limit(1); //control
}
else
{
	cohAcc.set(0,0,0);
}
}
sepAcc.mult(1.5); //controls
alignAcc.mult(1.5); //controls
cohAcc.mult(1); //controls
acc.add(sepAcc);
acc.add(alignAcc);
acc.add(cohAcc);
}

void perlin(float pDamp) {
float angle = noise(frameCount * 0.02);
angle = map(angle, 0.45, 0.6, -PI, PI);
PVector perlinAcc = new PVector(cos(angle), sin(angle));
perlinAcc.mult(0.1);
acc.add(perlinAcc);
}

void repeat() {
if (pos.x > width + boundaryExpansion) pos.x = -boundaryExpansion;
if (pos.x < -boundaryExpansion) pos.x = width + boundaryExpansion;
if (pos.y > height + boundaryExpansion) pos.y = -boundaryExpansion;
if (pos.y < -boundaryExpansion) pos.y = height + boundaryExpansion;
}

void walls() {
if (pos.x > boundW) {
pos.x = boundW;
vel.x *= -1;
}
if (pos.x < boundX) {
pos.x = boundX;
vel.x *= -1;
}
if (pos.y > boundH) {
pos.y = boundH;
vel.y *= -1;
}
if (pos.y < boundY) {
pos.y = boundY;
vel.y *= -1;
}
}

void update() {
vel.add(acc);
pos.add(vel);
vel.mult(damp);
acc.set(0,0,0);
}
}

class RibbonParticle extends Particle {

ArrayList past;
	float angle, pastVel;
	int pastSize, halfPastSize;

int ribbonLength = 64;
	int ribbonSpread = 16;

RibbonParticle() {
	super();

life = 255;
	past = new ArrayList();
	pastVel = 0;

c = color(random(128, 255), random(128), 0);
}

void update() {
//life
life--;
if (life < 1) {
ribbonParticles.remove(this);
} else {
super.update();
//keep track of past points
angle = atan2(vel.y, vel.x);
past.add( new PVector(pos.x, pos.y, angle) );
//PAST LENGTH
if (past.size() > ribbonLength) {
past.remove(past.get(0));
}
}
}

void drawMe() {
float newSpread;

pastSize = past.size();
halfPastSize = Math.floor(pastSize/2);
PVector p;
int i;
float opacity = 128;
if (life < 32) {
opacity = (float) life / 32 * 128
}
fill(c, opacity);
beginShape();
for (i = 0; i < halfPastSize; i++) {
p = (PVector) past.get(i);
p.x += pastVel;
newSpread = (ribbonSpread * (float)i/pastSize);
curveVertex(p.x + (newSpread * cos(p.z - PI/2)), p.y + (newSpread * sin(p.z - PI/2)));
}
for (i = halfPastSize; i < pastSize; i++) {
p = (PVector) past.get(i);
p.x += pastVel;
newSpread = ribbonSpread - (ribbonSpread * (float)i/pastSize);
curveVertex(p.x + (newSpread * cos(p.z - PI/2)), p.y + (newSpread * sin(p.z - PI/2)));
}
for (i = pastSize-1; i > halfPastSize; i--) {
p = (PVector) past.get(i);
newSpread = ribbonSpread - (ribbonSpread * (float)i/pastSize);
curveVertex(p.x + (newSpread * cos(p.z + PI/2)), p.y + (newSpread * sin(p.z + PI/2)));
}
for (i = halfPastSize; i >= 0; i--) {
p = (PVector) past.get(i);
newSpread = (ribbonSpread * (float)i/past.size());
curveVertex(p.x + (newSpread * cos(p.z + PI/2)), p.y + (newSpread * sin(p.z + PI/2)));
}
endShape();
}
}

Digital Games

Course Info

Syllabus
Success
Schedule
Inspiration: Exhibitions
Inspiration: People
Tools

Exhibitions

More coming soon

People

More coming soon

Tools and Texts

We will be using Processing and Google Chrome among other tools we will mention when you need them.

There is no official textbook for this course, however required readings will be listed.

Recommended readings come from Daniel Schiffman's Learning Processing and Nature of Code books.

Digital Games

Course Info

Exhibitions

People

Tools and Texts

Assignments

Final Project

Graphics

Data Types

Objects