Initial commit.

.project

@@ -0,0 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
	<name>pytron</name>
	<comment></comment>
	<projects>
	</projects>
	<buildSpec>
		<buildCommand>
			<name>org.python.pydev.PyDevBuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
	</buildSpec>
	<natures>
		<nature>org.python.pydev.pythonNature</nature>
	</natures>
</projectDescription>

.pydevproject

@@ -0,0 +1,10 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?eclipse-pydev version="1.0"?>
<pydev_project>
<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Python 2.7</pydev_property>
<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
<path>/pytron/src</path>
</pydev_pathproperty>
</pydev_project>

src/pytron/Enum.py

@@ -0,0 +1,10 @@
'''
Created on Nov 8, 2009
@author: Alec Thomas
'''
def Enum(*sequential, **named):
    enums = dict(zip(sequential, range(len(sequential))), **named)
    return type('Enum', (), enums)
        

src/pytron/GameGrid.py

@@ -0,0 +1,128 @@
import pygame
from pygame.locals import *
from pytron.locals.Heading import Heading
class GameGrid:
    '''
    The Game Grid is where programs compete for their survival.
    '''
    
    def __init__(self, Width, Height):
        '''
        Initializes a new instance of the GameGrid class.
        '''
        
        # Initialize the game grid.
        self.Height = Height
        self.Width = Width
        self._FrameRate = 30
        self._Programs = []
        
        # Initialize pyGame.
        pygame.init()
        pygame.display.set_caption("PyTron")
        self._Clock = pygame.time.Clock()
        self._Screen = pygame.display.set_mode((self.Width, self.Height))
        self._Background = pygame.Surface(self._Screen.get_size())
        self._Background.fill((0, 0, 0))
    
    def DoWork(self):
        # Tick-Tock.
        self._Clock.tick(self._FrameRate)
        
        # Clear screen (or possibly don't?).
        self._Screen.blit(self._Background, (0, 0))
        
        # Peek at inputs.
        self._HandleEvents(pygame.event.get())
        
        for prog in self._Programs:
            # Move and draw.
            self._DrawLightRibbon(prog.LightCycle.Move())
            
            # Collision checking.
            if prog.LightCycle.CollisionWithWall(self.Width, self.Height):
                if prog.Derezz():
                    self._Programs.remove(prog)
            else:
                # For each opponent check if program collided with their light ribbon.
                # If so, determine if program should derezz.
                
                for opponent in self._Opponents(prog):
                    if prog.LightCycle.CollisionWithLightRibbon(opponent.LightCycle.LightRibbon()):
                        if prog.Derezz():
                            self._Programs.remove(prog)
        
        # Flip! Flip! (i.e. update the display with the latest changes)
        pygame.display.flip()
    
    def IsRunning(self):
        '''
        Returns a value indicating whether the game is still running.
        '''
        
        return len(self._Programs) > 1
    
    def LoadProgram(self, Program):
        '''
        Load a program in to the game grid.
        '''
        
        self._Programs.append(Program)
    
    def SetFrameRate(self, Rate):
        '''
        Sets the frame rate.
        '''
        
        self._FrameRate = Rate
    
    def _DrawLightRibbon(self, Vertices):
        '''
        Draws the light ribbon.
        '''
        
        pygame.draw.lines(self._Screen, (255, 0, 0), False, Vertices, 1)
    
    def _HandleEvents(self, Events):
        '''
        Handles input events from the user(s).
        '''
        
        # TODO: Do not make static!!!!
        # Need to do something cool so there can be more
        # than just two programs playing (possibly use Id).
        
        for e in Events:
            if e.type == QUIT:
                self._Programs = []
            elif e.type == KEYDOWN:
                # Program one navigation.
                if e.key == K_a:
                    self._Programs[0].LightCycle.ChangeDirection(Heading.WEST)
                elif e.key == K_s:
                    self._Programs[0].LightCycle.ChangeDirection(Heading.SOUTH)
                elif e.key == K_d:
                    self._Programs[0].LightCycle.ChangeDirection(Heading.EAST)
                elif e.key == K_w:
                    self._Programs[0].LightCycle.ChangeDirection(Heading.NORTH)
                
                # Program two navigation.
                elif e.key == K_j:
                    self._Programs[1].LightCycle.ChangeDirection(Heading.WEST)
                elif e.key == K_k:
                    self._Programs[1].LightCycle.ChangeDirection(Heading.SOUTH)
                elif e.key == K_l:
                    self._Programs[1].LightCycle.ChangeDirection(Heading.EAST)
                elif e.key == K_i:
                    self._Programs[1].LightCycle.ChangeDirection(Heading.NORTH)
    
    def _Opponents(self, Program):
        '''
        Finds a programs opponents.
        '''
        
        opponents = self._Programs[:]
        opponents.remove(Program)
        
        return opponents

src/pytron/LightCycle.py

