~rick-rickspencer3/pygame-template/trunk

« back to all changes in this revision

Viewing changes to crashteroids/baseSprite.py

  • Committer: Rick Spencer
  • Date: 2010-03-07 00:17:48 UTC
  • Revision ID: rick.spencer@canonical.com-20100307001748-dh8grxsuakbu4cu1
lots of renaming of camelCase names, and indented and documented baseSprite.py

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
 
 
2
"""
 
3
base_sprite - contains BaseSprite class.
 
4
 
 
5
"""
 
6
 
1
7
import pygame
2
8
import crashteroidsconfig
3
9
 
4
10
class BaseSprite(pygame.sprite.Sprite):
5
 
 def __init__(self, spriteImage):
6
 
  #default to center of screen pointing strait up
7
 
  self.orientation = 0
8
 
  self.rotatingRight = False
9
 
  self.rotatingLeft = False
10
 
  self.velocityX = 0
11
 
  self.velocityY = 0
12
 
  self.accelerating = False
13
 
  self.x = 400
14
 
  self.y = 240
15
 
  self.maxVelocity = 50
16
 
  self.accelerationDivisor = 3 #accelerate at 1/3 speed
17
 
  self.rotationRate = 15 #makes 360/14 = 24 orientations
18
 
  
19
 
  pygame.sprite.Sprite.__init__(self)
20
 
  #load the image and shave a few pixels from the rect
21
 
  self.masterImage = pygame.image.load(spriteImage)
22
 
  self.image = self.masterImage
23
 
  self.rect = self.image.get_rect()
24
 
  self.rect.height -= 5
25
 
  self.rect.width -= 5
26
 
  self.updateImage()
27
 
  
28
 
 def startRotationRight(self):
29
 
  self.rotatingRight = True
30
 
 
31
 
 def startRotationLeft(self):
32
 
  self.rotatingLeft = True
33
 
  
34
 
 def stopRotationRight(self):
35
 
  self.rotatingRight = False
36
 
  
37
 
 def stopRotationLeft(self):
38
 
  self.rotatingLeft = False
39
 
 
40
 
 def accelerate(self):
41
 
  self.accelerating = True
42
 
  
43
 
 def stopAcceleration(self):
44
 
  self.accelerating = False
45
 
  
46
 
 def update(self):
47
 
  #update the orientation
48
 
  if self.rotatingLeft:
49
 
   self.orientation += self.rotationRate
50
 
   if self.orientation >= 360:
51
 
    self.orientation = 0 
52
 
 
53
 
  if self.rotatingRight:
54
 
   self.orientation -= self.rotationRate
55
 
   if self.orientation < 0:
56
 
    self.orientation = 345
57
 
  
58
 
  #change the image if rotating
59
 
  if self.rotatingLeft or self.rotatingRight:
60
 
   self.updateImage()
61
 
  
62
 
  #adjust the velocity based on orientation
63
 
  if self.accelerating:
64
 
   num = (24 - self.orientation/15) 
65
 
   if num == 24:
66
 
    num = 0
67
 
   if num < 7:
68
 
    self.velocityX += num
69
 
    self.velocityY -= 6 - num
70
 
   elif num < 13:
71
 
    self.velocityX += 12 - num
72
 
    self.velocityY += num - 6
73
 
   elif num < 19:
74
 
    self.velocityX -= num - 12
75
 
    self.velocityY += 18 - num
76
 
   elif num < 24:
77
 
    self.velocityX -= 24 - num
78
 
    self.velocityY -= num - 18
79
 
  
80
 
  #set the velocity is within bounds
81
 
  if self.velocityX > self.maxVelocity:
82
 
   self.velocityX = self.maxVelocity
83
 
  if self.velocityY > self.maxVelocity:
84
 
   self.velocityY = self.maxVelocity
85
 
  if self.velocityX < 0 - self.maxVelocity:
86
 
   self.velocityX = 0 - self.maxVelocity
87
 
  if self.velocityY < 0 - self.maxVelocity:
88
 
   self.velocityY = 0 - self.maxVelocity
89
 
   
90
 
  #adjust the location, raise accelrationDivisor to slow down
