Exemple #1
0
def campaign(c, background, stock, store):

    debug(c.DEBUG, "ENTERING: campaign")
    load_song(c, "It's Melting.ogg")

    versionID = stock.getVersion()

    #    pygame.key.set_repeat(0, 0)

    allSprites = pygame.sprite.Group()
    ringSprite = pygame.sprite.GroupSingle()
    circSprites = pygame.sprite.LayeredUpdates()
    buttonSprites = pygame.sprite.Group()  # @UnusedVariable
    starSprites = pygame.sprite.LayeredUpdates()
    caughtSprite = pygame.sprite.GroupSingle()
    dieingSprites = pygame.sprite.GroupSingle()
    scoreSprite = pygame.sprite.GroupSingle()
    pBox = playBox()  # a jukebox for handling music settings.

    ring = Ring(c.CENTER, stock.campaign["Ring"], stock.campaign["Ring Glow"],
                c.FULLSCREEN)
    '''CREATE IMAGES'''
    ring.add(ringSprite, allSprites)
    scoreboard = Scoreboard(c.DISPLAY_W, c.DISPLAY_H)
    scoreboard.add(scoreSprite, allSprites)
    box_img = stock.campaign["RGB Light"]
    background_rect = background.get_rect()
    background_rect.center = c.CENTER
    OGBackground = background.copy()
    '''INSTANTIATING OTHER VARIABLES'''
    rotAngle = 0  # background rotation angle
    waitCounterCirc = 0
    waitCounterStar = 0
    circleWaitStart = 0
    circleWaitMade = 0
    starWaitStart = 0
    starWaitMade = 0
    finishedCircleActions = False
    finishedStarActions = False
    circleAction = '_'
    starAction = '_'
    counter = 0
    starWaiting = False
    circleWaiting = False
    pauseStartTime = None  #datetime variable
    pauseEndTime = None  #datetime variable
    r = 0
    g = 0
    b = 0
    pause_selection = 0
    gamePaused = False
    total_input = 0
    fpsList = []
    toggle_color_r = False
    toggle_color_g = False
    toggle_color_b = False
    display_sprites = True
    controls = c.CONTROL_LIST
    leftHold = False
    rightHold = False
    upHold = False
    downHold = False
    #quitGame = False  # if user returns a True from pause, we quit game, etc.
    startTime = 0
    genList = os.path.join(c.DATA_DIR, 'campaign_commands/genCommands.txt')
    circleList = os.path.join(c.DATA_DIR,
                              'campaign_commands/circleCommands.txt')
    starList = os.path.join(c.DATA_DIR, 'campaign_commands/starCommands.txt')
    genList, circleList, starList = commander(c, genList, circleList,
                                              starList)  # commander takes the
    #                     commands.txt and converts it into a formatted list.
    circleList, starList = iter(circleList), iter(starList)

    # take in the genList parameters now, before the level begins.
    for loop in range(len(genList)):
        setting = genList[loop]
        if setting[0] == 'B':
            # if the command is BPM, set the proper variables.
            pBox.cWait = setting[1]
            pBox.fWait = setting[2]
            pBox.cSpeed = setting[3]
            pBox.fSpeed = setting[4]
        elif setting[0] == 'J':
            __startTime = setting[1]  #different startTime, unused
        # change the general speed for circles/stars
        elif setting[0][0] == 'W':
            if setting[0] == 'WG':
                pBox.cWait = setting[1]
                pBox.fWait = setting[1]
            elif setting[0] == 'WC':
                pBox.cWait = setting[1]
            elif setting[0] == 'WF':
                pBox.fWait = setting[1]
    """BUTTON / SPRITE RENDERING"""
    r_letter = c.FONT_LARGE.render('R', True, c.RED)
    r_letter.scroll(2, 0)
    r_letter_rect = r_letter.get_rect()
    r_letter_rect.center = (c.CENTER_X - 50, (c.CENTER_Y * 2) - 20)
    box_rectR = r_letter_rect

    g_letter = c.FONT_LARGE.render('G', True, c.GREEN)
    g_letter.scroll(1, 0)
    g_letter_rect = g_letter.get_rect()
    g_letter_rect.center = (c.CENTER_X, (c.CENTER_Y * 2) - 20)
    box_rectG = g_letter_rect

    b_letter = c.FONT_LARGE.render('B', True, c.BLUE)
    b_letter.scroll(2, 0)
    b_letter_rect = b_letter.get_rect()
    b_letter_rect.center = (c.CENTER_X + 50, (c.CENTER_Y * 2) - 20)
    box_rectB = b_letter_rect

    debug(c.DEBUG, "Variable and object instantiating successful.")
    showSplashScreen(c, stock)
    songLength = store.music["Spicy Chips"].get_length()
    #pygame.mixer.music.set_endevent(USEREVENT)
    debug(c.DEBUG, "Song loading successful, main game loop about to begin.")
    # --Main Game Loop//--
    playing_campaign = True
    startTime = datetime.datetime.now()
    pygame.mixer.music.play()
    while playing_campaign:
        counter += 1
        waitCounterCirc += 1
        waitCounterStar += 1
        # Paint the background
        c.DISPLAYSURFACE.fill((0, 0, 0))
        #c.DISPLAYSURFACE.blit(background, background_rect)
        #if not c.FULLSCREEN:
        #   if counter%2 == 0:
        #      background, background_rect, rotAngle = \
        #     rotateBackground(c.CENTER, OGBackground, counter, rotAngle)
        """LOGGING output information: FPS, event info, AA, etc."""
        # for every 30 or FPS number of frames, print an average fps.
        fpsList.append(c.FPSCLOCK.get_fps())
        if counter == (c.FPS):
            AverageFPS = mean(fpsList)
            debug(c.DEBUG, ("Average FPS: {0}".format(AverageFPS)))
            debug(c.DEBUG,
                  ("Current Score: {0}".format(scoreboard.scoreString)))
            counter = 0
            pygame.display.set_caption('RGB. FPS: {0}'.format(mean(fpsList)))
            fpsList = []

            #===================================================================
            # this includes other things that i feel like should only be done
            # once a second, to save computation time, such as song ending check
            #===================================================================
            # test real quick to see if the song is over.
            deltaTime = (datetime.datetime.now() - startTime).total_seconds()
            if deltaTime > songLength:
                timeMessage = "SongTime: {0}, GameTIme: {1}".format(
                    songLength, deltaTime)
                debug(c.DEBUG, timeMessage)
                pygame.mixer.music.stop()
                playing_campaign = False
                debug(c.DEBUG, "MUSIC ENDED, CAMPAIGN SESSION OVER")
        """TAKE ACTION COMMAND LIST"""
        # for every new action, if the wait was long enough, perform the action
        if not circleWaiting:
            if not finishedCircleActions:
                try:
                    circleAction = circleList.next()
                except:
                    finishedCircleActions = True
            # if the circleAction is to spawn a circle/star, gotta que it up.
            if circleAction[0] == 'C':
                circleWaiting = True
            # change the general speed for circles/stars
            elif circleAction[0] == 'CS':
                if circleAction[0] == 'CS':
                    pBox.cSpeed = circleAction[1]
            elif circleAction[0][0] == 'W':
                if circleAction[0] == 'W':
                    circleWaitStart = datetime.datetime.now()
                    circleWaiting = True
                    circleWaitMade = datetime.datetime.now(
                    )  # time started waiting
                elif circleAction[0] == 'WC':
                    pBox.cWait = circleAction[1]
            elif circleAction[0] == 'S':
                pygame.mixer.music.stop()
                playing_campaign = False
        if circleWaiting:
            # All main actions have to wait before they can be performed,
            # so once an action is read, waiting becomes True, and we test to
            # see if the time passed is valid for the given wait time.
            if circleAction[0] == 'C':
                if waitCounterCirc >= pBox.cWait:
                    if circleAction[2] == '':
                        # if there is no given speed, then it's the global
                        # speed. . .
                        tempSpeed = pBox.cSpeed
                    else:
                        tempSpeed = circleAction[2]
                    tempColor = circleAction[1]
                    debug(c.DEBUG,
                          ("{0}'s speed: {1}".format(tempColor, tempSpeed)))
                    tempCirc = Circle(stock.campaign['Circle'], c.CENTER,
                                      tempSpeed, tempColor, pBox.layer)
                    tempCirc.add(circSprites, allSprites)
                    circMade = datetime.datetime.now()  #for debugging
                    pBox.layer += 1  #determines which get drawn on top
                    circleWaiting = False
                    waitCounterCirc = 0
            elif circleAction[0] == 'W':
                change = datetime.datetime.now() - circleWaitStart
                # if the action is to JUST wait x amount of time
                if change.total_seconds() >= circleAction[1] / c.FPS:
                    circleWaiting = False
                    totalWaitTime = datetime.datetime.now() - circleWaitMade
                    debug(c.DEBUG,
                          ("Wait Time: ", totalWaitTime.total_seconds()))
                    waitCounterCirc = 0

        if not starWaiting:
            if not finishedStarActions:
                try:
                    starAction = starList.next()
                except:
                    finishedStarActions = True
            if starAction[0] == 'F':
                starWaiting = True
            # change the general speed for circles/stars
            elif starAction[0] == 'FS':
                pBox.fSpeed = starAction[1]
            elif starAction[0][0] == 'W':
                if starAction[0] == 'W':
                    starWaitStart = datetime.datetime.now()
                    starWaiting = True
                    starWaitMade = datetime.datetime.now(
                    )  # for debug purposes
                elif starAction[0] == 'WF':
                    pBox.fWait = starAction[1]
            elif starAction[0] == 'S':
                pygame.mixer.music.stop()
                playing_campaign = False
        if starWaiting:
            if starAction[0] == 'F':
                if waitCounterStar >= pBox.fWait:
                    if starAction[2] == '':
                        tempSpeed = pBox.fSpeed
                    else:
                        tempSpeed = starAction[2]
                    tempAngle = starAction[1]
                    images = (stock.campaign['Star Lit'],
                              stock.campaign['Star Unlit'])
                    tempStar = Star(images, c.CENTER, tempSpeed, tempAngle)
                    tempStar.add(starSprites, allSprites)
                    # no longer waiting, bring on the next starAction!
                    starWaiting = False
                    waitCounterStar = 0
            elif starAction[0] == 'W':
                change = datetime.datetime.now() - starWaitStart
                # if the starAction is to JUST wait x amount of time
                if change.total_seconds() >= starAction[1] / c.FPS:
                    starWaiting = False
                    totalWaitTime = datetime.datetime.now() - starWaitMade
                    debug(c.DEBUG,
                          ("Wait Time: ", totalWaitTime.total_seconds()))
                    waitCounterStar = 0
                    # we must also set the wait for the next starAction to 0,
                    # or else the wait would be Wx + Wcircle/star.
        """EVENT HANDLING INPUT"""
        # grab all the latest input
        latest_events = pygame.event.get()
        for event in latest_events:
            if event.type == QUIT:
                playing_campaign = False
                pygame.quit()
                sys.exit()
            elif event.type == KEYDOWN and event.key == K_ESCAPE:
                if c.DEBUG:
                    # quit game
                    playing_campaign = False
                    pygame.mixer.music.stop()
                else:
                    # have to time how long pause takes, for the wait.
                    pauseStartTime = datetime.datetime.now()
                    pause_selection = pause(c, stock, c.DISPLAYSURFACE)
                    pauseEndTime = datetime.datetime.now()
                    pauseTotalTime = (pauseEndTime - pauseStartTime)
                    starWaitStart += pauseTotalTime
                    circleWaitStart += pauseTotalTime
            # --game-play events//--
            elif event.type == KEYDOWN and event.key == controls[0]:
                r = 255
                toggle_color_r = True
                total_input += 1
                ring.glowColor((r, g, b))
            elif event.type == KEYUP and event.key == controls[0]:
                r = 0
                toggle_color_r = False
                total_input += -1
                ring.glowColor((r, g, b))
            elif event.type == KEYDOWN and event.key == controls[1]:
                g = 255
                toggle_color_g = True
                total_input += 1
                ring.glowColor((r, g, b))
            elif event.type == KEYUP and event.key == controls[1]:
                g = 0
                toggle_color_g = False
                total_input += -1
                ring.glowColor((r, g, b))
            elif event.type == KEYDOWN and event.key == controls[2]:
                b = 255
                toggle_color_b = True
                total_input += 1
                ring.glowColor((r, g, b))
            elif event.type == KEYUP and event.key == controls[2]:
                b = 0
                toggle_color_b = False
                total_input += -1
                ring.glowColor((r, g, b))
            # Ring Spinning
            elif event.type == KEYDOWN and event.key == controls[5]:
                leftHold = True
                if upHold:
                    ring.spin('upleft')
                elif downHold:
                    ring.spin('downleft')
                else:
                    ring.spin('left')
            elif event.type == KEYUP and event.key == controls[5]:
                leftHold = False
            elif event.type == KEYDOWN and event.key == controls[6]:
                rightHold = True
                if upHold:
                    ring.spin('upright')
                elif downHold:
                    ring.spin('downright')
                else:
                    ring.spin('right')
            elif event.type == KEYUP and event.key == controls[6]:
                rightHold = False
            elif event.type == KEYDOWN and event.key == controls[3]:
                upHold = True
                if leftHold:
                    ring.spin('upleft')
                elif rightHold:
                    ring.spin('upright')
                else:
                    ring.spin('up')
            elif event.type == KEYUP and event.key == controls[3]:
                upHold = False
            elif event.type == KEYDOWN and event.key == controls[4]:
                downHold = True
                if leftHold:
                    ring.spin('downleft')
                elif rightHold:
                    ring.spin('downright')
                else:
                    ring.spin('down')
            elif event.type == KEYUP and event.key == controls[4]:
                downHold = False

            #====================================
            # --non-game-play events//--
            #====================================
            # if O is pressed, toggle context display -------TO BE REMOVED SOON
            elif event.type == KEYDOWN and event.key == K_o:
                if display_sprites == True:
                    display_sprites = False
                else:
                    display_sprites = True
            # if P is pressed, pause game.
            elif event.type == KEYUP and event.key == controls[7]:
                gamePaused = True
            """LOGGING of inputs"""
            if event.type == KEYDOWN or event.type == KEYUP:
                debug(c.DEBUG,
                      (pygame.event.event_name(event.type), event.dict))

        if pause_selection == 3:
            pygame.mixer.music.stop()
            playing_campaign = False
            return
        """CATCH CIRCLES MATCHING COLORS"""
        # catch matching circles!!
        for circle in circSprites.sprites():
            if circle.catchable:
                # catchable becomes true when the circle comes in contact
                # with the ring.
                debug(c.DEBUG, (circle.color, (r, g, b)))
                circle.add(caughtSprite)
                circle.remove(circSprites)
                circle.catch()
                totalCircTime = datetime.datetime.now() - circMade
        """REPEATED POINTS HOLDING COLORS CAUGHT"""
        # every .1 seconds should add or remove points based on accuracy
        if not (caughtSprite.sprite is None):
            for circle in caughtSprite.sprites():
                if circle.color == (r, g, b) and not (circle.dieing):
                    debug(c.DEBUG,
                          ("CIRCTIME: ", totalCircTime.total_seconds()))
                    #if the circle is more than 1 color, than we give bonus
                    if circle.color[0] + circle.color[1] + circle.color[
                            2] > 255:
                        scoreboard.addScore(40)
                    else:
                        scoreboard.addScore(20)
                    circle.remove(caughtSprite)
                    circle.add(dieingSprites)
                else:
                    circle.remove(caughtSprite)
                    circle.add(dieingSprites)
                    scoreboard.addScore(-10)

        # a circle begins in circSprites, then hits the ring, gets caught, and
        # goes into "caughtSprite" group. From there, it tries to match with
        # the user's input, then dies and goes into the "dieingCircs" group.
        # the purpose of the last group is just to have it animate the fading
        # or "dieing" sequence before disappearing.
        for circle in dieingSprites.sprites():
            circle.death()
        """DELETE FREE STARS SHOOTING"""
        for star in starSprites.sprites():

            if star.travDist >= (264 - star.speed) and not (star.shooting):
                # this tests the stars' distance, once it's close enough. . .
                if not ((ringSprite.sprite.angle) % 360
                        == (star.angleDeg) % 360):
                    debug(c.DEBUG, "Star Died at:")
                    debug(c.DEBUG, ("Ring Angle: ", ringSprite.sprite.angle))
                    debug(c.DEBUG, ("Star Angle: ", star.angleDeg))
                    star.kill()
                    scoreboard.addScore(-30)
                else:
                    debug(c.DEBUG, "Star Made it at:")
                    debug(c.DEBUG, ("Ring Angle: ", ringSprite.sprite.angle))
                    debug(c.DEBUG, ("Star Angle: ", star.angleDeg))
            if star.shooting:
                #                 debug(c.DEBUG, 'I AM SHOOTING1!')
                # if the star has gone off the screen in the x or y direction
                # kill it and add points!!
                if star.pos[0] > c.DISPLAY_W or star.pos[0] < 0:
                    star.kill()
                    #                     debug(c.DEBUG, 'KILLED A STAR')
                    scoreboard.addScore(50)
                elif star.pos[1] > c.DISPLAY_H or star.pos[1] < 0:
                    star.kill()
                    #                     debug(c.DEBUG, 'KILLED A STAR')
                    scoreboard.addScore(50)


