Working on integration

5 files changed, 497 insertions, 0 deletions

diff --git a/devtools/Dave's Test Kit/DrawableFontObject.py b/devtools/Dave's Test Kit/DrawableFontObject.py
new file mode 100644
index 0000000..038d791
--- /dev/null
+++ b/devtools/Dave's Test Kit/DrawableFontObject.py
@@ -0,0 +1,16 @@
+import pygame

+from DrawableObject import DrawableObject

+

+class DrawableFontObject(DrawableObject, pygame.sprite.Sprite):

+

+    def __init__(self,text,font, x = 0, y = 0):

+

+        self.font = font

+        self.textImage = font.render(text, 1, (255,255,255))

+        #self._image = self.textImage

+        DrawableObject.__init__(self, [self.textImage], '')

+

+    def changeText(self, newText, color=(0,0,0)):

+

+        self._images[0] = self.font.render(newText, True, color)

+        self.image = self._images[0]

diff --git a/devtools/Dave's Test Kit/DrawableObject.py b/devtools/Dave's Test Kit/DrawableObject.py
new file mode 100644
index 0000000..b3584a3
--- /dev/null
+++ b/devtools/Dave's Test Kit/DrawableObject.py
@@ -0,0 +1,140 @@
+import pygame

+

+class DrawableObject(pygame.sprite.Sprite):

+

+    def __init__(self, images, textfileName, x = 0, y = 0):

+        pygame.sprite.Sprite.__init__(self)

+        

+        self._images = []

+        self._origImages = []

+        for i in range(len(images)):

+            self._images.append(images[i].convert())

+            self._origImages.append(images[i].convert())

+

+        self._start = pygame.time.get_ticks()

+        self.image = self._images[0]

+        self._last_update = 0

+        self._frame = 0

+        self.animations = {}

+        self._current_anim = ""

+        self.rect = self.image.get_rect()

+        self.xPos = x

+        self.yPos = y

+        self.myAngle = 0

+        self.xSize = 40     # <--

+        self.ySize = 40     # <--

+        self.rect.topleft = (x,y)

+

+        if textfileName != '':

+

+           f = open(textfileName, 'r')

+           currentLine = f.readline()

+           while currentLine != '':

+

+             animValues = currentLine.split(",")

+             self.animations[animValues[0]] =  [int(animValues[1]), int(animValues[2])]

+             currentLine = f.readline()

+

+        else:

+        

+            self.animations["anim1"] = [0, len(self._images)]

+            self.goToAnim("anim1")

+

+    def repopulateImages(self, newImages):

+    

+        self._images = []

+        self._origImages = []

+        for i in range(len(newImages)):

+            self._images.append(newImages[i].convert())

+            self._origImages.append(newImages[i].convert())

+        

+        self.image = self._images[0]

+        self._frame = 0

+        self.xSize = 40     # <--

+        self.ySize = 40     # <--

+

+    def addImages(self, images):

+        self._images.extend(images)

+        self._origImages.extend(images)

+

+    def goToAnim(self, animName):

+      if self.animations.get(animName, 0) != 0:

+         self._current_anim = animName

+         self._frame = self.animations[animName][0]

+         self.image = self._images[self._frame]

+

+    def nudge(self, x, y):

+        self.xPos += x

+        self.yPos += y

+        self.rect.right += x

+        self.rect.top += y

+

+    def scale(self, x=None, y=None):

+        if type(x).__name__=='int': self.xSize = x

+        if type(y).__name__=='int': self.ySize = y

+            

+        for i in range(len(self._images)):

+            self._origImages[i] = pygame.transform.scale(self._origImages[i], (self.xSize, self.ySize))

+            self._images[i] = self._origImages[i]

+

+    def fill(self, color):

+        for i in range(len(self._images)):

+            #print "filling with ", color

+            self._origImages[i].fill(color)

+            self._images[i].fill(color)

+            

+    def getXSize(self):

+       return self.xSize

+

+    def getYSize(self):

+       return self.ySize

+

+    def rotate(self,angle):

+        self.myAngle += angle

+        for i in range(len(self._images)):

+            self._images[i] = pygame.transform.rotate(self._origImages[i], self.myAngle)

+

+    def getRotation(self):

+       return self.myAngle

+

+    def setPosition(self, x = None, y = None):

+        if type(x).__name__=='int': self.xPos = x