91
 
  self.x += self.velocityX/self.accelerationDivisor
92
 
  self.y += self.velocityY/self.accelerationDivisor
93
 
 
94
 
  #wrap the sprite around the screen, maintain "hyper zone"
95
 
  if self.x > 800:
96
 
   self.x = 0 - self.rect.height
97
 
  if self.y > 480:
98
 
   self.y = 0 - self.rect.width
99
 
   
100
 
  if self.x < 0 - self.rect.width:
101
 
   self.x = 800
102
 
  if self.y < 0 - self.rect.height:
103
 
   self.y = 480
104
 
  
105
 
  self.rect.topleft = [self.x,self.y]
106
 
  
107
 
 def updateImage(self):
108
 
  oldCenter = self.rect.center
109
 
  self.image = pygame.transform.rotate(self.masterImage,self.orientation)
110
 
  self.rect = self.image.get_rect()
111
 
  #make a buffer so sprites can appear closer together
112
 
  self.rect.width -= 20
113
 
  self.rect.height -= 20
114
 
  self.rect.center = oldCenter
115
 
 
116
 
 def explode(self):
117
 
  self.kill()#remove self from any spritegroups by default
 
11
    """
 
12
    BaseSprite - handles all common sprite data and functionality
 
13
    for sprites in crashteroids.
 
14
 
 
15
    """
 
16
 
 
17
    def __init__(self, sprite_image):
 
18
        """Creates a BaseSprite. Sets the sprite's initial screen
 
19
        position, so this should be called by subclasses before they
 
20
        make any changes positioning.
 
21
 
 
22
        arguments:
 
23
        sprite_image - path to image file to use for the sprite.
 
24
 
 
25
        """
 
26
 
 
27
        self.__init_position()
 
28
 
 
29
        #acceleration_divisor determines how fast a sprite
 
30
        #accelerates. The hight the divisor, the slower the
 
31
        #acceleration.
 
32
        self.acceleration_divisor = 3 #accelerate at 1/3 speed
 
33
 
 
34
        #rotation_rate determines how many degrees the sprite will
 
35
        #rotate witch each tick while rotating. 
 
36
        self.rotation_rate = 15 #makes 360/14 = 24 orientations
 
37
 
 
38
        pygame.sprite.Sprite.__init__(self)
 
39
  
 
40
        #load the image and shave a few pixels from the rect
 
41
        #maintain a master image to avoid image corruption due to
 
42
        #multiple transformations of an image
 
43
        self.master_image = pygame.image.load(sprite_image)
 
44
        self.image = self.master_image
 
45
        self.rect = self.image.get_rect()
 
46
 
 
47
        #make the rect for the sprite slightly smaller than the
 
48
        #sprite image to accomedate non-rectangular images
 
49
        self.rect.height -= 5
 
50
        self.rect.width -= 5
 
51
 
 
52
        self.update_image()
 
53
 
 
54
 
 
55
    def __init_position(self):
 
56
        """init_position - initializes values for positioning, and provides 
 
57
        a default position implemention, places the sprite in the center of
 
58
        the screen.
 
59
 
 
60
        """
 
61
 
 
62
        self.orientation = 0
 
63
        self._rotating_right = False
 
64
        self._rotating_left = False
 
65
        self.velocity_x = 0
 
66
        self.velocity_y = 0
 
67
        self._accelerating = False
 
68
        self.x = 400
 
69
        self.y = 240
 
70
        self.max_velocity = 50
 
71
  
 
72
  
 
73
    def start_rotation_right(self):
 
74
        """
 
75
        start_rotation_right - set sprite to rotate clockwise by
 
76
        degrees set in rotation_rate on each call to update().
 
77
 
 
78
        """
 
79
 
 
80
        self._rotating_right = True
 
81
 
 
82
    def start_rotation_left(self):
 
83
        """
 
84
        start_rotation_left - set sprite to rotate counter-clockwise by
 
85
        degrees set in rotation_rate on each call to update().
 
86
 
 
87
        """
 
88
        self._rotating_left = True
 
89
  
 
90
    def stop_rotating_right(self):
 