#         debug(c.DEBUG, ('Stars #: {0}'.format(len(starSprites.sprites())))
        """DISPLAY SPRITE TOGGLE"""
        allSprites.update()
        if display_sprites == True:
            dieingSprites.draw(c.DISPLAYSURFACE)
            caughtSprite.draw(c.DISPLAYSURFACE)
            circSprites.draw(c.DISPLAYSURFACE)
            starSprites.draw(c.DISPLAYSURFACE)
            ringSprite.draw(c.DISPLAYSURFACE)
            if toggle_color_r:
                c.DISPLAYSURFACE.blit(r_letter, r_letter_rect)
            if toggle_color_g:
                c.DISPLAYSURFACE.blit(g_letter, g_letter_rect)
            if toggle_color_b:
                c.DISPLAYSURFACE.blit(b_letter, b_letter_rect)
            c.DISPLAYSURFACE.blit(box_img, box_rectR)
            c.DISPLAYSURFACE.blit(box_img, box_rectG)
            c.DISPLAYSURFACE.blit(box_img, box_rectB)
            scoreSprite.draw(c.DISPLAYSURFACE)
            c.DISPLAYSURFACE.blit(versionID, (0, 0))
        """DELAY"""
        c.FPSCLOCK.tick_busy_loop(c.FPS)
        """UPDATE"""
        pygame.display.flip()  # update()

        # have to time how long pause takes, for the wait.
        if gamePaused:
            pauseStartTime = datetime.datetime.now()
            pause_selection = pause(c, stock, pygame.display.get_surface())
            pauseEndTime = datetime.datetime.now()
            pauseTotalTime = (pauseEndTime - pauseStartTime)
            starWaitStart += pauseTotalTime
            circleWaitStart += pauseTotalTime
            gamePaused = False

    return
