snake.py

#
# snake.py
#
# Copyright (c) 2005 Nokia Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

import appuifw
import math
import e32
from key_codes import *
from graphics import *
import random

class SnakeGame:
    deltas=((1,0),(0,-1),(-1,0),(0,1))
    def __init__(self):
        self.direction=0
        self.step=5
        self.color=(0,128,0)
        self.fillarray={}
        self.exitflag=0
        self.score=0
        self.wormlocs=[]
        self.wormlength=10
        self.foodloc=None
        self.fieldcolor=(192,192,128)        
        self.state='init'        
        self.old_body=appuifw.app.body
        self.canvas=appuifw.Canvas(redraw_callback=self.redraw)
        self.draw=Draw(self.canvas)
        appuifw.app.body=self.canvas
        self.fieldsize=(self.canvas.size[0]/self.step,(self.canvas.size[1]-16)/self.step)        
        self.canvas.bind(EKeyRightArrow,lambda:self.turnto(0))
        self.canvas.bind(EKeyUpArrow,lambda:self.turnto(1))
        self.canvas.bind(EKeyLeftArrow,lambda:self.turnto(2))
        self.canvas.bind(EKeyDownArrow,lambda:self.turnto(3))
        self.loc=[self.fieldsize[0]/2,self.fieldsize[1]/2]        
        self.place_food()
        self.state='playing'
        self.redraw(())
    def turnto(self,direction):
        self.direction=direction
    def close_canvas(self): # break reference cycles
        appuifw.app.body=self.old_body
        self.canvas=None
        self.draw=None
        appuifw.app.exit_key_handler=None
    def redraw(self,rect):
        self.draw.clear(self.fieldcolor)
        for loc in self.fillarray.keys():
            self.draw_square(loc,self.color)
        self.draw_score()
        if self.foodloc:
            self.draw_food()        
    def draw_square(self,loc,color):
        self.draw.rectangle((loc[0]*self.step,
                             16+loc[1]*self.step,
                             loc[0]*self.step+self.step,
                             16+loc[1]*self.step+self.step),fill=color)
    def draw_score(self):
        self.draw.rectangle((0,0,176,16),fill=(0,0,0))
        self.draw.text((0,14),u"Score: %d"%self.score,(0,192,0))
    def draw_food(self):
        self.draw_square(self.foodloc,(255,0,0))        
    def place_food(self):
        while 1:
            self.foodloc=(random.randint(0,self.fieldsize[0]-1),
                          random.randint(0,self.fieldsize[1]-1))
            if not self.fillarray.has_key(self.foodloc): break
        self.draw_food()
    def set_exit(self):
        self.exitflag=1
    def run(self):
        appuifw.app.exit_key_handler=self.set_exit
        while not self.exitflag:
            self.draw_square(self.loc,self.color)
            if (tuple(self.loc) in self.fillarray or
                self.loc[0]>=self.fieldsize[0] or self.loc[0]<0 or
                self.loc[1]>=self.fieldsize[1] or self.loc[1]<0):
                break
            if tuple(self.loc)==self.foodloc:
                self.score+=10
                self.draw_score()
                self.place_food()
                self.draw_food()
                self.wormlength+=10
            if len(self.wormlocs)>self.wormlength:
                loc=self.wormlocs[0]
                del self.wormlocs[0]
                del self.fillarray[loc]
                self.draw_square(loc,self.fieldcolor)
            self.fillarray[tuple(self.loc)]=1
            self.wormlocs.append(tuple(self.loc))
            e32.ao_sleep(0.08)
            self.loc[0]+=self.deltas[self.direction][0]
            self.loc[1]+=self.deltas[self.direction][1]
        self.close_canvas()
appuifw.app.screen='full'
playing=1
while playing:
    game=SnakeGame()
    game.run()
    playing=appuifw.query(u'Final score: %d - Play again?'%game.score,'query')