Changeset 36:1a0bddee3c54

Timestamp:

12/20/10 18:43:18 (5 years ago)

Author:

Olga Zolotareva <olya_zol@?>

Branch:

new

Parents:

34:b7a85caedc7f (diff), 35:dfdc1def5d24 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Automated merge with ?ssh://kodomo.fbb.msu.ru/tanchiki

Files:

• body.py (modified) (2 diffs, 1 prop)
• game.py (modified) (2 diffs, 1 prop)
• user.py (modified) (1 diff)
• vector.py (modified) (4 diffs, 1 prop)

body.py

@@ -1 +1 @@
 import vector
 import math
-delta_phi = math.pi   # deltha phi = math.pi
+import random
+
+base_angle = math.pi/32   # deltha phi = math.pi/32
+turret_angle = math.pi/32
 speed_delta = 1
 delta_t = 1
-max_velocity = 2
+max_velocity = 4
+max_base_angle = 1
+max_turret_angle = 1
 initial_strength = 1
+bullet_velocity = 10
+width = 100
+height = 100
 
 class Body(object):
@@ -11 +19 @@
                 self.position = position
                 self.velocity = velocity
-                self.radius = radius
 
 class Tank(Body):
-        radius = 1
-        def __init__(self, position, user):
+        radius = 5
+        def __init__(self, position, user, game):
                 Body.__init__(self, position)
+                self.game = game
+                self.turret = vector.i
                 self.strength = 0
-                self.turret = vector.i
                 self.base_orientation = 1       # 1 or -1
                 self.user = user
-                user.tank = self # äîáàâëÿåò ñåáÿ â User
+                user.tank = self 
 
-        def rotate_base(tank, angle): 
-                self.velocity.phi += angle
+
+        def rotate_base(tank, angle):
+                if abs(angle) < max_base_angle:  
+                        self.velocity.phi += angle
+                else:
+                        self.velocity.phi += max_base_angle
 
         def rotate_turret(self, angle):
-                self.turret.phi += angle
+                if abs(angle) < max_base_angle:  
+                        self.turret.phi += angle
+                else:
+                        self.turret.phi += max_turret_angle
+
 
         def accelerate(self, speed_delta):
-                self.velocity.rho += speed_delta * delta_t
-                if self.velocity.rho > max_velocity :
+                self.velocity += self.velocity.normalize() * speed_delta * delta_t
+                print self.velocity.rho
+                if self.velocity.rho > max_velocity:
                         self.velocity.rho = max_velocity
 
         def fire(self):
-                pass
+                bullet_position = self.position + self.turret * (self.radius + 0.1)
+                bullet_velocity = self.turret.normalize() * self.game.bullet_speed
+                bullet = Bullet(bullet_position, bullet_velocity, self)
+                self.game.bodies.append(bullet)
 
         def on_tick(self,other_tanks, bullets):
-                if self.user.base_left == True :
-                        self.rotate_base(delta_phi)
-                if self.user.base_right == True :
-                        self.rotate_base(-1*delta_phi)
-                if self.user.accelerate == True :
+                if self.user.base_left == True:
+                        self.rotate_base(base_angle)
+                if self.user.base_right == True:
+                        self.rotate_base(-1*base_angle)
+                if self.user.accelerate == True:
                         self.accelerate(speed_delta)
+                if self.user.decelerate == True:
+                        self.accelerate(-1*speed_delta)
+                if self.user.turret_left == True:
+                        self.rotate_turret(turret_angle)
+                if self.user.turret_right == True:
+                        self.rotate_turret(-1*turret_angle)
+                if self.user.fire == True:
+                        self.fire()
 
         def on_spawn(self):
                 pass
 
-        def on_death(self):
+        def on_death(self) :
+                pass
+        
+        def on_hit(self, bullet):
                 pass
 
-        def on_hit(self,bullet):
-                pass
-
-        def on_collision(self):
+        def on_collision(self, other):
                 pass
 
         def on_wall(self):
-                pass
+                self.next_position = self.position
 
 class Bullet(Body):
         radius = 0.1
-        pass
+        def __init__(self, position, velocity, tank):
+                Body.__init__(self, position, velocity = bullet_velocity)
+                self.tank = tank

game.py

@@ -š +1 @@
+import vector
+import body
+import time
+
 other_tanks = []
 bullets = []
@@ -7 +11 @@
                 self.users = users
                 self.width = width
-                self.height = height
+                self.height = height     
 
-        def step(game):
-                game.next_positions()
-                game.check_collisions()
-                game.check_walls()
-                game.update_positions()
-                game.invoke_ticks()
-                game.respawn()
+        def step(self):
+                for i in self.bodies:           #test
+                        print "begin", i, i.position
+                self.next_positions()
+                self.check_collisions()
+                self.check_walls()
+                self.update_positions()
+                self.invoke_ticks()
+                self.respawn()
 
-        def next_positions(game):
+                for i in self.bodies:           #test
+                        print "end", i, i.position      #test
+        #       time.sleep(1)                   #test
+        #       self.step()                     #test
+                
+
+        def next_positions(self):
                 delta_t = 1
