Conflicting merge - edited and corrected

Merge branch 'animationrework' of ssh://jtmengel@git.fedorahosted.org/git/fortune_hunter into animationrework

Conflicts:
	devtools/CompleteTestKit/DynamicDrawableObject.py

4 files changed, 103 insertions, 198 deletions

diff --git a/devtools/CompleteTestKit/DrawableFontObject.py b/devtools/CompleteTestKit/DrawableFontObject.py
index f06e514..56783f1 100644
--- a/devtools/CompleteTestKit/DrawableFontObject.py
+++ b/devtools/CompleteTestKit/DrawableFontObject.py
@@ -7,7 +7,7 @@ class DrawableFontObject(DrawableObject, pygame.sprite.Sprite):
 

         self.font = font

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

-        #self._image = self.textImage

+

         DrawableObject.__init__(self, [self.textImage], '', fps, x, y, xVelocity, yVelocity)

 

     def changeText(self, newText):

diff --git a/devtools/CompleteTestKit/DrawableObject.py b/devtools/CompleteTestKit/DrawableObject.py
index 0fd430c..fca2d02 100644
--- a/devtools/CompleteTestKit/DrawableObject.py
+++ b/devtools/CompleteTestKit/DrawableObject.py
@@ -1,57 +1,26 @@
 import pygame

 

 class DrawableObject(pygame.sprite.Sprite):

-
-# I removed the parameter for FPS, x and y velocities, and the text file reference
-#  since this is not a dynamic object
-

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

-        pygame.sprite.Sprite.__init__(self)
-        
-        #
-        #   My question is why do drawable objects take the form of a List?
-        #   it seems that every object takes lists, but then why encapsulate?
-        #   I believe that we can collapse these objects
-        #   JT Jul 2010
-

-#self._originals = images

-#self._images = images
-

-        self._images = []
-        self._origImages = []
-        
-#        
-#   Made the below while loop more efficient and quicker
-#   JT Jul 28 2010

+

+    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]

-#
-#   This went away since it was relient on FPS which DO's don't have
-"""        self._delay = 1000 / fps     """
-#   JT Jul 28 2010

-        
-        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.xSpeed = xVelocity

-        self.ySpeed = yVelocity

         self.myAngle = 0

-        self.xSize = 40     # <--

-        self.ySize = 40     # <-- 

+        self.xSize = images[0].get_width()

+        self.ySize = images[0].get_width()

         self.rect.topleft = (x,y)

-#
-#   Since there will be no animation in a static object I removed the code that
-#   read the animFile since it was an unecessary slowdown
-#
-        """

+        

         if textfileName != '':

 

            f = open(textfileName, 'r')

@@ -61,37 +30,37 @@ class DrawableObject(pygame.sprite.Sprite):
              animValues = currentLine.split(",")

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

              currentLine = f.readline()

-        """

 

     def addImages(self, images):

-        self._images.extend(images)

-        #self._originals.extend(images)

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

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

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

 

     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]
-         
-#
-#   Again I took out default values because I don't want the primary function
-#   of the method to be effectively overridable and have a method that can
-#   do nothing without raising flags
-#   I also conformed the parameter naming convention so that it conforms with the
-#   other methods' naming convention in this object
+         self.image = self._images[self._frame]

+         

+#

+#   Again I took out default values because I don't want the primary function

+#   of the method to be effectively overridable and have a method that can

+#   do nothing without raising flags

+#   I also conformed the parameter naming convention so that it conforms with the

+#   other methods' naming convention in this object

 #   JT Jul 28 2010

     def nudge(self, x, y):

         self.xPos += x

         self.yPos += y

         self.rect.right += x

         self.rect.top += y

-
-#
-#   reworked the loop for efficiency and the if statement logic
+

+#

+#   reworked the loop for efficiency and the if statement logic

 #   JT Jul 28 2010

-    def scale(self, x=None, y=None):
-        if type(x).__name__=='int': self.xSize = x
-        if type(y).__name__=='int': self.ySize = 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))

@@ -102,9 +71,9 @@ class DrawableObject(pygame.sprite.Sprite):
 

     def getYSize(self):

        return self.ySize

-
-#
-#   I changed rotate to utilize a for instead of a counter/while loop for speed
+

+#

+#   I changed rotate to utilize a for instead of a counter/while loop for speed

 #   JT - Jul 28 2010

     def rotate(self,angle):

         self.myAngle += angle

@@ -113,15 +82,15 @@ class DrawableObject(pygame.sprite.Sprite):
 

     def getRotation(self):

        return self.myAngle

-
-#
-#   I don't recommend forcing people to keep images within the screen
-#   a common trick in bullet hells is to temporarily move image objects off-
-#   screen when they die so the game isn't constantly loading a new instance of
-#   a common enemy
+

+#

+#   I don't recommend forcing people to keep images within the screen

+#   a common trick in bullet hells is to temporarily move image objects off-

+#   screen when they die so the game isn't constantly loading a new instance of

+#   a common enemy

 #   JT - Jul 28 2010

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

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

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

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

 

@@ -130,9 +99,9 @@ class DrawableObject(pygame.sprite.Sprite):
 

     def getYPos(self):

        return self.yPos

-
-#
-#   Added defaul values in case someone wants their color key to be taken from bot.right corner, eg
+

+#

+#   Added defaul values in case someone wants their color key to be taken from bot.right corner, eg

 #   JT Jul 28 2010

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

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

@@ -141,68 +110,14 @@ class DrawableObject(pygame.sprite.Sprite):
     def setColorKey(self, aColor):

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

           self._images[i].set_colorkey(aColor)

-#
-#   Set default value to allow the method to be called empty (since t does nothing atm)
+#

