1 problema y resuelvo el juego

Tengo un problema con el temporizador,uso dos temporizadores en la escena y uno se superpone con el otro, nesesitaria que si ejecuto 1 suprima al otro. Uno es un contador para perder,y el otro esta asociado a un boton,seria lo que me permite avanzar en el juego.
El problema puntual es que si presiono el boton para avansar de escena y el tiempo del contador para gameover esta proximo a llegar a cero,se ejecuta el contador de perder y no el que me permite ganar,subo codigo,

# coding: utf-8
import pilasengine
pilas = pilasengine.iniciar()
#creo una ventana con las instruccion del juego
def menu():
    pilas.escenas.Normal()
    pilas.actores.Menu([('Empezar a jugar', iniciar_juego),('Salir', salir_del_juego)]),
    fondo=pilas.fondos.Fondo()
    fondo.imagen="fondos/azul.jpg"
    fondo.escala_x=1
    fondo.escala_y=1
    fondo.rotacion=[360],100###darleinstruccion de girar por siempre
    texto=pilas.actores.Texto("UN JUEGO DE\n   MEMORIA")#"\n divide el texto en dos lineas
    texto.y=150
    texto.escala=2
    texto.color=pilas.colores.Color(200,200,200)
    cursor1()
    botoncredito()

#creo una escena con la instruccion del juego
def iniciar_juego():
    pilas.escenas.Normal()
    fondo=pilas.fondos.Fondo()
    fondo.imagen="fondos/cerebro.jpg"
    fondo.escala_x=2.8
    fondo.escala_y=2.5
    texto=pilas.actores.Texto(" Memoriza la posicion\n    de las imagenes")
    texto.color=pilas.colores.Color(200,00,00)
    tempcambio(2,primer_escena,100)
    boton_salir()
    cursor1()
    
def salir_del_juego():
    print ("hasta pronto")#editar para antes de cerrar el juego salga este mensaje//sin concluir
    pilas.terminar()

    
#creo los actores (imagenes)que voy a usar durante el juego
def actorloro():
    actorl=pilas.actores.Actor()
    actorl.imagen="actores/loroverdet.png"
    actorl.escala=0.1
    actorl.definir_posicion(-270,200)
    actorl.transparencia=40
def actormariposareal():
    actorm=pilas.actores.Actor()
    actorm.imagen="actores/mariposarealbajares.png"
    actorm.escala=0.25
    actorm.definir_posicion(208,75)
    actorm.transparencia=40
def actoraveverde():
    actorm=pilas.actores.Actor()
    actorm.imagen="actores/aveverde.png"
    actorm.escala=0.40
    actorm.definir_posicion(-108,45)
    actorm.transparencia=40
    
def actorserpiente(cant):
    actorl=pilas.actores.Actor()
    actorl.imagen="actores/serpienteverdei2.png"
    actorl.escala=0.25
    actorl.definir_posicion(220,-130)
    cant=actorl.transparencia=(cant)
#defino la 1er imagen a encontrar creando un return para transparencia cada ves que la invoco   
def botonserpiente(cant):
    b = pilas.actores.Boton(ruta_normal="actores/serpienteverdei2.png",x=220,y=-130)
    b.escala=0.25
    b.definir_posicion=(220,-130)
    b.z=-1        #para que el boton invisible quede por delante della imagen visible
    cant=b.transparencia=(cant)
    b.conectar_presionado(logrado)
    return cant
    
def actorave(cant):##actor principal de esta escena
    actora=pilas.actores.Actor()
    actora.imagen="actores/ave2.png"
    actora.escala=0.1
    actora.definir_posicion(-25,-85)
    cant=actora.transparencia=(cant)  
def botonave(cant):
    b = pilas.actores.Boton(ruta_normal="actores/ave2.png",x=-160,y=190)
    b.escala=0.1
    b.definir_posicion(-25,-85)
    b.z=-1        #para que el boton invisible quede por delante della imagen visible
    cant=b.transparencia=(cant)
    b.conectar_presionado(logrado2)
    return cant
def actorlobo():
    actorl=pilas.actores.Actor()
    actorl.imagen="actores/lobo1.png"
    actorl.escala=0.3
    actorl.definir_posicion(-170,-200)
    actorl.transparencia=30
def actorra():
    actorra=pilas.actores.Actor()
    actorra.imagen="actores/rosaamarilla.png"
    actorra.escala=0.2
    actorra.definir_posicion(290,-80)
    actorra.transparencia=40
def actorma():
    actorma=pilas.actores.Actor()
    actorma.imagen="actores/mariposaazul.png"
    actorma.escala=0.3
    actorma.definir_posicion(170,-60)
    actorma.transparencia=40

#para mostrar la consigna durante un tiempo determinado
def tiempoconsigna(str,func,r,g,b):
    mtiempo= pilas.actores.Texto(str)
    mtiempo.color=pilas.colores.Color(r,g,b)
    mtiempo.escala=1.5
    mtiempo.x = -60
    mtiempo.y = 180
    t = pilas.actores.Temporizador() 
    t.ajustar(5, func)
    t.texto.x=80
    t.texto.y = 175
    t.texto.escala=1.5
    t.texto.transparencia=100
    t.comenzar()   
    t.terminar()
    return str,func,r,g,b