-                for i in game.bodies :
+                for i in self.bodies:
                         i.next_position = i.position + i.velocity*(delta_t)
+        
 
-        def check_collisions(game):
-                pass
+        def check_collisions(self):
+                for i in self.bodies:
+                        for j in self.bodies:
+                                if self.collides(i,j) == True :
+                                        self.handle_collision(i,j)                      
 
         def collides(self,body1,body2):
-                pass
+                print body1, body2
+                if (abs(body1.next_position - body2.next_position) <= (body1.radius + body2.radius)):
+                        print 'collision'
+                        print body1.position , body2.position 
+                        if (body1 != body2):
+                                return True
+                        else :
+                                return False
+                else :
+                        return False
 
         def handle_collision(self,body1,body2):
-                pass
+                if isinstance(body1, body.Tank) == True : 
+                        if isinstance(body2, body.Tank) == True :
+                                body1.on_collision(body2)
+                        else :
+                                body1.on_hit()
+                                body1.on_death()
+                else :
+                        if isinstance(body2, body.Tank) == True :
+                                body2.on_hit()
+                                body2.on_death()
 
-        def check_walls(game):
-                for i in game.bodies :
-                        if ((i.next_position.x - i.radius) <= 0) or ((i.next_position.y - i.radius) <= 0) or ((i.next_position.x + i.radius) >= game.width) or ((i.next_position.y + i.radius) >= game.height) :
+        def check_walls(self):
+                for i in self.bodies :
+                        if ((i.next_position.x - i.radius) <= 0) or ((i.next_position.y - i.radius) <= 0) or ((i.next_position.x + i.radius) >= self.width) or ((i.next_position.y + i.radius) >= self.height) :
                                 i.on_wall()
+                                print 'wall'      #test
 
-        def update_positions(game):
-                for i in game.bodies :
+        def update_positions(self):
+                for i in self.bodies:
                         i.position = i.next_position
 
-        def invoke_ticks(game):
-                for i in game.users :
-                        i.tank.on_tick(other_tanks,bullets)
-        
-        def respawn(game):
-                for i in game.users :
+        def invoke_ticks(self):
+                for i in self.bodies :
+                        if isinstance(i, body.Tank) :
+                                i.on_tick([], [])
+
+
+        def respawn(self):                     
+                for i in self.users :
                         if i.tank.strength == 0 :
                                 i.tank.on_spawn()
-                                i.tank.strength = 1 
+                                i.tank.strength = 1
+                                i.tank.velocity = vector.null
+                                i.tank.position.x = random.randint(self.radius , width - self.radius)
+                                i.tank.position.y = random.randint(self.radius , height - self.radius)
+                                i.tank.velocity = vector.null 
+
+ 

user.py

@@ -1 +1 @@
 class User(object):     
 
-        def __init__(self, base_left = False, base_right = False,
-                           turret_left = False, turret_right = False,
-                           accelerate = False, decelerate = False,
-                           fire = False, tank = 0):
+        def __init__(self, base_left = False , base_right = False, turret_left = False, turret_right = False, accelerate = False, decelerate = False, fire = False, tank = 0):
                 self.base_left = base_left
                 self.base_right = base_right

vector.py

@@ -1 +1 @@
 import math
 
-class Vector(object):
+class Vector(object):   
 
-        def __init__(self, x=0 , y=0):
+        def __init__(self, x=0 , y=0):         
                 self.x = x
                 self.y = y
-
+        
         def __add__(self, other):
                 result = Vector(0,0)
                 result.x = self.x + other.x
                 result.y = self.y + other.y
+                return result
+
+        def __sub__(self, other):
+                result = Vector(0,0)
+                result.x = self.x - other.x
+                result.y = self.y - other.y
                 return result
 
@@ -20 +26 @@
 
         def dot_product(self, other):
-                return self.x*other.x + self.y*other.y
+                return  self.x*other.x + self.y*other.y 
 
         def __abs__(self):
@@ -34 +40 @@
                         return 0
 
+        def normalize(self):
+                result = Vector()
+                result.x = self.x
+                result.y = self.y
+                result.rho = 1
+                return result
+
         def get_rho(self):
                 return abs(self)
 
         def set_rho(self, new_rho):
-                if self.is_null() == 1 :
+                if self.is_null() == 1:
                         self.x , self.y = new_rho*math.cos(self.phi) , new_rho*math.sin(self.phi)
                 else :
@@ -49 +62 @@
                 if self.is_null == 1:
                         phi = 0
-                return phi
+                return  phi
 
         def set_phi(self, new_phi):
                 rho = abs(self)
-                self.x, self.y = rho*math.cos(new_phi) , rho*math.sin(new_phi)
+                self.x , self.y = rho*math.cos(new_phi) , rho*math.sin(new_phi)
 
         phi = property(get_phi, set_phi)
+                
+i = Vector(1,0)
+j = Vector(0,1)
+null = Vector(0,0)