[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[pygame] Python optimization help



I'm trying to speed up this program as much as possible. Anyone able to
help?


import pygame
import random

import multiprocessing
import time
import math

width = 1000
height = 800

x = 0


class Consumer(multiprocessing.Process):
    
    def __init__(self, task_queue, result_queue):
        multiprocessing.Process.__init__(self)
        self.task_queue = task_queue
        self.result_queue = result_queue

    def run(self):
        proc_name = self.name
        while True:
            next_task = self.task_queue.get()
            if next_task is None:
                # Poison pill means we should exit
                print '%s: Exiting' % proc_name
                break
            #print '%s: %s' % (proc_name, next_task)
            answer = next_task[0](*next_task[1])
            self.result_queue.put(answer)
        return


class Task(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def __call__(self):
        time.sleep(0.1) # pretend to take some time to do our work
        return '%s * %s = %s' % (self.a, self.b, self.a * self.b)
    def __str__(self):
        return '%s * %s' % (self.a, self.b)


    
def end():
    for i in xrange(num_consumers):
        tasks.put(None)


def attract2(itemlist):             ## primary functin
    gravitar = itemlist[1]
    itemlist = itemlist[0]
    exc = 0
    for i in itemlist:
        if i.id != gravitar.id:
            if gravitar.mass > i.mass:
                greatermass = gravitar.mass
            else:
                greatermass = i.mass
            xdiff = gravitar.x - i.x  
            ydiff = gravitar.y - i.y
            dist = math.sqrt((xdiff**2)+(ydiff**2))
            if dist < greatermass:
                dist = greatermass
                
                
            #landmark
            acceleration = ((2*(i.mass*gravitar.mass))/(dist**2)) / gravitar.mass
            
            xc = xdiff/dist
            yc = ydiff/dist
            gravitar.dx -= acceleration * xc
            gravitar.dy -= acceleration * yc
        else:
            exc += 1
    if exc > 1:
        #print "Exc is" + str(exc)
        pass
        #raise ValueError, exc
    gravitar.x += gravitar.dx
    gravitar.y += gravitar.dy
    if gravitar.x > width or gravitar.x < 0:
        gravitar.dx *= -1
    if gravitar.y > height or gravitar.y < 0:
        gravitar.dy *= -1
    gravitar.dx *= .999
    gravitar.dy *= .999
    return gravitar
    
    
    
def attract(itemlist):      ### secondary function
    gravitar = itemlist[1]
    itemlist = itemlist[0]
    exc = 0
    for i in itemlist:
        if i.id != gravitar.id:
            if gravitar.mass > i.mass:
                greatermass = gravitar.mass
            else:
                greatermass = i.mass
            greatermass **=2
            xdiff = gravitar.x - i.x  
            ydiff = gravitar.y - i.y
            dist = (xdiff**2)+(ydiff**2)
            if dist < greatermass:
                dist = greatermass
                
                
            #landmark
            acceleration = ((2*(i.mass*gravitar.mass))/(dist)) / gravitar.mass
            
            xc = xdiff/dist
            yc = ydiff/dist
            gravitar.dx -= acceleration * xc
            gravitar.dy -= acceleration * yc
        else:
            exc += 1
    if exc > 1:
        #print "Exc is" + str(exc)
        pass
        #raise ValueError, exc
    gravitar.x += gravitar.dx
    gravitar.y += gravitar.dy
    if gravitar.x > width or gravitar.x < 0:
        gravitar.dx *= -1
    if gravitar.y > height or gravitar.y < 0:
        gravitar.dy *= -1
    gravitar.dx *= .999
    gravitar.dy *= .999
    return gravitar


class Gravitar(object):
    def __init__(self, id):
        self.id = id
        self.x = random.random()*width
        self.y = random.random()*height
        self.dx = 0
        self.dy = 0
        self.mass = random.randint(4,8)

def genlist():
    n = []
    global x
    for i in xrange( 2):
        n.append(Gravitar(i))
        x += 1
    
    return n

if __name__ == '__main__':
    
    pygame.init()
    screen = pygame.display.set_mode((width, height))
    
    
    # Establish communication queues
    
    
    pool = multiprocessing.Pool(processes = 12)
    
    # Enqueue jobs
    
    
    # Add a poison pill for each consumer
    result = genlist()
    lastx = x
    # Start printing results
    while True:
        ## blit all here
        if x != lastx:
            print x
            lastx = x
           
        
        screen.fill((0,0,0))
        #print result
        for item in result:
            pygame.draw.circle(screen, (255,255,255), ( int(item.x), int(item.y)), int(item.mass))
        pygame.display.update()
        for event in pygame.event.get():
            if event.type == pygame.KEYDOWN:
                x += 1 
                result.append(Gravitar(x))
                
        
        #print "Mapping..."
        result = [[result,i] for i in result]
        res = pool.map_async(attract, result)
        result = []
        #print "Calculating frame"
        #print res
        result = res.get()
        #print result