Exemple #2
0
def creative(c, background):

    debug(c.DEBUG, "ENTERING: creative")
    
    # display the version ID
    font_renderObj = c.FONT_SMALL.render(c.VERSION, False, c.BLACK, c.WHITE)
    versionID_SurfaceObj = font_renderObj
    versionID_RectObj = versionID_SurfaceObj.get_rect()
    versionID_RectObj.topleft = (0, 0)

#    pygame.key.set_repeat(0, 0)

    allSprites = pygame.sprite.Group()
    ringSprite = pygame.sprite.GroupSingle()
    scoreSprite = pygame.sprite.GroupSingle()
    '''CREATE IMAGES'''
    ring = Ring(c, c.CENTER)
    ring.add(ringSprite, allSprites)
    scoreboard = Scoreboard(c.DISPLAY_W, c.DISPLAY_H)
    scoreboard.add(scoreSprite, allSprites)
    box_img, _box_rect = load_image(c, 'letter_box.png')
    background_rect = background.get_rect()
    background_rect.center = c.CENTER
    OGBackground = background.copy()
    logging = False

    '''INSTANTIATING OTHER VARIABLES'''
    dataDir = os.path.join(c.DATA_DIR, 'newCommands.txt')
    frameCount = 0      # tracks the number of frames passed.
    bgRotAngle = 0      # background rotation angle
    logFile = file
    testFrame = 0
    newAction = True
    r = 0
    g = 0
    b = 0
    paused = False
    fpsList = []
    toggle_color_r = False
    toggle_color_g = False
    toggle_color_b = False
    display_sprites = True
    controls = c.CONTROL_LIST
    leftHold = False
    rightHold = False
    upHold = False
    downHold = False
    quitGame = False  # if user returns a True from pause, we quit game, etc.
    firstAction = True

    """BUTTON / SPRITE RENDERING"""
    r_letter = c.FONT_LARGE.render('R', True, c.RED)
    r_letter.scroll(2, 0)
    r_letter_rect = r_letter.get_rect()
    r_letter_rect.center = (c.CENTER_X - 50, (c.CENTER_Y * 2) - 20)
    box_rectR = r_letter_rect

    g_letter = c.FONT_LARGE.render('G', True, c.GREEN)
    g_letter.scroll(1, 0)
    g_letter_rect = g_letter.get_rect()
    g_letter_rect.center = (c.CENTER_X, (c.CENTER_Y * 2) - 20)
    box_rectG = g_letter_rect

    b_letter = c.FONT_LARGE.render('B', True, c.BLUE)
    b_letter.scroll(2, 0)
    b_letter_rect = b_letter.get_rect()
    b_letter_rect.center = (c.CENTER_X + 50, (c.CENTER_Y * 2) - 20)
    box_rectB = b_letter_rect




    # throw down splash screen before beginning
    splashInfo, splashInfo_rect = load_image(c, 'splashInfo.png')
    # adjusting image cuz i can't make images.
    splashInfo_rect.center = (c.CENTER_X - 50, c.CENTER_Y)

    # fade info in and out
    fade = 0
    pgext.color.setAlpha(splashInfo, fade, 1)
    pygame.event.clear()
    # fade in
    inInfoScreen = True
    for fade in range(255):
        c.DISPLAYSURFACE.fill((0, 0, 0))
        c.DISPLAYSURFACE.blit(splashInfo, splashInfo_rect)
        pgext.color.setAlpha(splashInfo, fade, 1)
        c.DISPLAYSURFACE.blit(versionID_SurfaceObj, versionID_RectObj)
        pygame.display.flip()
        if pygame.event.poll().type != NOEVENT:
            inInfoScreen = False
            break
    # if the info is still being read/no button pressed, just wait.
    while inInfoScreen:
        if pygame.event.poll().type != NOEVENT:
            inInfoScreen = False
    fade = 255
    pgext.color.setAlpha(splashInfo, fade, 1)
    load_song(c, "It's Melting.ogg")  # stops other music from playing too
    cmdFile = open(dataDir, 'w')
    cmdFile.write("BPM60 Play:")

    # --Main Game Loop//--
    going = True
    while going:
        

        # Paint the background
        c.DISPLAYSURFACE.fill((0,0,0))
        c.DISPLAYSURFACE.blit(background, background_rect)
        """ROTATION TESTING"""
        # rotate the background, but only 15 times/second, not 30.
        # if the frame rate is 30/sec, then rotate when its an odd frame.
        if frameCount%3 == 0:
            bgRotAngle += .03
            background = pygame.transform.rotozoom(OGBackground, bgRotAngle%360 , 1)
            background_rect = background.get_rect()
            background_rect.center = c.CENTER
        frameCount += 1


        """LOGGING output information: FPS, event info, AA, etc."""
        # for every 30 or FPS number of frames, print an average fps.
        fpsList.append(c.FPSCLOCK.get_fps())
        if testFrame == c.FPS:
            debug(c.DEBUG, ("Average FPS: {0}".format(mean(fpsList))))
            debug(c.DEBUG, ("Current Score: {0}".format(scoreboard.scoreString)))
            testFrame = 0
            pygame.display.set_caption('RGB. FPS: {0}'.format(mean(fpsList)))
            fpsList = []

        """Start the Song!"""
        beginning = True
        if beginning:
            pygame.mixer.music.play()
            beginning = False
            # record the beginning, since no action causes a new time recording
            counter.setTime(1)
        

        """EVENT HANDLING INPUT"""
        # grab all the latest input
        latest_events = pygame.event.get()
        for event in latest_events:
            if (event.type == KEYDOWN or event.type == KEYUP) and \
                (event.key in controls) and firstAction:
                # this is the very first action, and its a correct input,
                # we put a Wait action in, since there was nothing before the 
                # first action to tell us otherwise.
                cmdFile.write(' W%d'%counter.getDelta(True))
                # so we write how long it took to do the action above
                counter.setTime(1)
                # if any button is pressed, a change must be written in. . .
                firstAction = False
            if event.type == QUIT:
                going = False
                pygame.quit()
                sys.exit()
            elif event.type == KEYDOWN and event.key == K_ESCAPE:
                if c.DEBUG:
                    going = False
                else:
                    paused = True
            # --game-play events//--
            elif event.type == KEYDOWN and event.key == controls[0]:
                # default key is R
                r = 255
                toggle_color_r = True
            elif event.type == KEYUP and event.key == controls[0]:
                r = 0
                toggle_color_r = False
            elif event.type == KEYDOWN and event.key == controls[1]:
                # default key is G
                g = 255
                toggle_color_g = True
            elif event.type == KEYUP and event.key == controls[1]:
                g = 0
                toggle_color_g = False
            elif event.type == KEYDOWN and event.key == controls[2]:
                # default key is B
                b = 255
                toggle_color_b = True
            elif event.type == KEYUP and event.key == controls[2]:
                b = 0
                toggle_color_b = False
            # Ring Spinning
            elif event.type == KEYDOWN and event.key == controls[5]:
                leftHold = True
                if upHold:
                    ring.spin('upleft')
                elif downHold:
                    ring.spin('downleft')
                else:
                    ring.spin('left')
            elif event.type == KEYUP and event.key == controls[5]:
                leftHold = False
            elif event.type == KEYDOWN and event.key == controls[6]:
                rightHold = True
                if upHold:
                    ring.spin('upright')
                elif downHold:
                    ring.spin('downright')
                else:
                    ring.spin('right')
            elif event.type == KEYUP and event.key == controls[6]:
                rightHold = False
            elif event.type == KEYDOWN and event.key == controls[3]:
                upHold = True
                if leftHold:
                    ring.spin('upleft')
                elif rightHold:
                    ring.spin('upright')
                else:
                    ring.spin('up')
            elif event.type == KEYUP and event.key == controls[3]:
                upHold = False
            elif event.type == KEYDOWN and event.key == controls[4]:
                downHold = True
                if leftHold:
                    ring.spin('downleft')
                elif rightHold:
                    ring.spin('downright')
                else:
                    ring.spin('down')
            elif event.type == KEYUP and event.key == controls[4]:
                downHold = False

            #====================================
            # --non-game-play events//--
            #====================================
            # if O is pressed, toggle context display -------TO BE REMOVED SOON
            elif event.type == KEYDOWN and event.key == K_o:
                if display_sprites == True:
                    display_sprites = False
                else:
                    display_sprites = True
            # if P is pressed, pause game.
            elif event.type == KEYUP and event.key == controls[7]:
                paused = True

            """LOGGING of inputs"""
            if event.type == KEYDOWN or event.type == KEYUP:
                debug(c.DEBUG, event.dict)

        """DISPLAY SPRITE TOGGLE"""
        allSprites.update()
        if display_sprites == True:
            if toggle_color_r:
                c.DISPLAYSURFACE.blit(r_letter, r_letter_rect)
            if toggle_color_g:
                c.DISPLAYSURFACE.blit(g_letter, g_letter_rect)
            if toggle_color_b:
                c.DISPLAYSURFACE.blit(b_letter, b_letter_rect)
            c.DISPLAYSURFACE.blit(box_img, box_rectR)
            c.DISPLAYSURFACE.blit(box_img, box_rectG)
            c.DISPLAYSURFACE.blit(box_img, box_rectB)
            scoreSprite.draw(c.DISPLAYSURFACE)
            c.DISPLAYSURFACE.blit(versionID_SurfaceObj, versionID_RectObj)

        """DELAY"""
        c.FPSCLOCK.tick_busy_loop(c.FPS)

        """PAUSE UNPAUSE"""
        if paused:
            pygame.mixer.music.pause()
            quitGame = pauseScreen(c)
            if quitGame == 3:
                going = False
            pygame.mixer.music.unpause()
            paused = False

        """UPDATE"""
        pygame.display.flip()  # update()

    try:
        cmdFile.close()
    except Exception:
        debug(c.DEBUG, "File never opened")
    return
Exemple #3
0
def creative(c, background, stock, store):

    debug(c.DEBUG, "ENTERING: campaign")

    versionID = stock.getVersion()

    timeClock = clockCounter()
    allSprites = pygame.sprite.Group()
    ringSprite = pygame.sprite.GroupSingle()
    circSprites = pygame.sprite.LayeredUpdates()
    buttonSprites = pygame.sprite.Group()  # @UnusedVariable
    starSprites = pygame.sprite.LayeredUpdates()
    caughtSprite = pygame.sprite.GroupSingle()
    dieingSprites = pygame.sprite.GroupSingle()
    scoreSprite = pygame.sprite.GroupSingle()
    pBox = playBox()  # a jukebox for handling music settings.
    pygame.mixer.music.set_endevent(USEREVENT)

    ring = Ring(c.CENTER, stock.campaign["Ring"], stock.campaign["Ring Glow"],
                c.FULLSCREEN)
    '''CREATE IMAGES'''
    ring.add(ringSprite, allSprites)
    scoreboard = Scoreboard(c.DISPLAY_W, c.DISPLAY_H)
    scoreboard.add(scoreSprite, allSprites)
    box_img = stock.campaign["RGB Light"]
    background_rect = background.get_rect()
    background_rect.center = c.CENTER
    OGBackground = background.copy()
    '''INSTANTIATING OTHER VARIABLES'''
    rotAngle = 0  # background rotation angle
    waitCounterCirc = 0
    waitCounterStar = 0
    countingCircleTime = False
    countingStarTime = False
    countingWaitTime = False
    totalWaitTime = 0
    totalCircleTime = 0
    totalStarTime = 0
    newStartTime = 0
    oldStartTime = 0
    pause_selection = 0
    newCircleColor = ''
    oldCircleColor = ''
    newStarAngle = ''
    oldStarAngle = ''
    circleWaitStart = 0
    circleWaitMade = 0
    circleColor = ''
    starWaitStart = 0
    starWaitMade = 0
    pauseStartTime = None  #datetime variable
    pauseEndTime = None  #datetime variable
    finishedCircleActions = False
    finishedStarActions = False
    circleAction = '_'
    starAction = '_'
    counter = 0
    starWaiting = False
    circleWaiting = False
    countingWaitTime = False
    r = 0
    g = 0
    b = 0
    paused = False
    total_input = 0
    fpsList = []
    toggle_color_r = False
    toggle_color_g = False
    toggle_color_b = False
    display_sprites = True
    controls = c.CONTROL_LIST
    leftHold = False
    rightHold = False
    upHold = False
    downHold = False
    quitGame = False  # if user returns a True from pause, we quit game, etc.
    startTime = 0
    newInput = True
    currentColor = (0, 0, 0)
    colorList = ""

    # open the files that we'll be saving to.
    genFile = os.path.join(c.DATA_DIR, 'creative_commands/genCommands.txt')
    circleFile = os.path.join(c.DATA_DIR,
                              'creative_commands/circleCommands.txt')
    starFile = os.path.join(c.DATA_DIR, 'creative_commands/starCommands.txt')
    genFile = open(genFile, 'w')
    circleFile = open(circleFile, 'w')
    starFile = open(starFile, 'w')
    """BUTTON / SPRITE RENDERING"""
    r_letter = c.FONT_LARGE.render('R', True, c.RED)
    r_letter.scroll(2, 0)
    r_letter_rect = r_letter.get_rect()
    r_letter_rect.center = (c.CENTER_X - 50, (c.CENTER_Y * 2) - 20)
    box_rectR = r_letter_rect

    g_letter = c.FONT_LARGE.render('G', True, c.GREEN)
    g_letter.scroll(1, 0)
    g_letter_rect = g_letter.get_rect()
    g_letter_rect.center = (c.CENTER_X, (c.CENTER_Y * 2) - 20)
    box_rectG = g_letter_rect

    b_letter = c.FONT_LARGE.render('B', True, c.BLUE)
    b_letter.scroll(2, 0)
    b_letter_rect = b_letter.get_rect()
    b_letter_rect.center = (c.CENTER_X + 50, (c.CENTER_Y * 2) - 20)
    box_rectB = b_letter_rect

    stageDisplay = stock.creative["Circle Building"]
    stageDisplay_rect = stageDisplay.get_rect()
    stageDisplay_rect.topright = (c.DISPLAY_W, 0)

    debug(c.DEBUG, "Variable and object instantiating successful.")
    showSplashScreen(c, stock)
    load_song(c, "It's Melting.ogg")  # stops other music from playing too

    debug(c.DEBUG, "Stars and Circles ready! ")

    debug(c.DEBUG, "Now building Circles")

    # --CIRCLE MAKING Loop//--
    going = True
    pygame.mixer.music.play(0, 0)
    timeClock.playTimeSet()
    while going:
        counter += 1
        # Paint the background
        c.DISPLAYSURFACE.fill((0, 0, 0))
        c.DISPLAYSURFACE.blit(background, background_rect)
        if counter % 5 == 0:
            background, background_rect, rotAngle = \
            rotateBackground(c.CENTER, OGBackground, counter, rotAngle)
        """LOGGING output information: FPS, event info, AA, etc."""
        # for every 30 or FPS number of frames, print an average fps.
        fpsList.append(c.FPSCLOCK.get_fps())
        if counter == (c.FPS * 5):
            debug(c.DEBUG, ("Average FPS: {0}".format(mean(fpsList))))
            debug(c.DEBUG,
                  ("Current Score: {0}".format(scoreboard.scoreString)))
            counter = 0
            pygame.display.set_caption('RGB. FPS: {0}'.format(mean(fpsList)))
            fpsList = []

        #=======================================================================
        # """Get input to know if we should put in a wait action"""
        # if total_input == 0:
        #     if not countingWaitTime:
        #         debug(c.DEBUG, "STARTING COUNT WAIT TIME")
        #         countingWaitTime = True
        #         timeClock.setTime(1)
        #=======================================================================

        if newCircleColor != '':
            oldCircleColor = newCircleColor
        """EVENT HANDLING INPUT"""
        # grab all the latest input
        latest_events = pygame.event.get()
        for event in latest_events:
            if event.type == QUIT:
                going = False
                pygame.quit()
                sys.exit()
            elif event.type == KEYDOWN and event.key == K_ESCAPE:
                if c.DEBUG:
                    going = False
                    pygame.mixer.music.stop()
                #===============================================================
                # else:
                #     # have to time how long pause takes, for the wait.
                #     pauseStartTime = datetime.datetime.now()
                #     pause_selection = pause()
                #     pauseEndTime = datetime.datetime.now()
                #     pauseTotalTime = (pauseEndTime - pauseStartTime)
                #     starWaitStart = starWaitStart + pauseTotalTime
                #     circleWaitStart = circleWaitStart + pauseTotalTime
                #===============================================================
            # --game-play events//--
            elif event.type == KEYDOWN and event.key == controls[0]:
                r = 255
                toggle_color_r = True
                total_input += 1
                colorList += 'R'
            elif event.type == KEYUP and event.key == controls[0]:
                r = 0
                toggle_color_r = False
                total_input += -1
                colorList = colorList.replace('R', '')
            elif event.type == KEYDOWN and event.key == controls[1]:
                g = 255
                toggle_color_g = True
                total_input += 1
                colorList += 'G'
            elif event.type == KEYUP and event.key == controls[1]:
                g = 0
                toggle_color_g = False
                total_input += -1
                colorList = colorList.replace('G', '')
            elif event.type == KEYDOWN and event.key == controls[2]:
                b = 255
                toggle_color_b = True
                total_input += 1
                colorList += 'B'
            elif event.type == KEYUP and event.key == controls[2]:
                b = 0
                toggle_color_b = False
                total_input += -1
                colorList = colorList.replace('B', '')
            #====================================
            # --non-game-play events//--
            #====================================
            # if O is pressed, toggle context display -------TO BE REMOVED SOON
            elif event.type == KEYDOWN and event.key == K_o:
                if display_sprites == True:
                    display_sprites = False
                else:
                    display_sprites = True
            elif event.type == KEYDOWN and event.key == K_s:
                # add ten seconds to the total playtime.
                pygame.mixer.music.stop()
                newStartTime = (datetime.datetime.now() - timeClock.playTime
                                ).total_seconds() + 10 + oldStartTime
                # since the song is now 10 seconds ahead, we have to make sure there is a 10 second difference
                # in recording of actions.
                timeClock.timeIn = timeClock.timeIn - datetime.timedelta(
                    seconds=10)
                pygame.mixer.music.play(0, newStartTime)
                # need to record where we last began.
                oldStartTime = newStartTime
                debug(c.DEBUG, "new Start Time: %f" % newStartTime)
            # if P is pressed, pause game.
            elif event.type == KEYUP and event.key == controls[7]:
                None
                #===============================================================
                # # have to time how long pause takes, for the wait.
                # pauseStartTime = datetime.datetime.now()
                # pause_selection = pause()
                # pauseEndTime = datetime.datetime.now()
                # pauseTotalTime = (pauseEndTime - pauseStartTime)
                # starWaitStart = starWaitStart + pauseTotalTime
                # circleWaitStart = circleWaitStart + pauseTotalTime
                #===============================================================
            """LOGGING of inputs"""
            if event.type == KEYDOWN or event.type == KEYUP:
                debug(c.DEBUG,
                      (pygame.event.event_name(event.type), event.dict))
                debug(c.DEBUG, "NEWINPUT FOUND")
                newInput = True
                newCircleColor = colorList  # grab color at time of recording.

        if pygame.event.peek(USEREVENT):
            going = False

        if pause_selection == 3:
            going = False
            return

        #if an action has been input, test total_inputs:
        """Get input to know if we should put in a wait action"""
        if not (total_input == 0):
            if countingWaitTime:
                countingWaitTime = False
                totalWaitTime = timeClock.getDelta(True)
                debug(c.DEBUG, "Old wait time recorded")
                circleFile.write(" W{0} ".format(totalWaitTime +
                                                 totalCircleTime))
                # if it isn't counting wait time, then it IS counting circleTime
                countingCircleTime = True
                debug(c.DEBUG, "Now counting circle time")
                timeClock.setTime(1)
                # newInput is set to false, since we already know its a new
                # input based on change in counting. newInput is only
                # relevant for when the circle color changes without a wait
                # in between.
                newInput = False
            else:
                if countingCircleTime:
                    if newInput:
                        #first, we must store the old input.
                        totalCircleTime = timeClock.getDelta(True)
                        circleFile.write(" C{0},{1} ".format(
                            oldCircleColor, totalCircleTime))
                        # a wait time must be introduced so that other circles
                        # don't spawn.
                        circleFile.write(" W{0} ".format(totalCircleTime))
                        newInput = False
                        debug(c.DEBUG, "Old circle time recorded")
                        debug(c.DEBUG, "New circle time recording")
                        #now we start the new Input recording..
                        timeClock.setTime(1)
        else:
            if not countingWaitTime:
                if countingCircleTime:
                    totalCircleTime = timeClock.getDelta(True)
                    circleFile.write(" C{0},{1} ".format(
                        oldCircleColor, totalCircleTime))
                    newInput = False
                    debug(c.DEBUG, "Old circle time recorded")
                    countingCircleTime = False
                else:
                    debug(c.DEBUG, "Now counting wait time")
                    countingWaitTime = True
                    timeClock.setTime(1)
            elif not (going):
                totalWaitTime = timeClock.getDelta(True)
                circleFile.write(" W{0} ".format(totalWaitTime))
        """DISPLAY SPRITE TOGGLE"""
        allSprites.update()
        if display_sprites == True:
            dieingSprites.draw(c.DISPLAYSURFACE)
            caughtSprite.draw(c.DISPLAYSURFACE)
            circSprites.draw(c.DISPLAYSURFACE)
            starSprites.draw(c.DISPLAYSURFACE)
            ringSprite.draw(c.DISPLAYSURFACE)
            if toggle_color_r:
                c.DISPLAYSURFACE.blit(r_letter, r_letter_rect)
            if toggle_color_g:
                c.DISPLAYSURFACE.blit(g_letter, g_letter_rect)
            if toggle_color_b:
                c.DISPLAYSURFACE.blit(b_letter, b_letter_rect)
            c.DISPLAYSURFACE.blit(box_img, box_rectR)
            c.DISPLAYSURFACE.blit(box_img, box_rectG)
            c.DISPLAYSURFACE.blit(box_img, box_rectB)
            c.DISPLAYSURFACE.blit(stageDisplay, stageDisplay_rect)
            scoreSprite.draw(c.DISPLAYSURFACE)
            c.DISPLAYSURFACE.blit(versionID, (0, 0))
        """DELAY"""
        c.FPSCLOCK.tick_busy_loop(c.FPS)
        """UPDATE"""
        pygame.display.flip()  # update()
    circleFile.close()
    if quitGame == 3:
        return

    debug(c.DEBUG, "Now building Stars")
    """Reinitializing Variables."""
    newStartTime = 0
    oldStartTime = 0
    stageDisplay = stock.creative["Star Building"]
    stageDisplay_rect = stageDisplay.get_rect()
    stageDisplay_rect.topright = (c.DISPLAY_W, 0)

    # --STAR MAKING Loop//--
    going = True
    pygame.mixer.music.play(0, 0)
    timeClock.playTimeSet()
    while going:
        counter += 1
        # Paint the background
        c.DISPLAYSURFACE.fill((0, 0, 0))
        c.DISPLAYSURFACE.blit(background, background_rect)
        if counter % 5 == 0:
            background, background_rect, rotAngle = \
            rotateBackground(c.CENTER, OGBackground, counter, rotAngle)
        """LOGGING output information: FPS, event info, AA, etc."""
        # for every 30 or FPS number of frames, print an average fps.
        fpsList.append(c.FPSCLOCK.get_fps())
        if counter == (c.FPS * 5):
            debug(c.DEBUG, ("Average FPS: {0}".format(mean(fpsList))))
            debug(c.DEBUG,
                  ("Current Score: {0}".format(scoreboard.scoreString)))
            counter = 0
            pygame.display.set_caption('RGB. FPS: {0}'.format(mean(fpsList)))
            fpsList = []

        #=======================================================================
        # """Get input to know wif we should put in a wait action"""
        # if total_input == 0:
        #     if not countingWaitTime:
        #         debug(c.DEBUG, "STARTING COUNT WAIT TIME")
        #         countingWaitTime = True
        #         timeClock.setTime(1)
        #=======================================================================

        if newStarAngle != '':
            oldStarAngle = newStarAngle
        """EVENT HANDLING INPUT"""
        # grab all the latest input
        latest_events = pygame.event.get()
        for event in latest_events:
            if event.type == QUIT:
                going = False
                pygame.quit()
                sys.exit()
            elif event.type == KEYDOWN and event.key == K_ESCAPE:
                if c.DEBUG:
                    going = False
                    pygame.mixer.music.stop()
                else:
                    None
                    #===========================================================
                    # # have to time how long pause takes, for the wait.
                    # pauseStartTime = datetime.datetime.now()
                    # pause_selection = pause()
                    # pauseEndTime = datetime.datetime.now()
                    # pauseTotalTime = (pauseEndTime - pauseStartTime)
                    # starWaitStart = starWaitStart + pauseTotalTime
                    # circleWaitStart = circleWaitStart + pauseTotalTime
                    #===========================================================
            # --game-play events//--
            # Ring Spinning
            elif event.type == KEYDOWN and event.key == controls[5]:
                total_input += 1
                leftHold = True
                if upHold:
                    ring.spin('upleft')
                elif downHold:
                    ring.spin('downleft')
                else:
                    ring.spin('left')
            elif event.type == KEYUP and event.key == controls[5]:
                leftHold = False
                total_input += -1
            elif event.type == KEYDOWN and event.key == controls[6]:
                rightHold = True
                total_input += 1
                if upHold:
                    ring.spin('upright')
                elif downHold:
                    ring.spin('downright')
                else:
                    ring.spin('right')
            elif event.type == KEYUP and event.key == controls[6]:
                rightHold = False
                total_input += -1
            elif event.type == KEYDOWN and event.key == controls[3]:
                upHold = True
                total_input += 1
                if leftHold:
                    ring.spin('upleft')
                elif rightHold:
                    ring.spin('upright')
                else:
                    ring.spin('up')
            elif event.type == KEYUP and event.key == controls[3]:
                upHold = False
                total_input += -1
            elif event.type == KEYDOWN and event.key == controls[4]:
                downHold = True
                total_input += 1
                if leftHold:
                    ring.spin('downleft')
                elif rightHold:
                    ring.spin('downright')
                else:
                    ring.spin('down')
            elif event.type == KEYUP and event.key == controls[4]:
                downHold = False
                total_input += -1

            #====================================
            # --non-game-play events//--
            #====================================
            # if O is pressed, toggle context display -------TO BE REMOVED SOON
            elif event.type == KEYDOWN and event.key == K_o:
                if display_sprites == True:
                    display_sprites = False
                else:
                    display_sprites = True
            elif event.type == KEYDOWN and event.key == K_s:
                # add ten seconds to the total playtime.
                pygame.mixer.music.stop()
                newStartTime = (datetime.datetime.now() - timeClock.playTime
                                ).total_seconds() + 10 + oldStartTime
                # since the song is now 10 seconds ahead, we have to make sure there is a 10 second difference
                # in recording of actions.
                timeClock.timeIn = timeClock.timeIn - datetime.timedelta(
                    seconds=10)
                pygame.mixer.music.play(0, newStartTime)
                # need to record where we last began.
                oldStartTime = newStartTime
                debug(c.DEBUG, "new Start Time: %f" % newStartTime)
            # if P is pressed, pause game.
            elif event.type == KEYUP and event.key == controls[7]:
                None
                #===============================================================
                # # have to time how long pause takes, for the wait.
                # pauseStartTime = datetime.datetime.now()
                # pause_selection = pause()
                # pauseEndTime = datetime.datetime.now()
                # pauseTotalTime = (pauseEndTime - pauseStartTime)
                # starWaitStart = starWaitStart + pauseTotalTime
                # circleWaitStart = circleWaitStart + pauseTotalTime
                #===============================================================
            """LOGGING of inputs"""
            if event.type == KEYDOWN or event.type == KEYUP:
                debug(c.DEBUG,
                      (pygame.event.event_name(event.type), event.dict))
                debug(c.DEBUG, "NEWINPUT FOUND")
                newInput = True
                newStarAngle = ring.angle  # grab angle at time of recording.

        if pygame.event.peek(USEREVENT):
            pygame.mixer.music.stop()
            going = False

        if pause_selection == 3:
            going = False
            return

        #if an action has been input, test total_inputs:
        """Get input to know if we should put in a wait action"""
        if not (total_input == 0):
            if countingWaitTime:
                countingWaitTime = False
                totalWaitTime = timeClock.getDelta(True)
                debug(c.DEBUG, "Old wait time recorded")
                starFile.write(" W{0} ".format(totalWaitTime + totalStarTime))
                # if it isn't counting wait time, then it IS counting circleTime
                countingStarTime = True
                debug(c.DEBUG, "Now counting star time")
                timeClock.setTime(1)
                # newInput is set to false, since we already know its a new
                # input based on change in counting. newInput is only
                # relevant for when the circle color changes without a wait
                # in between.
                newInput = False
            else:
                if countingStarTime:
                    if newInput:
                        #first, we must store the old input.
                        totalStarTime = timeClock.getDelta(True)
                        starFile.write(" F{0},{1} ".format(
                            oldStarAngle, totalStarTime))
                        # a wait time must be introduced so that other circles
                        # don't spawn.
                        starFile.write(" W{0} ".format(totalStarTime))
                        newInput = False
                        debug(c.DEBUG, "Old star time recorded")
                        debug(c.DEBUG, "New star time recording")
                        #now we start the new Input recording..
                        timeClock.setTime(1)
        else:
            if not countingWaitTime:
                if countingStarTime:
                    totalStarTime = timeClock.getDelta(True)
                    starFile.write(" F{0},{1} ".format(oldStarAngle,
                                                       totalStarTime))
                    newInput = False
                    debug(c.DEBUG, "Old star time recorded")
                    countingStarTime = False
                else:
                    debug(c.DEBUG, "Now counting wait time")
                    countingWaitTime = True
                    timeClock.setTime(1)
            elif not (going):
                totalWaitTime = timeClock.getDelta(True)
                starFile.write(" W{0} ".format(totalWaitTime))
        """DISPLAY SPRITE TOGGLE"""
        allSprites.update()
        if display_sprites == True:
            dieingSprites.draw(c.DISPLAYSURFACE)
            caughtSprite.draw(c.DISPLAYSURFACE)
            circSprites.draw(c.DISPLAYSURFACE)
            starSprites.draw(c.DISPLAYSURFACE)
            ringSprite.draw(c.DISPLAYSURFACE)
            if toggle_color_r:
                c.DISPLAYSURFACE.blit(r_letter, r_letter_rect)
            if toggle_color_g:
                c.DISPLAYSURFACE.blit(g_letter, g_letter_rect)
            if toggle_color_b:
                c.DISPLAYSURFACE.blit(b_letter, b_letter_rect)
            c.DISPLAYSURFACE.blit(box_img, box_rectR)
            c.DISPLAYSURFACE.blit(box_img, box_rectG)
            c.DISPLAYSURFACE.blit(box_img, box_rectB)
            c.DISPLAYSURFACE.blit(stageDisplay, stageDisplay_rect)
            scoreSprite.draw(c.DISPLAYSURFACE)
            c.DISPLAYSURFACE.blit(versionID, (0, 0))
        """DELAY"""
        c.FPSCLOCK.tick_busy_loop(c.FPS)
        """UPDATE"""
        pygame.display.flip()  # update()
    starFile.close()
    if quitGame == 3:
        return

    debug(c.DEBUG, "Showing built commands")
    """REINITIALIZING"""

    stageDisplay = stock.creative["Build Testing"]
    stageDisplay_rect = stageDisplay.get_rect()
    stageDisplay_rect.topright = (c.DISPLAY_W, 0)

    genList = os.path.join(c.DATA_DIR, 'creative commands/genCommands.txt')
    circleList = os.path.join(c.DATA_DIR,
                              'creative commands/circleCommands.txt')
    starList = os.path.join(c.DATA_DIR, 'creative commands/starCommands.txt')
    genList, circleList, starList = commander(c, genList, circleList,
                                              starList)  # commander takes the
    #                     commands.txt and converts it into a formatted list.
    circleList, starList = iter(circleList), iter(starList)

    # take in the genList parameters now, before the level begins.
    for loop in range(len(genList)):
        setting = genList[loop]
        if setting[0] == 'B':
            # if the command is BPM, set the proper variables.
            pBox.cWait = setting[1]
            pBox.fWait = setting[2]
            pBox.cSpeed = setting[3]
            pBox.fSpeed = setting[4]
        elif setting[0] == 'J':
            startTime = setting[1]
        # change the general speed for circles/stars
        elif setting[0][0] == 'W':
            if setting[0] == 'WG':
                pBox.cWait = setting[1]
                pBox.fWait = setting[1]
            elif setting[0] == 'WC':
                pBox.cWait = setting[1]
            elif setting[0] == 'WF':
                pBox.fWait = setting[1]

    # --Main Game Loop//--
    going = True
    pygame.mixer.music.play(0, startTime)
    while going:
        counter += 1
        waitCounterCirc += 1
        waitCounterStar += 1
        # Paint the background
        c.DISPLAYSURFACE.fill((0, 0, 0))
        c.DISPLAYSURFACE.blit(background, background_rect)
        if counter % 5 == 0:
            background, background_rect, rotAngle = \
            rotateBackground(c.CENTER, OGBackground, counter, rotAngle)
        """LOGGING output information: FPS, event info, AA, etc."""
        # for every 30 or FPS number of frames, print an average fps.
        fpsList.append(c.FPSCLOCK.get_fps())
        if counter == (c.FPS * 5):
            debug(c.DEBUG, ("Average FPS: {0}".format(mean(fpsList))))
            debug(c.DEBUG,
                  ("Current Score: {0}".format(scoreboard.scoreString)))
            counter = 0
            pygame.display.set_caption('RGB. FPS: {0}'.format(mean(fpsList)))
            fpsList = []
        """TAKE ACTION COMMAND LIST"""
        # for every new action, if the wait was long enough, perform the action
        if not circleWaiting:
            if not finishedCircleActions:
                try:
                    circleAction = circleList.next()
                except:
                    finishedCircleActions = True
            # if the circleAction is to spawn a circle/star, gotta que it up.
            if circleAction[0] == 'C':
                circleWaiting = True
            # change the general speed for circles/stars
            elif circleAction[0] == 'CS':
                if circleAction[0] == 'CS':
                    pBox.cSpeed = circleAction[1]
            elif circleAction[0][0] == 'W':
                if circleAction[0] == 'W':
                    circleWaitStart = datetime.datetime.now()
                    circleWaiting = True
                    circleWaitMade = datetime.datetime.now(
                    )  # time started waiting
                elif circleAction[0] == 'WC':
                    pBox.cWait = circleAction[1]
            elif circleAction[0] == 'S':
                pygame.mixer.music.stop()
                going = False
        if circleWaiting:
            # All main actions have to wait before they can be performed,
            # so once an action is read, waiting becomes True, and we test to
            # see if the time passed is valid for the given wait time.
            if circleAction[0] == 'C':
                if waitCounterCirc >= pBox.cWait:
                    if circleAction[2] == '':
                        # if there is no given speed, then it's the global
                        # speed. . .
                        tempSpeed = pBox.cSpeed
                    else:
                        tempSpeed = circleAction[2]
                    tempColor = circleAction[1]
                    debug(c.DEBUG,
                          ("{0}'s speed: {1}".format(tempColor, tempSpeed)))
                    tempCirc = Circle(stock.campaign['Circle'], c.CENTER,
                                      tempSpeed, tempColor, pBox.layer)
                    tempCirc.add(circSprites, allSprites)
                    circMade = datetime.datetime.now()  #for debugging
                    pBox.layer += 1  #determines which get drawn on top
                    circleWaiting = False
                    waitCounterCirc = 0
            elif circleAction[0] == 'W':
                change = datetime.datetime.now() - circleWaitStart
                # if the action is to JUST wait x amount of time
                if change.total_seconds() >= circleAction[1] / c.FPS:
                    circleWaiting = False
                    totalWaitTime = datetime.datetime.now() - circleWaitMade
                    debug(c.DEBUG,
                          ("Wait Time: ", totalWaitTime.total_seconds()))
                    waitCounterCirc = 0

        if not starWaiting:
            if not finishedStarActions:
                try:
                    starAction = starList.next()
                except:
                    finishedStarActions = True
            if starAction[0] == 'F':
                starWaiting = True
            # change the general speed for circles/stars
            elif starAction[0] == 'FS':
                pBox.fSpeed = starAction[1]
            elif starAction[0][0] == 'W':
                if starAction[0] == 'W':
                    starWaitStart = datetime.datetime.now()
                    starWaiting = True
                    starWaitMade = datetime.datetime.now()
                elif starAction[0] == 'WF':
                    pBox.fWait = starAction[1]
            elif starAction[0] == 'S':
                pygame.mixer.music.stop()
                going = False
        if starWaiting:
            if starAction[0] == 'F':
                if waitCounterStar >= pBox.fWait:
                    if starAction[2] == '':
                        tempSpeed = pBox.fSpeed
                    else:
                        tempSpeed = starAction[2]
                    tempAngle = starAction[1]
                    images = (stock.campaign['Star Lit'],
                              stock.campaign['Star Unlit'])
                    tempStar = Star(images, c.CENTER, tempSpeed, tempAngle)
                    tempStar.add(starSprites, allSprites)
                    # no longer waiting, bring on the next starAction!
                    starWaiting = False
                    waitCounterStar = 0
            elif starAction[0] == 'W':
                change = datetime.datetime.now() - starWaitStart
                # if the starAction is to JUST wait x amount of time
                if change.total_seconds() >= starAction[1] / 30.0:
                    starWaiting = False
                    totalWaitTime = datetime.datetime.now() - starWaitMade
                    debug(c.DEBUG,
                          ("Wait Time: ", totalWaitTime.total_seconds()))
                    waitCounterStar = 0
                    # we must also set the wait for the next starAction to 0,
                    # or else the wait would be Wx + Wcircle/star.

        # test real quick to see if the song is over.
        if pygame.event.peek(USEREVENT):
            pygame.mixer.music.stop()
            going = False

        if pause_selection == 3:
            going = False
            return
        """EVENT HANDLING INPUT"""
        # grab all the latest input
        latest_events = pygame.event.get()
        for event in latest_events:
            if event.type == QUIT:
                going = False
                pygame.quit()
                sys.exit()
            elif event.type == KEYDOWN and event.key == K_ESCAPE:
                if c.DEBUG:
                    going = False
                else:
                    # have to time how long pause takes, for the wait.
                    pauseStartTime = datetime.datetime.now()
                    pause_selection = pause()
                    pauseEndTime = datetime.datetime.now()
                    pauseTotalTime = (pauseEndTime - pauseStartTime)
                    starWaitStart = starWaitStart + pauseTotalTime
                    circleWaitStart = circleWaitStart + pauseTotalTime
            # --game-play events//--
            elif event.type == KEYDOWN and event.key == controls[0]:
                r = 255
                toggle_color_r = True
                total_input += 1
            elif event.type == KEYUP and event.key == controls[0]:
                r = 0
                toggle_color_r = False
                total_input += -1
            elif event.type == KEYDOWN and event.key == controls[1]:
                g = 255
                toggle_color_g = True
                total_input += 1
            elif event.type == KEYUP and event.key == controls[1]:
                g = 0
                toggle_color_g = False
                total_input += -1
            elif event.type == KEYDOWN and event.key == controls[2]:
                b = 255
                toggle_color_b = True
                total_input += 1
            elif event.type == KEYUP and event.key == controls[2]:
                b = 0
                toggle_color_b = False
                total_input += -1
            # Ring Spinning
            elif event.type == KEYDOWN and event.key == controls[5]:
                leftHold = True
                if upHold:
                    ring.spin('upleft')
                elif downHold:
                    ring.spin('downleft')
                else:
                    ring.spin('left')
            elif event.type == KEYUP and event.key == controls[5]:
                leftHold = False
            elif event.type == KEYDOWN and event.key == controls[6]:
                rightHold = True
                if upHold:
                    ring.spin('upright')
                elif downHold:
                    ring.spin('downright')
                else:
                    ring.spin('right')
            elif event.type == KEYUP and event.key == controls[6]:
                rightHold = False
            elif event.type == KEYDOWN and event.key == controls[3]:
                upHold = True
                if leftHold:
                    ring.spin('upleft')
                elif rightHold:
                    ring.spin('upright')
                else:
                    ring.spin('up')
            elif event.type == KEYUP and event.key == controls[3]:
                upHold = False
            elif event.type == KEYDOWN and event.key == controls[4]:
                downHold = True
                if leftHold:
                    ring.spin('downleft')
                elif rightHold:
                    ring.spin('downright')
                else:
                    ring.spin('down')
            elif event.type == KEYUP and event.key == controls[4]:
                downHold = False

            #====================================
            # --non-game-play events//--
            #====================================
            # if O is pressed, toggle context display -------TO BE REMOVED SOON
            elif event.type == KEYDOWN and event.key == K_o:
                if display_sprites == True:
                    display_sprites = False
                else:
                    display_sprites = True
            # if P is pressed, pause game.
            elif event.type == KEYUP and event.key == controls[7]:
                # have to time how long pause takes, for the wait.
                pauseStartTime = datetime.datetime.now()
                pause_selection = pause()
                pauseEndTime = datetime.datetime.now()
                pauseTotalTime = (pauseEndTime - pauseStartTime)
                starWaitStart = starWaitStart + pauseTotalTime
                circleWaitStart = circleWaitStart + pauseTotalTime
            """LOGGING of inputs"""
            if event.type == KEYDOWN or event.type == KEYUP:
                debug(c.DEBUG,
                      (pygame.event.event_name(event.type), event.dict))
        """CATCH CIRCLES MATCHING COLORS"""
        # catch matching circles!!
        for circle in circSprites.sprites():
            if circle.catchable:
                # catchable becomes true when the circle comes in contact
                # with the ring.
                debug(c.DEBUG, (circle.color, (r, g, b)))
                circle.add(caughtSprite)
                circle.remove(circSprites)
                circle.catch()
                totalCircTime = datetime.datetime.now() - circMade
        """REPEATED POINTS HOLDING COLORS CAUGHT"""
        # every .1 seconds should add or remove points based on accuracy
        if not (caughtSprite.sprite is None):
            for circle in caughtSprite.sprites():
                if circle.color == (r, g, b) and not (circle.dieing):
                    debug(c.DEBUG,
                          ("CIRCTIME: ", totalCircTime.total_seconds()))
                    #if the circle is more than 1 color, than we give bonus
                    if circle.color[0] + circle.color[1] + circle.color[
                            2] > 255:
                        scoreboard.addScore(40)
                    else:
                        scoreboard.addScore(20)
                    circle.remove(caughtSprite)
                    circle.add(dieingSprites)
                else:
                    circle.remove(caughtSprite)
                    circle.add(dieingSprites)
                    scoreboard.addScore(-10)

        # a circle begins in circSprites, then hits the ring, gets caught, and
        # goes into "caughtSprite" group. From there, it tries to match with
        # the user's input, then dies and goes into the "dieingCircs" group.
        # the purpose of the last group is just to have it animate the fading
        # or "dieing" sequence before disappearing.
        for circle in dieingSprites.sprites():
            circle.death()
        """DELETE FREE STARS SHOOTING"""
        for star in starSprites.sprites():

            if star.travDist >= (264 - star.speed) and not (star.shooting):
                # this tests the stars' distance, once it's close enough. . .
                if not ((ringSprite.sprite.angle) % 360
                        == (star.angleDeg) % 360):
                    debug(c.DEBUG, "Star Died at:")
                    debug(c.DEBUG, ("Ring Angle: ", ringSprite.sprite.angle))
                    debug(c.DEBUG, ("Star Angle: ", star.angleDeg))
                    star.kill()
                    scoreboard.addScore(-30)
                else:
                    debug(c.DEBUG, "Star Made it at:")
                    debug(c.DEBUG, ("Ring Angle: ", ringSprite.sprite.angle))
                    debug(c.DEBUG, ("Star Angle: ", star.angleDeg))
            if star.shooting:
                #                 debug(c.DEBUG, 'I AM SHOOTING1!')
                # if the star has gone off the screen in the x or y direction
                # kill it and add points!!
                if star.pos[0] > c.DISPLAY_W or star.pos[0] < 0:
                    star.kill()
                    #                     debug(c.DEBUG, 'KILLED A STAR')
                    scoreboard.addScore(50)
                elif star.pos[1] > c.DISPLAY_H or star.pos[1] < 0:
                    star.kill()
                    #                     debug(c.DEBUG, 'KILLED A STAR')
                    scoreboard.addScore(50)