+        if type(y).__name__=='int': self.yPos = y

+        self.rect.topleft = (self.xPos, self.yPos)

+

+    def getXPos(self):

+       return self.xPos

+

+    def getYPos(self):

+       return self.yPos

+

+    def calcColorKey(self, x=0, y=0):

+       myColorKey = images[0].get_at((x,y))

+       setColorKey(myColorKey)

+       

+    def makeTransparent(self, bool = True):

+       

+       if bool == True:

+            self.nudge(-3000, 0)

+       else:

+            self.nudge(3000, 0)

+

+    def setColorKey(self, aColor):

+       for i in range(len(self._images)):

+          self._images[i].set_colorkey(aColor)

+

+    def update(self, t=None):

+        timePassed = t + self._last_update

+

+        if (timePassed) > 200:

+

+            self.image = self._images[self._frame]

+            self._last_update = timePassed%1000

+        else:   

+            self._last_update = timePassed

+

+    def nextFrame(self):

+       pass

+

+    def nextCurrentAnimFrame(self):

+       pass

diff --git a/devtools/Dave's Test Kit/DynamicDrawableObject.py b/devtools/Dave's Test Kit/DynamicDrawableObject.py
new file mode 100644
index 0000000..9c7f2ac
--- /dev/null
+++ b/devtools/Dave's Test Kit/DynamicDrawableObject.py
@@ -0,0 +1,75 @@
+import pygame

+from DrawableObject import DrawableObject

+

+class DynamicDrawableObject(DrawableObject, pygame.sprite.Sprite):

+

+    def __init__(self,images,textfileName,fps = 10, x = 0, y = 0, xVelocity = 0, yVelocity = 0):

+

+        self._delay = 1000/fps

+        DrawableObject.__init__(self, images, textfileName, x, y)

+

+    def addImages(self, images):

+

+        self._images.extend(images)

+

+    def setSpeed(self, xVelocity = None, yVelocity = None):

+

+       if xVelocity != None:  self.xSpeed = xVelocity

+       if yVelocity != None:  self.ySpeed = yVelocity

+

+    def getXSpeed(self):

+

+       return self.xSpeed

+

+    def getYSpeed(self):

+

+       return self.ySpeed

+

+    def move(self):

+        self.xPos += self.xSpeed

+        self.yPos += self.ySpeed

+        self.rect.right += self.xSpeed

+        self.rect.top += self.ySpeed

+

+    def update(self, t):

+

+        timePassed = t + self._last_update

+

+        if (timePassed) > self._delay:

+            if self._frame < self.animations.get(self._current_anim)[0] or self._frame > self.animations.get(self._current_anim)[1]: 

+                self._frame = self.animations.get(self._current_anim)[0]

+

+            self._frame += timePassed/self._delay

+

+            while self._frame >= self.animations.get(self._current_anim)[1]:

+                framesPast = self._frame - self.animations.get(self._current_anim)[1]

+                self._frame = framesPast - 1 + self.animations.get(self._current_anim)[0]

+

+            self.image = self._images[self._frame]

+            self._last_update = timePassed%self._delay

+        else:   

+            self._last_update = timePassed

+

+    def nextFrame(self):

+        self._frame += 1

+        if self._frame >= len(self._images):

+            framesPast = self._frame - len(self._images)

+            self._frame = framesPast

+

+        self.image = self._images[self._frame]

+

+    def nextCurrentAnimFrame(self):

+

+        for cnt in range(len(animations)):

+

+            if animations[cnt] == self._current_anim:

+                if self._frame < self.animations[self._current_anim][0] or self._frame > self.animations[self._current_anim][1]:

+                    self._frame = self.animations[self._current_anim][0]

+

+                else: self._frame += 1

+

+                if self._frame > self.animations[self._current_anim][1]:

+                    framesPast = self._frame - self.animations[self._current_anim][1]

+                    self._frame = framesPast - 1 + self.animations[self._current_anim][0]

+                  

+                self.image = self._images[self._frame]

diff --git a/devtools/Dave's Test Kit/FontDirtyTest.py b/devtools/Dave's Test Kit/FontDirtyTest.py
new file mode 100644
index 0000000..4a37bfa
--- /dev/null
+++ b/devtools/Dave's Test Kit/FontDirtyTest.py
@@ -0,0 +1,64 @@
+#! /usr/bin/env python

+import pygame

+from pygame.locals import *