@@ -0,0 +1,80 @@
from pytron.locals.Heading import Heading
class LightCycle:
    '''
    Light cycle vehicle
    '''
    
    def __init__(self, Color, Direction, StartX, StartY):
        '''
        Initializes a new instance of the LightCycle class.
        '''
        
        self.RibbonColor = Color
        self.Direction = Direction
        self._LightRibbon = [(StartX, StartY)]
    
    def ChangeDirection(self, NewHeading):
        '''
        Change light cycle direction.
        '''
        
        # Check to make sure the bike is not pulling a 180 degree turn.
        if ((self.Direction == Heading.NORTH and NewHeading == Heading.SOUTH)
            or (self.Direction == Heading.SOUTH and NewHeading == Heading.NORTH)
            or (self.Direction == Heading.EAST and NewHeading == Heading.WEST)
            or (self.Direction == Heading.WEST and NewHeading == Heading.EAST)):
            pass
        else:
            self.Direction = NewHeading
    
    def CollisionWithLightRibbon(self, Ribbon):
        '''
        Check each point of a ribbon if we have a collision.
        '''
        
        for coord in Ribbon:
            if self._LightRibbon.count(coord) > 0:
                return True
        
        return False
    
    def CollisionWithWall(self, PosX, PosY):
        '''
        Check all possible wall collision combinations.
        '''
        
        # First find the current position.
        currentPosition = self._LightRibbon[-1]
        
        return ((currentPosition[0] < 1 or currentPosition[0] >= PosX)
                or (currentPosition[1] < 1 or currentPosition[1] >= PosY)
                or (self._LightRibbon.count(currentPosition) > 1))
    
    def LightRibbon(self):
        '''
        Return all vertices of the light ribbon.
        '''
        
        return self._LightRibbon[:]
    
    def Move(self):
        '''
        Move the light cycle one unit in its current direction.
        '''
        
        # First find the current position.
        currentPosition = self._LightRibbon[-1]
        
        # Determine which direction to move.
        if self.Direction == Heading.NORTH:
            self._LightRibbon.append((currentPosition[0], currentPosition[1] - 1))
        elif self.Direction == Heading.EAST:
            self._LightRibbon.append((currentPosition[0] + 1, currentPosition[1]))
        elif self.Direction == Heading.SOUTH:
            self._LightRibbon.append((currentPosition[0], currentPosition[1] + 1))
        else:
            self._LightRibbon.append((currentPosition[0] - 1, currentPosition[1]))
        
        # Return the light ribbon.
        return self._LightRibbon

src/pytron/Program.py

@@ -0,0 +1,40 @@
from pytron.LightCycle import LightCycle
class Program:
    '''
    A user program
    '''
    
    def __init__(self, Id):
        '''
        Initializes a new instance of the Program class.
        '''
        
        self._Health = 1
        self._Id = Id
        self.LightCycle = None
    
    def Derezz(self):
        '''
        Returns a value indicating whether the program should derezz.
        '''
        
        # Decrease health by one.
        self._Health = self._Health - 1
        
        # Return boolean indicating whether to derezz the player.
        return self._Health == 0
    
    def Name(self):
        '''
        Returns the programs name.
        '''
        
        return "Player " + self._Id
    
    def UseBaton(self, Direction, StartX, StartY):
        '''
        Use the baton to generate the light cycle.
        '''
        
        self.LightCycle = LightCycle(self._Id, Direction, StartX, StartY)

src/pytron/PyTron.py

@@ -0,0 +1,36 @@
#!/usr/bin/python
from pytron.GameGrid import GameGrid
from pytron.Program import Program
from pytron.locals.Heading import Heading
#
# Build the game grid.
#
gameGrid = GameGrid(250, 250)
gameGrid.SetFrameRate(30)
#
# Create the programs (players).
#
clu = Program(0)
clu.UseBaton(Heading.SOUTH, 10, 10)
ram = Program(1)
ram.UseBaton(Heading.NORTH, gameGrid.Width - 10, gameGrid.Height - 10)
gameGrid.LoadProgram(clu)
gameGrid.LoadProgram(ram)
#
# Engine.
#
while gameGrid.IsRunning():
    gameGrid.DoWork()
#
# End of the world.
#

src/pytron/README.txt

@@ -0,0 +1,45 @@
Program:	PyTron
Author:		Bryan M. Allred
Created:	06/03/2011
Dependencies:
	Python 2.7
	pygame
Description:
	Simple Tron game written in Python.
Acknowledgements:
	HacDC (http://www.hacdc.org) for the great introduction.
	Python documentation on classes.
	PEP008 "Style Guide for Python Code".
	Pygame documentation.
	Alec Thomas on the sweet Enum() function found on StackOverflow (I felt I needed enumerations!).
Directions:
Avoid hitting the game grids boundaries as well as each programs light ribbon. Currently each
programs health level is set to "1" so you only have one chance before derezz. To navigate your
light cycle use the following keys:
	Player 1 (Program "Clu")
		A -> Left
		S -> Down
		D -> Right
		W -> Up
	Player 2 (Program "Ram")
		J -> Left
		K -> Down
		L -> Right
		I -> Up
Issues:
[Unresolved] Once each programs light ribbon has reach a large number the redrawing of the screen
eats up resources. This causes a delay in reaction time and makes the game appear sluggish. Possibly
need to implement some sort of caching or only draw the new portions of the ribbon.
[Unresolved] Never got around to implementing different light cycle colors.
[Unresolved] Sound.

src/pytron/locals/Color.py

@@ -0,0 +1,3 @@
from pytron.Enum import Enum
Color = Enum(RED=0, BLUE=1, GREEN=2, YELLOW=3, WHITE=4)

src/pytron/locals/Heading.py

@@ -0,0 +1,3 @@
from pytron.Enum import Enum
Heading = Enum(NORTH=0, EAST=1, SOUTH=2, WEST=3)