Changes in [20:ee776b889df7:30:1b117f1451bd]

Location:

tanchiki

Files:

• body.py (modified) (1 diff)
• controller.py (added)
• game.py (modified) (1 diff)
• ui.py (modified) (1 diff)
• user.py (deleted)
• user_controller.py (added)
• vector.py (modified) (4 diffs)

tanchiki/body.py

@@ -š +1 @@
+#coding:utf-8
+
 import vector
 import math
-delta_phi = math.pi   # deltha phi = math.pi
-speed_delta = 1
-delta_t = 1
-max_velocity = 2
-initial_strength = 1
 
 class Body(object):
-        def __init__(self, position, velocity = vector.null):
+        def __init__(self, game, position, velocity = vector.Vector.null):
+                self.game = game
                 self.position = position
                 self.velocity = velocity
-                self.radius = radius
 
 class Tank(Body):
         radius = 1
-        def __init__(self, position, user):
-                Body.__init__(self, position)
+        model = "tank"
+
+        def __init__(self, game, position, controller):
+                Body.__init__(self, game, position)
+                self.controller = controller
+                self.turret = vector.Vector()
                 self.strength = 0
-                self.turret = vector.i
-                self.base_orientation = 1       # 1 or -1
-                self.user = user
-                user.tank = self # äīįąāė’åņ ńåį’ ā User
 
         def rotate_base(tank, angle): 
-                self.velocity.phi += angle
+                if abs(angle) < self.game.max_base_delta :
+                        self.velocity.phi += angle
+                else :
+                        self.velocity.phi += self.game.max_base_delta
 
         def rotate_turret(self, angle):
-                self.turret.phi += angle
+                if abs(angle) < self.game.max_base_delta :
+                        self.turret.phi += angle
+                else :
+                        self.turret.phi += self.game.max_turret_delta
 
         def accelerate(self, speed_delta):
-                self.velocity.rho += speed_delta * delta_t
+                self.velocity += self.velocity.normalize() * speed_delta
                 if self.velocity.rho > max_velocity :
                         self.velocity.rho = max_velocity
 
         def fire(self):
-                pass
-
-        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 :
-                        self.accelerate(speed_delta)
-
-        def on_spawn(self):
-                pass
-
-        def on_death(self):
-                pass
-
-        def on_hit(self,bullet):
-                pass
-
-        def on_collision(self):
-                pass
-
-        def on_wall(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)
 
 class Bullet(Body):
         radius = 0.1
-        pass
+        model = "bullet"
+
+        def __init__(self, position, velocity, tank):
+                Body.__init__(self, position, velocity)
+                self.origin = origin

tanchiki/game.py

@@ -24 +24 @@
 
         def __collides(self, body1, body2):
-                pass
+                return (abs(body1.position - body2.position) <= (body1.radius + body2.radius)) \
+                       and (body1 != body2)
 
         def __handle_collision(self, body1, body2):
-                pass
+                if isinstance(body1, body.Tank) == True : 
+                        if isinstance(body2, body.Tank) == True :
+                                body1.on_collision(body2)
+                                body2.on_collision(body1)
+                        else :
+                                body1.on_hit()
+                                body1.on_death()
+                else :
+                        if isinstance(body2, body.Tank) == True :
+                                body2.on_hit()
+                                body2.on_death()
 
         def __check_collisions(game):
-                pass
+                for i in range(len(self.bodies)) :
+                        for j in range(i, len(self.bodies)) :
+                                a, b = self.bodies[i], self.bodies[j]
+                                if self.collides(a, b) == True :
+                                        self.handle_collision(a, b)
 
-        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) <= -game.width/2) or \
+                           ((i.next_position.y - i.radius) <= -game.width/2) or \
+                           ((i.next_position.x + i.radius) >= game.width/2) or \
+                           ((i.next_position.y + i.radius) >= game.height/2) :
                                 i.on_wall()
-
-        def __update_positions(self):
-                for i in self.bodies :
-                        i.position = i.next_position
 
         def __invoke_ticks(self):
                 for i in self.bodies :
-                        if i.controller
+                        if i.controller :
                                 i.controller.on_tick(other_tanks, bullets)

tanchiki/ui.py

@@ -1 +š @@
-import game
+import math
+
+from OpenGL.GLUT import *
+from OpenGL.GLU import *
+from OpenGL.GL import *
+
+from body import *
+from vector import *
+from game import *
+import game as game_module
+
+glutInit()
+glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
+
+class GLWindow(object):
+        def __init__(self, game, tank):
+                self.game, self.tank = game, tank
+
+                window = glutCreateWindow('hello')
+
+                circle = glGenLists(1)
+                glNewList(circle, GL_COMPILE)
+                glPolygonMode(GL_FRONT, GL_LINE)
+                glBegin(GL_POLYGON)
+                for i in range(100) :
+                        glVertex2f(math.cos(i*2*math.pi/100.0), math.sin(i*2*math.pi/100.0))
+                glEnd()
+                glEndList(circle)
+
+                def display():
+                        glutSetWindow(window)
+                        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+                        glLoadIdentity()
+                        glScalef(1/game.width, 1/game.height, 0)
+
+                        for body in game.bodies :
+                                glPushMatrix()
+                                #glTranslatef(body.position.x, body.position.y, 0)
+
+                                #glScalef(body.radius, body.radius, 0)
+                                if body is tank :
+                                        glColor3f(255, 255, 0)
+                                elif body.__class__ is Tank :
+                                        glColor3f(0, 255, 0)
+                                elif body.__class__ is Tank :
+                                        glColor3f(255, 0, 0)
+
+                                glCallList(circle)
+                                glPopMatrix()
+
+                        glutSwapBuffers()
+
+                glutDisplayFunc(display)
 
 class Ui(object):
         def __init__(self):
-                pass
+                bodies = [ Tank(Vector.null, None) ]
+                self.game = Game(100, 100, bodies)
+                self.window = GLWindow(self.game, bodies[0])
+
+        def loop(self):
+                glutMainLoop()
+
+ui = Ui()
+ui.loop()

tanchiki/vector.py

@@ -2 +2 @@
 
 class Vector(object):
-
         def __init__(self, x=0 , y=0):
                 self.x = x
                 self.y = y
-
+        
         def __add__(self, other):
-                result = Vector(0,0)
+                result = Vector(0, 0)
                 result.x = self.x + other.x
                 result.y = self.y + other.y
@@ -20 +19 @@
 
         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 +33 @@
                         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 :
                         self.x , self.y = self.x*(new_rho/abs(self)) , self.y*(new_rho/abs(self))
 
-        rho = property(get_rho, set_rho) 
+        rho = property(get_rho, set_rho)
 
         def get_phi(self):
@@ -49 +55 @@
                 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)
+
+Vector.null = Vector(0, 0)