#creo temporizador para personalizar segun cada escena donde se invoca,es invisible. 
def tempcambio(cant,func,cantt):
    ti = pilas.actores.Temporizador() 
    ti.ajustar(cant, func)#cambiar tiempo para terminar de leer la instruccion
    ti.comenzar()
    ti.texto.transparencia=(cantt)
    ti.actualizar()
    return cant,func,cantt

#creo boton para terminar juego
def boton_salir():
    bs = pilas.interfaz.Boton("Salir") 
    bs.x = -240
    bs.y = -220
    bs.z=-1
    bs.conectar(salir_del_juego)
##defino cursor personalizado
def cursor1():
    actor=pilas.actores.Actor()                               
    actor.escala=0.1
    actor.imagen="actores/avecursor3.png"
    actor.aprender("seguiralmouse")
    pilas.ocultar_puntero_del_mouse()        #deja visible solo la imagen personalizada del cursor
    actor.z= -100#porque no agarra??????????
#defino primer escena 
def primer_escena():
    pilas.escenas.Normal()
    fondo=pilas.fondos.Fondo()
    fondo.imagen="fondos/selva2.jpg"
    fondo.escala_x=0.5
    fondo.escala_y=0.8
    actorserpiente(50)                
    actorloro()                
    actormariposareal()
    actoraveverde()
    tiempoconsigna("encuentra la serpiente",actualizar_primerescena,250,250,250)
    boton_salir()
    cursor1()

    
#defino la actualizacion de escena con la ilusion de invisibilizar personajes
def actualizar_primerescena():
    pilas.escenas.Normal()
    fondo=pilas.fondos.Fondo()
    fondo.imagen="fondos/selva2.jpg"
    fondo.escala_x=0.5
    fondo.escala_y=0.8    #de esta manera simula ser la misma escena              #escena pero con los actores invisibles(transparencia 100%)
    boton_salir()
    cursor1()
    botonserpiente(100)
    tempcambio(6,gameover,0)
    
    
def segunda_escena():
    pilas.escenas.Normal()
    fondo=pilas.fondos.Fondo()
    fondo.imagen="fondos/cascada.jpg"
    fondo.escala_x=0.4
    fondo.escala_y=0.4 
    actorave(40)                     
    actorlobo()
    actorra()
    actorma()
    tiempoconsigna("        encuentra\n            el ave",actualizar_segundaescena,250,100,0)
    cursor1()
    boton_salir()
    
def actualizar_segundaescena():
   pilas.escenas.Normal()
   fondo=pilas.fondos.Fondo()
   fondo.imagen="fondos/cascada.jpg"
   fondo.escala_x=0.4
   fondo.escala_y=0.4 
   botonave(100)
   cursor1()
   boton_salir()
   tempcambio(6,gameover,0)
    
def logrado():
    fondo=pilas.fondos.Fondo()
    fondo.imagen="actores/logrado.png"
    fondo.escala=0.5
    fondo.z=10
    botonserpiente(0)
    tempcambio(2,segunda_escena,0)
    
    
def logrado2():
    fondo=pilas.fondos.Fondo()
    fondo.imagen="actores/logrado.png"
    fondo.escala=0.5
    fondo.z=10
    actorave(0)
    tempcambio(2,felicitacion,0)
        
#imagen para fin del juego
def gameover():
    pilas.escenas.Normal()
    fondo=pilas.fondos.Fondo()
    fondo.imagen="fondos/gameover.jpg"
    fondo.escala=1.2
    texto=pilas.actores.Texto("NO HAS ENCONTRADO LA IMAGEN")
    texto.color=pilas.colores.Color(200,00,200)
    texto.definir_posicion(0,-100)
    tempcambio(5,menu,100)
    
def felicitacion():
    pilas.escenas.Normal()
    fondo=pilas.fondos.Fondo()
    fondo.imagen="fondos/felicitaciones.jpg"
    tempcambio(2,menu,0)
    fondo.escala_y=1.5
    fondo.escala_x=1.5
def botoncredito():
    bc= pilas.interfaz.Boton("Creditos") 
    bc.x = 210
    bc.y = -220
    bc.z=-1
    bc.conectar(creditos)
    
def creditos():
    pilas.escenas.Normal()
    fondo=pilas.fondos.Fondo()
    fondo.imagen="fondos/creditos.png"
    fondo.escala_x=1.5
    fondo.escala_y=2.85
    tempcambio(3,menu,100)   
    
menu()

Hola @avin !!

Para crear contadores de tiempo y poder eliminarlos podrías usar tareas, están en el manual de pilas:

http://manual.pilas-engine.com.ar/tareas/

Es muy sencillo, cada vez que creas una tarea, por ejemplo una que aumente un puntaje, podés eliminarla con la referencia que te entrega la creación:

# Para crear una tarea
una_tarea = pilas.tareas.siempre(5, funcion)

# Y para eliminar ...
una_tarea.terminar()