Korruption in der Demokratie


Korruption scheint in Österreich so allgegenwärtig zu sein, wie der Schimmel im Brotkasten einer Studenten-WG.

Wie „virtueller Schimmel“ mit Hilfe von Agenten erzeugt werden kann und wie dieser die Demokratie „befällt“, zeigt folgendes Beispiel:

Starte Applet

Mit Hilfe der Geomerative Library wird die Schrift erzeugt und die Koordinaten der Konturpunkte gefunden und in ein Array gespeichert. Mit einem Mausklick werden dann Agenten erzeugt, welche eine begrenzte Lebensdauer aufweisen und sich in zufälliger Richtung fortbewegen. Trifft ein Agent nun auf einen Konturpunkt, dann „stirbt“ er. Davor erzeugt er aber noch 0-8 neue Agenten, die sich ihrerseits auf die Suche nach Punkten auf der Schriftkontur machen. So durchdringen sie nach und nach alle Buchstaben bis dahin unsichtbaren Buchstaben und der Schriftzug wird sichtbar.

import geomerative.*;

RShape shp, shp1, shp2;
RPoint[] pnts, pnts1;

String BspText = "Korruption durchdringt die ...";
String BspText1 = "Demokratie!";
String BspText2 = "Mausklick um zu starten!";

ArrayList agenten;

void setup() {
size(1400, 500);
strokeWeight(1);
smooth();
background(0);
translate(width/2, height*2/12);
agenten = new ArrayList();

RG.init(this);

// 3 Shape - Objekte werden erzeugt.
// Die Schrift mit dem Namen "Ubuntu-R.ttf" muss im data Ordner platziert werden
shp = RG.getText(BspText, "Ubuntu-R.ttf", width/60, CENTER);
shp1 = RG.getText(BspText1, "Ubuntu-R.ttf", width*8/70, CENTER);
shp2 = RG.getText(BspText2, "Ubuntu-R.ttf", width/80, CENTER);

// Punkte an der Schriftkontur finden
//Abstand der Punkte
RCommand.setSegmentLength (1);
//Modus
RCommand.setSegmentator(RCommand.UNIFORMLENGTH);

// Die Shapes wirde gezeichnet
fill(180, 160);
shp.draw();

// und positioneiert
shp1.translate(0, height*7/12);
shp2.translate(0, height*9/12);
fill(180, 160);
shp2.draw();

// Finden der Konturpunkte
pnts = shp1.getPoints();

// Variation der einzelnen Punkte
for (int i=0;i<pnts.length; i++) {
pnts[i].x+= (int) random(-5, 5);
pnts[i].y+= (int) random(-5, 5);
}
}

void draw() {

translate(width/2, height*1/12);

for (int i=0; i<agenten.size(); i++) {
//jeder Agent wird gezeichnet
Agent agent =(Agent) agenten.get(i);
agent.render();
//jeder Agent muß die Position ändern
agent.move();

// entfernen von Agenten aus der ArrayList
if (agent.lifetime<=0) agenten.remove(i);

// Wenn ein Agent auf einen Konturpunkt trifft, wird ein punkt gezeichnet und
// es werden neue Agenten erzeugt

for (int j=0; j<pnts.length; j++) {
if (!agent.blocked && (int)agent.position.x== (int) pnts[j].x && (int)agent.position.y==  (int)pnts[j].y) {
stroke(100, 150, 255, 200);
point(pnts[j].x, pnts[j].y);
fill(100, 150, 255, 60);

for (int r=(int) random (8);r>0;r--) {
agenten.add(new Agent(pnts[j].x, pnts[j].y, agenten.size()));
}

// Damit jeder Punkt nur ein mal "besetzt" wird!
pnts[j].x=-10000;
pnts[j].y=-10000;
agenten.remove(i);
}
}
}
println(agenten.size());
}

// Um den Wucherprozess in Gang zu setzen!
void mousePressed() {
agenten.add(new Agent(mouseX-width/2, mouseY-height*1/12, agenten.size()));
}

class Agent {

// Variablen
PVector position;
PVector direction;
PVector start;
//definiert die Stärke der Richtungsänderung
float spin = 0.40;
int lifetime;
boolean blocked;
float lifetimeinit; // 3. Radius

//der Konstruktor für die Agenten-Klasse
Agent (float theX, float theY, float alifetime) {
start    = new PVector (theX, theY);
position=new PVector(theX, theY);
direction   = new PVector (10, 10);
direction.x = random (-1, 1);
direction.y = random (-1, 1);
lifetimeinit = alifetime;
if ((int)random(60/lifetimeinit)!=0) {
lifetime=(int) random(400, 600);
}
else {
lifetime=(int) random(0, 50);
}
blocked=true;
}

void render() {
stroke(255, 20);
fill(255);

point(position.x, position.y);
lifetime--;

if (((int)start.x != (int) position.x) &&((int)start.y != (int) position.y)) {
blocked=false;
}
}

void move() {

//die Agenten ändern ihre Richting nicht abrupt, sondern immer nur ein wenig!
direction.x += random (-spin, spin);
direction.y += random (-spin, spin);

//for a constant speed
direction.normalize();

// hier kann man die Geschwindigkeit ändern
//direction.mult(map(mouseX,0,width,5,1));

position.add(direction);
}
}
Advertisements

2 Kommentare

  1. Pingback: Processing – Über dieses Weblog « processing – tutorial

  2. Pingback: Array Lists « processing – tutorial

Kommentar verfassen

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

WordPress.com-Logo

Du kommentierst mit Deinem WordPress.com-Konto. Abmelden / Ändern )

Twitter-Bild

Du kommentierst mit Deinem Twitter-Konto. Abmelden / Ändern )

Facebook-Foto

Du kommentierst mit Deinem Facebook-Konto. Abmelden / Ändern )

Google+ Foto

Du kommentierst mit Deinem Google+-Konto. Abmelden / Ändern )

Verbinde mit %s

%d Bloggern gefällt das: