import this

10. January, 2014

During the Flask presentation yesterday, I learned about an Easter egg in Python: “import this” which will print:

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one– and preferably only one –obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea — let’s do more of those!


People Despair When They No Longer Experience Themselves as Efficacious

7. January, 2014

Simple fact: When you feel helpless, unable to change your circumstances, and when your input doesn’t spawn any reaction, you despair.


As I Began To Love Myself

26. December, 2013

This text/poem is attributed to Charlie Chaplin but there is some discussion whether this is true or not.

I’m not sure what is correct but I feel that the poem itself is too important to bother much about the details. There are two versions. Version 1 is from the Sahaja Yoga:

As I began to love myself
I found that anguish and emotional suffering
are only warning signs that I was living against my own truth.
Today, I know, this is “AUTHENTICITY“.

As I began to love myself
I understood how much it can offend somebody
as I try to force my desires on this person,
even though I knew the time was not right and the person was not ready for it,
and even though this person was me.
Today I call it “RESPECT“.

As I began to love myself
I stopped craving for a different life,
and I could see that everything that surrounded me was inviting me to grow.
Today I call it “MATURITY“.

As I began to love myself
I understood that at any circumstance,
I am in the right place at the right time, and
everything happens at the exactly right moment,
so I could be calm.
Today I call it “SELF-CONFIDENCE“.

As I began to love myself
I quit stealing my own time, and
I stopped designing huge projects for the future.
Today, I only do what brings me joy and happiness,
things I love to do and that make my heart cheer,
and I do them in my own way and in my own rhythm.
Today I call it “SIMPLICITY“.

As I began to love myself
I freed myself of anything that is no good for my health –
food, people, things, situations, and
everything the drew me down and away from myself.
At first I called this attitude a healthy egoism.
Today I know it is “LOVE OF ONESELF“.

As I began to love myself
I quit trying to always be right,
and ever since I was wrong less of the time.
Today I discovered that is “MODESTY“.

As I began to love myself
I refused to go on living in the past and
worry about the future.
Now, I only live for the moment,
where EVERYTHING is happening.
Today I live each day, day by day, and I call it “FULFILLMENT“.

As I began to love myself
I recognized that my mind can disturb me and
it can make me sick.
But As I connected it to my heart,
my mind became a valuable ally.
Today I call this connection “WISDOM OF THE HEART“.

We no longer need to fear arguments,
confrontations or any kind of problems with ourselves or others.
Even stars collide, and out of their crashing new worlds are born.
Today I know THAT IS “LIFE“!

There is also a YouTube version by Adrea Bezerra.

M.Peer Mohamed Sardhar posted a much longer and more complex version:

When I started loving myself” – A poem by Charlie Chaplin written on his 70th birthday on April 16, 1959:

When I started loving myself
I understood that I’m always and at any given opportunity
in the right place at the right time.
And I understood that all that happens is right –
from then on I could be calm.
Today I know: It’s called TRUST.

When I started to love myself I understood how much it can offend somebody
When I tried to force my desires on this person,
even though I knew the time is not right and the person was not ready for it,
and even though this person was me.
Today I know: It’s called LETTING GO

When I started loving myself
I could recognize that emotional pain and grief
are just warnings for me to not live against my own truth.
Today I know: It’s called AUTHENTICALLY BEING.

When I started loving myself
I stopped longing for another life
and could see that everything around me was a request to grow.
Today I know: It’s called MATURITY.

When I started loving myself
I stopped depriving myself of my free time
and stopped sketching further magnificent projects for the future.
Today I only do what’s fun and joy for me,
what I love and what makes my heart laugh,
in my own way and in my tempo.
Today I know: it’s called HONESTY.

When I started loving myself
I escaped from all what wasn’t healthy for me,
from dishes, people, things, situations
and from everything pulling me down and away from myself.
In the beginning I called it the “healthy egoism”,
but today I know: it’s called SELF-LOVE.

When I started loving myself
I stopped wanting to be always right
thus I’ve been less wrong.
Today I’ve recognized: it’s called HUMBLENESS.

When I started loving myself
I refused to live further in the past
and worry about my future.
Now I live only at this moment where EVERYTHING takes place,
like this I live every day and I call it CONSCIOUSNESS.

When I started loving myself
I recognized, that my thinking
can make me miserable and sick.
When I requested for my heart forces,
my mind got an important partner.
Today I call this connection HEART WISDOM.

We do not need to fear further discussions,
conflicts and problems with ourselves and others
since even stars sometimes bang on each other
and create new worlds.
Today I know: THIS IS LIFE!


Writing Games with Processing: Intro Screen

24. December, 2013

Merry Christmas, everyone :-)

In the last post, we cleaned up the code. This makes it now very simple to add an intro to the game:

class IntroState extends State {
  
  Player p;
  Enemy e;
  Step playerStep;
  Step enemyStep;
  
  void setup() {
    
    playerStep = new Step();
    playerStep.x += + 3*tileSize;
    
    p = new Player();
    
    e = new Enemy("Kenny");

    enemyStep = new Step();
    
    frameRate(10);
  }

The class Step adds a very simple movement algorithm to the player and enemy we created in setup():

class Step {
  int minX = tileSize * 3;
  int minY = tileSize * 3;
  int maxX = width - (tileSize * 3);
  int maxY = height - (tileSize * 3);

  int x = minX;
  int y = minY;
  int dx = tileSize;
  int dy = 0;
  
  void next() {
    int newX = x + dx;
    int newY = y + dy;
    
    if(newX > maxX) {
      newX = maxX;
      dx = 0;
      dy = tileSize;
      newY += dy;
    } else if(newY > maxY) {
      newY = maxY;
      dx = -tileSize;
      dy = 0;
      newX += dx; 
    } else if(newX < minX) {
      newX = minX;
      dx = 0;
      dy = -tileSize;
      newY += dy;
    } else if(newY < minY) {
      newY = minY;
      dx = tileSize;
      dy = 0;
      newX += dx; 
    }
    
    x = newX;
    y = newY;
  }
}

The code simply moves a coordinate along the outline of a rectangle. Using this code, we can move the player and enemy and then render the screen:

  void draw() {
    movePlayer();
    moveEnemy();
    
    drawBackground();
    p.draw();
    e.draw();
  }
  
  void movePlayer() {
    playerStep.next();
    p.x = playerStep.x;
    p.y = playerStep.y;
  }
  
  void moveEnemy() {
    enemyStep.next();   
    e.x = enemyStep.x;
    e.y = enemyStep.y;
  }

drawBackground() is similar to the code in the main game code. Only this time, we display the game title and a short explanation what the game is about.

We could also use this to display a high score list, etc.

  void drawBackground() {
    fill(174, 204, 27);
    rect(0, 0, width, height);
    
    textAlign(CENTER, TOP);
    textSize(40);
    color outline = color(255,255,255);
    color fill = color(0,0,0);
    int y = height/2 - 60;
    textWithOutline("Run, Platty, Run!", width/2, y, outline, fill);
    y += 50;
    
    textSize(20);
    textWithOutline("Use cursor keys to evade the hungry crocodiles", width/2, y, outline, fill);
    y += 40;
    
    outline = color(0,0,255);
    fill = color(255,255,255);
    textWithOutline("Press any key to start", width/2, y, outline, fill);
    y += 20;
  }

The last element we need is a key handler which starts the game itself:

  void keyPressed() {
    changeState(new MainGame());
  }

Easy, isn’t it? Just imagine how complex this might have been without the refactoring. We might have ended up with a draw() method with several if(), checking for the current state of the game, trying to avoid messing with the wrong variables, …

By splitting the game into steps, each step can do it’s own thing. This is the major goal of refactoring: Cutting down dependencies.

The whole project can be cloned from here. The version of this blog post is tagged with v9.

Cool, our game is almost complete. One last thing is missing: Displaying the high score table.

Previous: Cleaning Up
First post: Getting Started


Writing Games with Processing: Cleaning Up

23. December, 2013

While the code for our game is simple enough, it’s starting to get messy. movePlayer() contains code to move the player, the enemies and the collision detection.

Also, the game ends when you win. There is no way to restart. I could add that but it would make the code … ugly. Time to refactor.

Refactoring, in a nutshell, means to change the internal structure of the code without changing the behavior.

Sounds futile? Nope. The goal of refactoring to make the code easier to maintain and extend.

Right now, the some code related to enemies is in the Enemy class but code for the player is spread all over the place. Time to create a Player class.

class Player {
  int x = 320, y = 240;

  void draw() {
    fill(235,220,160);
    rect(x, y, tileSize, tileSize);
    
    fill(0);
    textSize(tileSize-2);
    textAlign(CENTER, CENTER);
    text("P", x+tileSize/2, y+tileSize/2-2);
  }
  
  void move(int dx, int dy) {
    dx *= tileSize;
    dy *= tileSize;
    
    int newX = x + dx;
    int newY = y + dy;
    if(newX >= 0
      && newX < width
      && newY >= 0
      && newY < height
    ) {
      x = newX;
      y = newY;
    }
  }
}

That looks much better. Next, we’ll have several states that the game can be in: Intro, game running, game over, high score.

They all have similar properties: They respond to keys and they draw something on the screen. With the current code, that would be clumsy to implement.

So I add a new class:

class State {
  void setup() {}
  void draw() {}
  void keyPressed() {}
}

Now, I can move all the code to run the game into a new class MainGame which extends State:

class MainGame extends State {
  ArrayList<Enemy> enemies = new ArrayList<Enemy>();
  Player player;
  
  void addEnemy(int x, int y, String name) {
    Enemy enemy = new Enemy(name);
    enemy.x = x;
    enemy.y = y;
    enemies.add(enemy);
  }
  
  void drawEnemies() {
   for(Enemy e: enemies) {
      e.draw();
    }
  }

  void setup() {
    player = new Player();
  
    addEnemy(20, 20, "Kenny");
    addEnemy(600, 20, "Benny");
  }

  void drawBackground() {
    fill(174, 204, 27);
    rect(0, 0, width, height);
      
    fill(0);
    textAlign(LEFT, TOP);
    textSize(20);
    text("Scrore: "+score, 2, 2);
  }
  
  void draw() {
    drawBackground();
    player.draw();
    drawEnemies();
  }
  
  void moveEnemies() {
    for(Enemy e: enemies) {
      e.hunt(player.x, player.y);
    }
  }
  
  void checkCollisions() {
    ArrayList<Enemy> enemiesToCheck = new ArrayList<Enemy>();
    
    for(Enemy e: enemies) {
      if(e.closeTo(player.x, player.y)) {
        gameOver(e);
        return;
      }
      
      for(Enemy e2: enemiesToCheck) {
        if(e.closeTo(e2.x, e2.y)) {
          e.fighting = true;
          e2.fighting = true;
        }
      }
      
      enemiesToCheck.add(e);
    }
    
    int notFighting = 0;
    for(Enemy e: enemies) {
      if(!e.fighting) {
        notFighting ++;
      }
    }
    
    score ++;
    if(notFighting == 0) {
      youWon(enemies.size());
    }
  }
  
  void movePlayer(int dx, int dy) {
    player.move(dx, dy);
    moveEnemies();
    checkCollisions();
  }
  
  void keyPressed() {
    if(key == CODED) {
      if(keyCode == UP) {
        movePlayer(0, -1);
      } else if(keyCode == DOWN) {
        movePlayer(0, 1);
      } else if(keyCode == LEFT) {
        movePlayer(-1, 0);
      } else if(keyCode == RIGHT) {
        movePlayer(1, 0);
      }
    } else if(key == ' ') {
      movePlayer(0, 0);
    }  
  }  
}

Next, we can move the code for “game over” into a new GameOverWonState and GameOverLostState:

class GameOverWonState extends State {
  MainGame main;
  int numberOfEnemies;
  
  GameOverWonState(MainGame main, int numberOfEnemies) {
    this.main = main;
    this.numberOfEnemies = numberOfEnemies;
  }
  
  void draw() {
    main.draw();
  
    textAlign(CENTER, TOP);
    textSize(40);
    color outline = color(255,255,255);
    color fill = color(255,0,0);
    textWithOutline("YOU WON!", width/2, 200, outline, fill);
    
    textSize(20);
    textWithOutline("The cute platypus outsmarted "+numberOfEnemies+" crocodiles!", width/2, 240, outline, fill);    
  }
}

class GameOverLostState extends State {
  MainGame main;
  Enemy e;
  
  GameOverLostState(MainGame main, Enemy e) {
    this.main = main;
    this.e = e;
  }
  
  void draw() {
    main.draw();
  
    textAlign(CENTER, TOP);
    textSize(40);
    color outline = color(255,255,255);
    color fill = color(255,0,0);
    textWithOutline("GAME OVER", width/2, 200, outline, fill);
    
    textSize(20);
    textWithOutline("The poor platypus was eaten by "+e.name+"!", width/2, 240, outline, fill);
  }
}

While this is much more code than before, it has the advantage that I don’t have to stop the main loop anymore. Which means I can add a nice death or victory animation with little effort.

More importantly, I can (after another refactoring) restart the game:

class GameOverState extends State {
  MainGame main;
  String mainMessage;
  String subMessage;
  
  GameOverState(MainGame main, String mainMessage, String subMessage) {
    this.main = main;
    this.mainMessage = mainMessage;
    this.subMessage = subMessage;
  }

  void draw() {
    main.draw();
  
    textAlign(CENTER, TOP);
    textSize(40);
    color outline = color(255,255,255);
    color fill = color(255,0,0);
    textWithOutline(mainMessage, width/2, 200, outline, fill);
    
    textSize(20);
    textWithOutline(subMessage, width/2, 240, outline, fill);
    
    color outline = color(0,0,0);
    color fill = color(255,255,255);

    textSize(20);
    textWithOutline("Try again (Y/N)?", width/2, 280, outline, fill);
  }
  
  void keyPressed() {
    if(key == 'y' || key == 'Y') {
      current = new MainGame();
      current.setup();
    } else if(key == 'n' || key == 'N') {
      exit();
    }
  } 
}

class GameOverWonState extends GameOverState {
  GameOverWonState(MainGame main, int numberOfEnemies) {
    super(main, "YOU WON!", "The cute platypus outsmarted "+numberOfEnemies+" crocodiles!");
  }
}

class GameOverLostState extends GameOverState {
  GameOverLostState(MainGame main, Enemy e) {
    super(main, "GAME OVER", "The poor platypus was eaten by "+e.name+"!");
  }
}

To move to these states, I implement two new methods in MainGame:

  void gameOver(Enemy e) {
    current = new GameOverLostState(this, e);
  }
  
  void youWon() {
    current = new GameOverWonState(this, enemies.size()); 
  }

While trying this version, I noticed that I forgot to reset the score. Actually, the scoring is part of the main game loop, so I can move all the code related to it into MainGame.

Also, I noticed that I sometimes forgot to call setup() when changing states. A new method fixes all this:

void changeState(State next) {
  current = next;
  current.setup();
}

To clean up things even more, I’m splitting the code into several tabs. Since the project has now reached a certain complexity, I’m moving to version control with Git. If you don’t know what Git or distribute version control is, I suggest to read this article. Or you can try it online.

The whole project can be cloned from here. The version of this blog post is tagged with v8.

With the new cleaned up code, we can easily add an intro screen.

Previous: Highscore!
First post: Getting Started


Writing Games with Processing: Highscore!

22. December, 2013

What’s a game without a score? Boring!

Luckily, adding scoring to our game is a piece of cake. We just count the number of moves that Platty survives.

For this, we need another global variable:

int tileSize = 20;
int score = 0;

Then in the collision check, we increment the score:

  score ++;
  if(notFighting == 0) {
    ...

and lastly, we display score in drawBackground():

void drawBackground() {
  fill(174, 204, 27);
  rect(0, 0, width, height);
    
  fill(0);
  textAlign(LEFT, TOP);
  textSize(20);
  text("Scrore: "+score, 2, 2);
}

That’s it. Can you beat my high score?

Highscore

That’s it. Complete game in 210 lines of code.

Next: Time to clean up.

Previous: Winning
First post: Getting Started


Writing Games with Processing: Winning

21. December, 2013

Now that the player can lose the game, he needs a way to win. One idea we had was that crocodiles are greedy: When they run into each other hunting Platty, they start to fight over the food.

To achieve this, we need to add more checks to checkCollisions():

void checkCollisions() {
  ArrayList<Enemy> enemiesToCheck = new ArrayList<Enemy>();
  
  for(Enemy e: enemies) {
    if(e.closeTo(px, py)) {
      gameOver(e);
      return;
    }
    
    for(Enemy e2: enemiesToCheck) {
      if(e.closeTo(e2.x, e2.y)) {
        e.fighting = true;
        e2.fighting = true;
      }
    }
    
    enemiesToCheck.add(e);
  }
  
  int notFighting = 0;
  for(Enemy e: enemies) {
    if(!e.fighting) {
      notFighting ++;
    }
  }
  
  if(notFighting == 0) {
    youWon();
  }
}

As you can see, I added an inner loop to check if the current enemy is close to any other enemy (except itself, that’s why there is a second list).

I also count how many enemies are currently not in a fight.

At the end, if all enemies are fighting with each other, Platty has won:

void youWon() {
  draw();
  noLoop();
  
  textAlign(CENTER, TOP);
  textSize(40);
  color outline = color(255,255,255);
  color fill = color(255,0,0);
  textWithOutline("YOU WON!", width/2, 200, outline, fill);
  
  textSize(20);
  textWithOutline("The cute platypus outsmarted "+enemies.size()+" crocodiles!", width/2, 240, outline, fill);
}

Now just add a boolean to Enemy:

  boolean fighting;

Let’s see how that works:

Winning the Game
(Click image to start the animation)

What’s left? Scoring!

You can find the whole source code here.

Previous: Eating Platty
First post: Getting Started


Follow

Get every new post delivered to your Inbox.

Join 334 other followers