#         debug(c.DEBUG, ('Stars #: {0}'.format(len(starSprites.sprites())))
        """DISPLAY SPRITE TOGGLE"""
        allSprites.update()
        if display_sprites == True:
            dieingSprites.draw(c.DISPLAYSURFACE)
            caughtSprite.draw(c.DISPLAYSURFACE)
            circSprites.draw(c.DISPLAYSURFACE)
            starSprites.draw(c.DISPLAYSURFACE)
            ringSprite.draw(c.DISPLAYSURFACE)
            if toggle_color_r:
                c.DISPLAYSURFACE.blit(r_letter, r_letter_rect)
            if toggle_color_g:
                c.DISPLAYSURFACE.blit(g_letter, g_letter_rect)
            if toggle_color_b:
                c.DISPLAYSURFACE.blit(b_letter, b_letter_rect)
            c.DISPLAYSURFACE.blit(box_img, box_rectR)
            c.DISPLAYSURFACE.blit(box_img, box_rectG)
            c.DISPLAYSURFACE.blit(box_img, box_rectB)
            c.DISPLAYSURFACE.blit(stageDisplay, stageDisplay_rect)
            scoreSprite.draw(c.DISPLAYSURFACE)
            c.DISPLAYSURFACE.blit(versionID, (0, 0))
        """DELAY"""
        c.FPSCLOCK.tick_busy_loop(c.FPS)
        """UPDATE"""
        pygame.display.flip()  # update()

    return