+from time import time

+from Scene import Scene

+from DrawableObject import DrawableObject

+from DrawableFontObject import DrawableFontObject

+pygame.init()

+

+FRAME=500

+screenWidth = 600

+screenHeight = 400

+numImages = 1

+maxTrial = 5 # multiple trials, but hard coded in this test

+dirtyList=[]

+

+print "width,height",

+print screenWidth,

+print ",",

+print screenHeight

+

+screen = pygame.display.set_mode( [int(screenWidth),

+    int(screenHeight)] ) #Screen Set 600x400

+pygame.display.set_caption("Sprite Speed Test Window")

+GREEN = 0, 192, 0 # green

+background = pygame.image.load("Room.gif")

+screen.blit(background,[0,0])

+pygame.display.flip()

+start = time()

+

+for aTrial in range(maxTrial):

+    start = time()

+

+    font = pygame.font.SysFont("cmr10", 100)

+    d = DrawableFontObject("hello world", font)

+    d.goToAnim("anim1")

+    

+

+    group1=Scene(d)

+    groups=[group1]

+    print (time()-start) ,

+    print " -- Time to load"

+

+

+    clock = pygame.time.Clock()

+    clock.tick()

+    start = time()

+    for frame in range(FRAME):

+        dirtyList=[]

+        d.changeText(str(frame))

+        for image in range(numImages):

+            #move / collision detection

+            groups[image].update(clock.get_time())

+            clock.tick()

+            #individually blit each image group - add to list for update

+            dirtyList.extend(groups[image].draw(screen))

+

+        #draw the images flip/update

+        pygame.display.update(dirtyList)

+        for image in range(numImages):

+            groups[image].clear(screen, background)

+

+    #print 1/((time()-start)/FRAME)

+    pygame.display.flip()

diff --git a/devtools/Dave's Test Kit/Scene.py b/devtools/Dave's Test Kit/Scene.py
new file mode 100644
index 0000000..13827d3
--- /dev/null
+++ b/devtools/Dave's Test Kit/Scene.py
@@ -0,0 +1,202 @@
+import pygame

+from pygame.sprite import RenderUpdates

+

+class Scene(pygame.sprite.RenderUpdates):

+

+    def __init__(self, sprites):

+

+       self._spritelist = []

+       self._spritelist.append([sprites, sprites.getXPos(), sprites.getYPos()])

+       RenderUpdates.__init__(self, sprites)

+

+       self.xPos = 0

+       self.yPos = 0

+       self.xSize = 0

+       self.ySize = 0

+       

+       self.calcPosition()

+       self.calcSize()

+       self.setRelativePositions()

+

+    def calcPosition(self):

+    

+       lowestX = 9000

+       lowestY = 9000

+       

+       cnt = 0

+       while cnt < len(self._spritelist):

+           if self._spritelist[cnt][0].getXPos() < lowestX: lowestX = self._spritelist[cnt][0].getXPos()

+           if self._spritelist[cnt][0].getYPos() < lowestY: lowestY = self._spritelist[cnt][0].getYPos()

+           cnt += 1

+

+       self.xPos = lowestX

+       self.yPos = lowestY

+

+    def calcSize(self):

+    

+       highestX = 0

+       highestY = 0

+       

+       cnt = 0

+       while cnt < len(self._spritelist):

+           if (self._spritelist[cnt][0].getXPos() + self._spritelist[cnt][0].getXSize()) > highestX: highestX = self._spritelist[cnt][0].getXPos() + self._spritelist[cnt][0].getXSize()

+           if (self._spritelist[cnt][0].getYPos() + self._spritelist[cnt][0].getYSize()) > highestY: highestY = self._spritelist[cnt][0].getYPos() + self._spritelist[cnt][0].getYSize()

+           cnt += 1

+

+       self.xSize = highestX - self.xPos

+       self.ySize = highestY - self.yPos

+

+    def addObject(self, newDrawableObject):

+        RenderUpdates.add_internal(self, newDrawableObject)

+        self._spritelist.append([newDrawableObject, newDrawableObject.getXPos(), newDrawableObject.getYPos()])

+

+    def addObjects(self, newDrawableObjects):

+        for sprite in newDrawableObjects:

+           RenderUpdates.add_internal(self, sprite)

+           self._spritelist.append([sprite, sprite.getXPos(), sprite.getYPos()])

+

+    def setRelativePositions(self):

