from Level import *
from Util import *


class World:
    """ A python singleton """

    class __impl:
        """ Implementation of the singleton interface """

        def __init__(self):
            self.actorList = []
            self.gameStarted = 0
            self.gameTime = 0
            self.gameTutActorSpawned = 0
            self.nextSpawnTime = 0       
            
            # goal rectangles
            self.goal1 = Rect((0,140),(75,170))
            self.goal2 = Rect((680,140),(75,170))
            
            # spawn arena
            self.spawnArena = Rect((190,30),(410,380))

            self.points = 0 #should really be in Player.. but oh well
            self.hiscore = 0
            
            self.allsprites = pygame.sprite.RenderPlain(self.actorList)
            
            #load prize sound
            self.prize = load_sound("a_prizeDing.wav")
            self.prize.set_volume(0.5)
            
            #self.leftPrize = load_sound("a_prizeDingLeft.wav")
            #self.rightPrize = load_sound("a_prizeDingRight.wav")
            #self.leftPrize.set_volume(0.5)
            #self.rightPrize.set_volume(0.5)

            self.footsteps= []
            self.footsteps.append(load_sound("1_Footsteps1.wav"))
            self.footsteps.append(load_sound("1_Footsteps2.wav"))
            self.footsteps.append(load_sound("1_Footsteps3.wav"))
            self.footsteps.append(load_sound("1_Footsteps4.wav"))
            self.currentsnd = -1
            
            self.tutorialSound = load_sound("a_introMusic.wav")
            self.fightSound  = load_sound("a_fight.wav")
            self.gameoverSound  = load_sound("a_gameOver.wav")
            
        def killActor(self, actor):
            World().actorList.remove(actor)
            actor.path.delActor(actor)
            actor.kill();
        
        def endGame(self):
            if(World().hiscore<World().points):
                World().hiscore = World().points
            World().points = 0
            World().gameStarted = 0
            World().gameTutActorSpawned = 0
            World().gameoverSound.play(0)
            for actor in World().actorList:
                actor.path.delActor(actor)
                actor.kill();
            del World().actorList[:]

    # storage for the instance reference
    __instance = None

    def __init__(self):
        """ Create singleton instance """
        # Check whether we already have an instance
        if World.__instance is None:
            # Create and remember instance
            World.__instance = World.__impl()

        # Store instance reference as the only member in the handle
        self.__dict__['_World__instance'] = World.__instance

    def __getattr__(self, attr):
        """ Delegate access to implementation """
        return getattr(self.__instance, attr)

    def __setattr__(self, attr, value):
        """ Delegate access to implementation """
        return setattr(self.__instance, attr, value)
    

from Actor import *
    
class Game:

    def __init__(self):
        pass

    
    def update(self):
        "World update"    
        
        # update footsteps
        '''
            if(len(self.actorList)==0):
                sndidx = -1
            elif(len(self.actorList)<3):
                sndidx = 0
            elif(len(self.actorList)<=7):
                sndidx = 1
            elif(len(self.actorList)<=15):
                sndidx = 2
            else:
                sndidx = 3
                
            for i in range(4):
                if(i==sndidx):
                    if(self.currentsnd!=i):
                       self.footsteps[i].play(1)
                       self.currentsnd = i
                       print 'Footstep play :', i
                else:
                    self.footsteps[i].stop()
        ''' 
        
        # check actors in goal
        for actor in World().actorList:
            if actor.state==Actor.FOLLOW:
                if (actor.rect.colliderect(World().goal1)):
                    if (actor.teamID==1):
                        actor.state = Actor.GOAL
                    elif (actor.teamID==2):
                        World().endGame()
                if (actor.rect.colliderect(World().goal2)):
                    if (actor.teamID==2):
                        actor.state = Actor.GOAL                        
                    elif (actor.teamID==1):
                        World().endGame()

            elif actor.state==Actor.GOAL and actor.goalTime>3:
                World().killActor(actor)
                World().prize.play()
                World().points += 1
                if(World().gameStarted==0):
                    World().gameStarted = 1
        
        # spawn new actors
        if(World().gameStarted==1):
            World().gameTime += 1
            if(World().gameTime>=World().nextSpawnTime):
                if World().gameTime<1000:
                    self.spawnRandomActors(1)
                    spawnTime = 120
                elif World().gameTime<5000:
                    self.spawnRandomActors(2)
                    spawnTime = 100
                elif World().gameTime<10000:
                    self.spawnRandomActors(3)
                    spawnTime = 70
                else:
                    self.spawnRandomActors(4)
                    spawnTime = 50
                World().nextSpawnTime = World().gameTime+spawnTime
                
        else:
            # spawn one tutorial actor
            if(World().gameTutActorSpawned==0):
                testActor = Actor(2)
                testActor.rect.topleft = (180,190)
                World().actorList.append(testActor)
                World().allsprites.add(testActor)
                World().nextSpawnTime = 0
                World().gameTutActorSpawned = 1
                World().gameTime = 0
                
        World().allsprites.update()
            
    def spawnRandomActors(self, numactors):
        for i in range(numactors):
            testActor = Actor(randint(1,2))
            testActor.rect.topleft = randint(World().spawnArena.left,World().spawnArena.right),randint(World().spawnArena.top,World().spawnArena.bottom)
            World().actorList.append(testActor)
            World().allsprites.add(testActor)
        
    def draw(self, screen):
        # visual debug
        #pygame.draw.rect(screen,(255,228,40), World().goal1, 2)
        #pygame.draw.rect(screen,(110,0,250), World().goal2, 2)
        #pygame.draw.rect(screen,(110,110,110), World().spawnArena, 2)
        
        World().allsprites.draw(screen)