91
        """
 
92
        stop_rotating_right - set the sprite to stop rotating on each tick
 
93
 
 
94
        """
 
95
 
 
96
        self._rotating_right = False
 
97
  
 
98
    def stop_rotating_left(self):
 
99
        """
 
100
        stop_rotating_right - set the sprite to stop rotating on each tick
 
101
 
 
102
        """
 
103
 
 
104
        self._rotating_left = False
 
105
 
 
106
    def accelerate(self):
 
107
        """
 
108
        accelerate - set the sprite to accelerate up to the max_acceleration
 
109
        on each tick
 
110
 
 
111
        """
 
112
        self._accelerating = True
 
113
  
 
114
    def stop_acceleration(self):
 
115
        """
 
116
        accelerate - set the sprite to stop accelateration
 
117
        on each tick
 
118
 
 
119
        """
 
120
        self._accelerating = False
 
121
  
 
122
    def update(self):
 
123
        """update - update internal data and position
 
124
 
 
125
        """
 
126
        #update the orientation
 
127
        if self._rotating_left:
 
128
            self.orientation += self.rotation_rate
 
129
        if self.orientation >= 360:
 
130
            self.orientation = 0 
 
131
 
 
132
        if self._rotating_right:
 
133
            self.orientation -= self.rotation_rate
 
134
    
 
135
        if self.orientation < 0:
 
136
            self.orientation = 360 - self.rotation_rate
 
137
  
 
138
        #change the image if rotating
 
139
        if self._rotating_left or self._rotating_right:
 
140
            self.update_image()
 
141
  
 
142
        #adjust the velocity based on orientation
 
143
        up = 360/self.rotation_rate
 
144
        right = up/4
 
145
        down = up/2
 
146
        left = right * 3
 
147
        
 
148
        if self._accelerating:
 
149
            num = (up - self.orientation/self.rotation_rate) 
 
150
            if num == up:
 
151
                num = 0
 
152
            if num <= right:
 
153
                self.velocity_x += num
 
154
                self.velocity_y -= right - num
 
155
            elif num <= down:
 
156
                self.velocity_x += down - num
 
157
                self.velocity_y += num - right
 
158
            elif num <= left:
 
159
                self.velocity_x -= num - down
 
160
                self.velocity_y += left - num
 
161
            elif num < up:
 
162
                self.velocity_x -= up - num
 
163
                self.velocity_y -= num - left
 
164
  
 
165
        #set the velocity is within bounds
 
166
        if self.velocity_x > self.max_velocity:
 
167
            self.velocity_x = self.max_velocity
 
168
        if self.velocity_y > self.max_velocity:
 
169
            self.velocity_y = self.max_velocity
 
170
        if self.velocity_x < 0 - self.max_velocity:
 
171
            self.velocity_x = 0 - self.max_velocity
 
172
        if self.velocity_y < 0 - self.max_velocity:
 
173
            self.velocity_y = 0 - self.max_velocity
 
174
   
 
175
        #adjust the location, raise accelrationDivisor to slow down
 
176
        self.x += self.velocity_x/self.acceleration_divisor
 
177
        self.y += self.velocity_y/self.acceleration_divisor
 
178
 
 
179
        #wrap the sprite around the screen, maintain "hyper zone"
 
180
        if self.x > 800:
 
181
            self.x = 0 - self.rect.height
 
182
        if self.y > 480:
 
183
            self.y = 0 - self.rect.width
 
184
   
 
185
        if self.x < 0 - self.rect.width:
 
186
            self.x = 800
 
187
        if self.y < 0 - self.rect.height:
 
188
            self.y = 480
 
189
  
 
190
        self.rect.topleft = [self.x,self.y]
 
191
  
 
192
    def update_image(self):
 
193
        oldCenter = self.rect.center
 
194
        self.image = pygame.transform.rotate(self.master_image,self.orientation)
 
195
        self.rect = self.image.get_rect()
 
196
        #make a buffer so sprites can appear closer together
 
197
        self.rect.width -= 5
 
198
        self.rect.height -= 5
 
199
        self.rect.center = oldCenter
 
200
 
 
201
    def explode(self):
 
202
        self.kill()#remove self from any spritegroups by default