+

+       cnt = 0

+       while cnt < len(self._spritelist):

+           self._spritelist[cnt][1] = self._spritelist[cnt][0].getXPos() - self.xPos

+           self._spritelist[cnt][2] = self._spritelist[cnt][0].getYPos() - self.yPos

+           cnt += 1

+

+    def removeObject(self, sprite):

+

+       for i in self._spritelist:

+           if i[0] == sprite:

+               self._spritelist.remove(i)

+               break

+       RenderUpdates.remove_internal(self, sprite)

+

+    def getObject(self, index):

+

+       if index < len(self._spritelist):

+          return  self._spritelist[index][0]

+

+    def getListSize(self):

+

+       return len(self._spritelist)

+

+    def getList(self):

+

+       return list(self._spritelist)

+

+    def moveObjects(self):

+

+       cnt = 0

+       while cnt < len(self._spritelist):

+

+          self._spritelist[cnt][0].move()

+          cnt += 1

+

+       self.calcPosition()

+       self.calcSize()

+       self.setRelativePositions()

+

+    def moveScene(self, xNudge = 0, yNudge = 0):

+

+       cnt = 0

+       while cnt < len(self._spritelist):

+

+          self._spritelist[cnt][0].nudge(xNudge, yNudge)

+          cnt += 1

+

+       self.calcPosition()

+

+    def setPosition(self, newXPos = None, newYPos = None):

+

+       if newXPos != None: self.xPos = newXPos

+       if newYPos != None: self.yPos = newYPos

+

+       cnt = 0

+       while cnt < len(self._spritelist):

+

+          self._spritelist[cnt][0].setPosition(self.xPos + self._spritelist[cnt][1], self.yPos + self._spritelist[cnt][2])

+          cnt += 1

+

+    def getXPos(self):

+       return self.xPos

+

+    def getYPos(self):

+       return self.yPos

+

+    def getXSize(self):

+       return self.xSize

+

+    def getYSize(self):

+       return self.ySize

+

+    def scaleObjects(self, newXSize = None, newYSize = None):

+

+       cnt = 0

+       while cnt < len(self._spritelist):

+           self._spritelist[cnt][0].scale(newXSize, newYSize)

+           cnt += 1

+

+    def scaleScene(self, newXSize = None, newYSize = None):

+

+       self.calcPosition()

+       self.calcSize()

+

+       xScale = 1

+       yScale = 1

+

+       if newXSize != None: xScale = (newXSize * 1.0)/self.xSize

+       if newYSize != None: yScale = (newYSize * 1.0)/self.ySize

+

+       cnt = 0

+       while cnt < len(self._spritelist):

+           self._spritelist[cnt][0].scale(xScale * self._spritelist[cnt][0].getXSize(), yScale * self._spritelist[cnt][0].getYSize())

+           self._spritelist[cnt][1] = xScale * self._spritelist[cnt][1]

+           self._spritelist[cnt][2] = yScale * self._spritelist[cnt][2]

+           cnt += 1

+

+       self.calcPosition()

+       self.calcSize()

+       self.setPosition()

+

+    def update(self, t):

+    

+       for s in self._spritelist: s[0].update(t);

+

+    def draw(self, surface):

+       spritedict = self.spritedict

+       surface_blit = surface.blit

+       dirty = self.lostsprites

+       self.lostsprites = []

+       dirty_append = dirty.append

+       for s in self._spritelist:

+           r = spritedict[s[0]]

+           newrect = surface_blit(s[0].image, s[0].rect)

+           if r is 0:

+               dirty_append(newrect)

+           else:

+               if newrect.colliderect(r):

+                   dirty_append(newrect.union(r))

+               else:

+                   dirty_append(newrect)

+                   dirty_append(r)

+           spritedict[s[0]] = newrect

+       return dirty

+       

+    def drawEntireScene(self, surface):

+       spritedict = self.spritedict

+       surface_blit = surface.blit

+       dirty = self.lostsprites

+       self.lostsprites = []

+       dirty_append = dirty.append

+       for s in self._spritelist:

+           dirty_append(spritedict[s[0]])

+           dirty_append(surface_blit(s[0].image, s[0].rect))

+       return dirty

+

+    def nextFrame(self):

+

+       cnt = 0

+       while cnt < len(self._spritelist):

+

+          self._spritelist[cnt][0].nextFrame()

+          cnt += 1