+#   Set default value to allow the method to be called empty (since t does nothing atm)

 #   JT Jul 28 2010

     def update(self, t=None):

        pass

-
-#
-#   removed current animation method
-#

+       

     def nextFrame(self):

        pass

 

     def nextCurrentAnimFrame(self):

-       pass
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-   
-#
-#   Removed this because it took into account the depreciated velocity concept that was
-#   contrary to the projected use of the drawable object
-#   This would be more useful in a Dynamic Drawable Object
-#   JT Jul 28 2010
-"""

-    def move(self):

-        self.xPos += self.xSpeed

-        self.yPos += self.ySpeed

-        self.rect.right += self.xSpeed

-        self.rect.top += self.ySpeed

-"""
-
-#
-#   I removed velocity because a static object should not have variables pertaining to movement
-#   That is not instructed manually; velocity, being displacement over time, is easily perceived
-#   as an exaple of autonomous motion since it's dictated by the passage of time
-#   JT Jul 28 2010
-"""

-    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

-"""
+       pass
\ No newline at end of file
diff --git a/devtools/CompleteTestKit/DynamicDrawableObject.py b/devtools/CompleteTestKit/DynamicDrawableObject.py
index b7fe90f..8705fa7 100644
--- a/devtools/CompleteTestKit/DynamicDrawableObject.py
+++ b/devtools/CompleteTestKit/DynamicDrawableObject.py
@@ -1,72 +1,58 @@
-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):
-
-        DrawableObject.__init__(self, images, textfileName, fps, x, y, xVelocity, yVelocity)
-    def addImages(self, images):
+import pygame

+from DrawableObject import DrawableObject

 

-        self._images.extend(images)

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

+

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

 

-# def update(self, t):

-# 

-#         timePassed = t + self._last_update

-#         if timePassed > self._delay:

-# 

-#             self._frame += timePassed/self._delay

-#             while self._frame >= len(self._images):

-# 

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

-#               self._frame = framesPast - 1

-# 

-#             self.image = self._images[self._frame]

-#             self._last_update = timePassed%self._delay

-#         self._last_update = timePassed

-

-    def updateWithMovement(self, right, bottom): # causes objects to move and collide with walls

-

-# If we're at the top or bottom of the screen, switch directions.

-        if (self.yPos + self.ySize) >= bottom or self.yPos < 0: 
-            self.ySpeed = self.ySpeed * -1

-        if (self.yPos + self.ySize) >= bottom and self.ySpeed > 0: 
-            self.ySpeed = self.ySpeed * -1

-        if self.yPos < 0 and self.ySpeed < 0: 
-            self.ySpeed = self.ySpeed * -1

-
-#2345678911234567892123456789312345678941234567895123456789612345678971234567898
-

-# If we're at the right or left of the screen, switch directions.

-        if (self.xPos + self.xSize) >= right or self.xPos < 0:
-            self.xSpeed = self.xSpeed * -1

-        if (self.xPos + self.xSize) >= right and self.xSpeed > 0:
-             self.xSpeed = self.xSpeed * -1

-        if self.xPos < 0 and self.xSpeed < 0:
-            self.xSpeed = self.xSpeed * -1

- 

-        self.move()

-

-        if self._frame < len(self._images) - 1:

-            self._frame += 1

+        if fps > 0:

+            self._delay = 1000 / fps

         else:

-            self._frame = 0

-           

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

+            self._delay = 1000

+

+        self.xSpeed = xVelocity

+        self.ySpeed = yVelocity

+        

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

+        self._last_update = 0

+        self._frame = 0

+        self.animations = {}

+        self._current_anim = ""

+

+        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): # just updates the frame / object

-        ##print "Last update:", self._last_update,

-#getting the time since the last time I updated my frame and adding it to the time that I last updated my frame
+

         timePassed = t + self._last_update

-        ##print " Time since:", timePassed,
-
-#checking if I am in the animation and putting me there if I am not

+

         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

-            ##print " On frame:", self._frame,"\n"

 

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

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

@@ -77,7 +63,7 @@ class DynamicDrawableObject(DrawableObject, pygame.sprite.Sprite):
         else:   

             self._last_update = timePassed

 

-    def nextFrame(self): # push to next frame

+    def nextFrame(self):

         self._frame += 1

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

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

@@ -85,14 +71,14 @@ class DynamicDrawableObject(DrawableObject, pygame.sprite.Sprite):
 

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

 

-    def nextCurrentAnimFrame(self): # push to the next frame of curr animation

-
+    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]:

@@ -100,5 +86,3 @@ class DynamicDrawableObject(DrawableObject, pygame.sprite.Sprite):
                     self._frame = framesPast - 1 + self.animations[self._current_anim][0]

                   

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

-              

-#                cnt = len(anmiations)  <-- why was this here?
diff --git a/devtools/CompleteTestKit/Scene.py b/devtools/CompleteTestKit/Scene.py
index 9727177..320246b 100644
--- a/devtools/CompleteTestKit/Scene.py
+++ b/devtools/CompleteTestKit/Scene.py
@@ -13,7 +13,7 @@ class Scene(pygame.sprite.RenderUpdates):
        self.yPos = 0

        self.xSize = 0

        self.ySize = 0

-       

+

        self.calcPosition()

        self.calcSize()

        self.setRelativePositions()

@@ -46,6 +46,11 @@ class Scene(pygame.sprite.RenderUpdates):
        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)

@@ -61,7 +66,8 @@ class Scene(pygame.sprite.RenderUpdates):
 

     def removeObject(self, sprite):

        RenderUpdates.remove_internal(self, sprite)

-       self._spritelist.remove(sprite)

+       #self._spritelist.remove(sprite)

+

 

     def getObject(self, index):