Python engine.precache_sound函数代码示例

def light_fluoro(*qwp_extra):
    if qc.self.style >= 32:
        qc.self.use = light_use
        if qc.self.spawnflags & START_OFF:
            engine.lightstyle(qc.self.style, 'a')
        else:
            engine.lightstyle(qc.self.style, 'm')
        
    engine.precache_sound('ambience/fl_hum1.wav')
    engine.ambientsound(qc.self.origin, 'ambience/fl_hum1.wav', 0.5, defs.ATTN_STATIC)

def item_artifact_envirosuit(*qwp_extra):
    qc.self.touch = powerup_touch
    engine.precache_model('progs/suit.mdl')
    engine.precache_sound('items/suit.wav')
    engine.precache_sound('items/suit2.wav')
    qc.self.noise = 'items/suit.wav'
    qc.self.setmodel('progs/suit.mdl')
    qc.self.netname = 'Biosuit'
    qc.self.items = defs.IT_SUIT
    qc.setsize(qc.self, Vector(-16, -16, -24), Vector(16, 16, 32))
    StartItem()

def trigger_teleport(*qwp_extra):
    subs.InitTrigger()
    qc.self.touch = teleport_touch
    #  find the destination 
    if not qc.self.target:
        qc.objerror('no target')
    qc.self.use = teleport_use
    if not (qc.self.spawnflags & SILENT):
        engine.precache_sound('ambience/hum1.wav')
        o = (qc.self.mins + qc.self.maxs) * 0.5
        engine.ambientsound(o, 'ambience/hum1.wav', 0.5, defs.ATTN_STATIC)

def func_train(*qwp_extra):
    if not qc.self.speed:
        qc.self.speed = 100
    if not qc.self.target:
        qc.objerror('func_train without a target')
    if not qc.self.dmg:
        qc.self.dmg = 2
    if qc.self.sounds == 0:
        qc.self.noise = ('misc/null.wav')
        engine.precache_sound('misc/null.wav')
        qc.self.noise1 = ('misc/null.wav')
        engine.precache_sound('misc/null.wav')        
    elif qc.self.sounds == 1:
        qc.self.noise = ('plats/train2.wav')
        engine.precache_sound('plats/train2.wav')
        qc.self.noise1 = ('plats/train1.wav')
        engine.precache_sound('plats/train1.wav')
        
    qc.self.cnt = 1
    qc.self.solid = defs.SOLID_BSP
    qc.self.movetype = defs.MOVETYPE_PUSH
    qc.self.blocked = train_blocked
    qc.self.use = train_use
    qc.self.classname = 'train'
    qc.self.setmodel(qc.self.model)
    qc.setsize(qc.self, qc.self.mins, qc.self.maxs)
    qc.setorigin(qc.self, qc.self.origin)
    #  start trains on the second frame, to make sure their targets have had
    #  a chance to spawn
    qc.self.nextthink = qc.self.ltime + 0.1
    qc.self.think = func_train_find

def trigger_secret(*qwp_extra):
    qc.total_secrets += 1
    qc.self.wait = -1
    if not qc.self.message:
        qc.self.message = 'You found a secret area!'
    if not qc.self.sounds:
        qc.self.sounds = 1
    if qc.self.sounds == 1:
        engine.precache_sound('misc/secret.wav')
        qc.self.noise = 'misc/secret.wav'
        
    elif qc.self.sounds == 2:
        engine.precache_sound('misc/talk.wav')
        qc.self.noise = 'misc/talk.wav'
        
    trigger_multiple()

def misc_explobox2(*qwp_extra):
    qc.self.solid = defs.SOLID_BBOX
    qc.self.movetype = defs.MOVETYPE_NONE
    engine.precache_model('maps/b_exbox2.bsp')
    qc.self.setmodel('maps/b_exbox2.bsp')
    qc.setsize(qc.self, Vector(0, 0, 0), Vector(32, 32, 32))
    engine.precache_sound('weapons/r_exp3.wav')
    qc.self.health = 20
    qc.self.th_die = barrel_explode
    qc.self.takedamage = defs.DAMAGE_AIM
    qc.self.origin %= Vector(None, None, qc.self.origin.z + 2)
    oldz = qc.self.origin.z
    qc.droptofloor()
    if oldz - qc.self.origin.z > 250:
        engine.dprint('item fell out of level at ')
        engine.dprint(str(qc.self.origin))
        engine.dprint('\012')
        qc.self.remove()

def StartRuneSpawn(*qwp_extra):
    if defs.runespawned or defs.gamestart:
        return 
    defs.runespawned = 1
    engine.precache_model('progs/end1.mdl')
    engine.precache_model('progs/end2.mdl')
    engine.precache_model('progs/end3.mdl')
    engine.precache_model('progs/end4.mdl')
    engine.precache_model('progs/m_s_key.mdl')
    engine.precache_model('progs/m_g_key.mdl')
    engine.precache_sound('rune/rune1.wav')
    engine.precache_sound('rune/rune2.wav')
    engine.precache_sound('rune/rune22.wav') #  special rune and quad combo
    engine.precache_sound('rune/rune3.wav')
    engine.precache_sound('rune/rune4.wav')
    #  spawn the runes
    rspawn = qc.spawn()
    rspawn.nextthink = qc.time + 0.1
    rspawn.think = SpawnRunes

def trigger_multiple(*qwp_extra):
    if qc.self.sounds == 1:
        engine.precache_sound('misc/secret.wav')
        qc.self.noise = 'misc/secret.wav'
        
    elif qc.self.sounds == 2:
        engine.precache_sound('misc/talk.wav')
        qc.self.noise = 'misc/talk.wav'
        
    elif qc.self.sounds == 3:
        engine.precache_sound('misc/trigger1.wav')
        qc.self.noise = 'misc/trigger1.wav'
        
    if not qc.self.wait:
        qc.self.wait = 0.2
    qc.self.use = multi_use
    subs.InitTrigger()
    if qc.self.health:
        if qc.self.spawnflags & SPAWNFLAG_NOTOUCH:
            qc.objerror("health and notouch don't make sense\012")
        qc.self.max_health = qc.self.health
        qc.self.th_die = multi_killed
        qc.self.takedamage = defs.DAMAGE_YES
        qc.self.solid = defs.SOLID_BBOX
        qc.setorigin(qc.self, qc.self.origin) #  make sure it links into the world
        
    else:
        if not (qc.self.spawnflags & SPAWNFLAG_NOTOUCH):
            qc.self.touch = multi_touch

def item_health(*qwp_extra):
    qc.self.touch = health_touch
    if qc.self.spawnflags & H_ROTTEN:
        engine.precache_model('maps/b_bh10.bsp')
        engine.precache_sound('items/r_item1.wav')
        qc.self.setmodel('maps/b_bh10.bsp')
        qc.self.noise = 'items/r_item1.wav'
        qc.self.healamount = 15
        qc.self.healtype = 0
        
    elif qc.self.spawnflags & H_MEGA:
        engine.precache_model('maps/b_bh100.bsp')
        engine.precache_sound('items/r_item2.wav')
        qc.self.setmodel('maps/b_bh100.bsp')
        qc.self.noise = 'items/r_item2.wav'
        qc.self.healamount = 100
        qc.self.healtype = 2
        
    else:
        engine.precache_model('maps/b_bh25.bsp')
        engine.precache_sound('items/health1.wav')
        qc.self.setmodel('maps/b_bh25.bsp')
        qc.self.noise = 'items/health1.wav'
        qc.self.healamount = 25
        qc.self.healtype = 1
        
    qc.setsize(qc.self, Vector(0, 0, 0), Vector(32, 32, 56))
    StartItem()

def func_plat(*qwp_extra):
    t = engine.world
    if not qc.self.t_length:
        qc.self.t_length = 80
    if not qc.self.t_width:
        qc.self.t_width = 10
    if qc.self.sounds == 0:
        qc.self.sounds = 2
    #  FIX THIS TO LOAD A GENERIC PLAT SOUND
    if qc.self.sounds == 1:
        engine.precache_sound('plats/plat1.wav')
        engine.precache_sound('plats/plat2.wav')
        qc.self.noise = 'plats/plat1.wav'
        qc.self.noise1 = 'plats/plat2.wav'
        
    if qc.self.sounds == 2:
        engine.precache_sound('plats/medplat1.wav')
        engine.precache_sound('plats/medplat2.wav')
        qc.self.noise = 'plats/medplat1.wav'
        qc.self.noise1 = 'plats/medplat2.wav'
        
    qc.self.mangle = qc.self.angles
    qc.self.angles = Vector(0, 0, 0)
    qc.self.classname = 'plat'
    qc.self.solid = defs.SOLID_BSP
    qc.self.movetype = defs.MOVETYPE_PUSH
    qc.setorigin(qc.self, qc.self.origin)
    qc.self.setmodel(qc.self.model)
    qc.setsize(qc.self, qc.self.mins, qc.self.maxs)
    qc.self.blocked = plat_crush
    if not qc.self.speed:
        qc.self.speed = 150
    #  pos1 is the top position, pos2 is the bottom
    qc.self.pos1 = qc.self.origin
    qc.self.pos2 = qc.self.origin
    if qc.self.height:
        qc.self.pos2 %= Vector(None, None, qc.self.origin.z - qc.self.height)
    else:
        qc.self.pos2 %= Vector(None, None, qc.self.origin.z - qc.self.size.z + 8)
    qc.self.use = plat_trigger_use
    plat_spawn_inside_trigger() #  the "start moving" trigger	
    if qc.self.targetname:
        qc.self.state = defs.STATE_UP
        qc.self.use = plat_use
        
    else:
        qc.setorigin(qc.self, qc.self.pos2)
        qc.self.state = defs.STATE_BOTTOM

def misc_teleporttrain(*qwp_extra):
    if not qc.self.speed:
        qc.self.speed = 100
    if not qc.self.target:
        qc.objerror('func_train without a target')
    qc.self.cnt = 1
    qc.self.solid = defs.SOLID_NOT
    qc.self.movetype = defs.MOVETYPE_PUSH
    qc.self.blocked = train_blocked
    qc.self.use = train_use
    qc.self.avelocity = Vector(100, 200, 300)
    qc.self.noise = ('misc/null.wav')
    engine.precache_sound('misc/null.wav')
    qc.self.noise1 = ('misc/null.wav')
    engine.precache_sound('misc/null.wav')
    engine.precache_model('progs/teleport.mdl')
    qc.self.setmodel('progs/teleport.mdl')
    qc.setsize(qc.self, qc.self.mins, qc.self.maxs)
    qc.setorigin(qc.self, qc.self.origin)
    #  start trains on the second frame, to make sure their targets have had
    #  a chance to spawn
    qc.self.nextthink = qc.self.ltime + 0.1
    qc.self.think = func_train_find

def trap_spikeshooter(*qwp_extra):
    subs.SetMovedir()
    qc.self.use = spikeshooter_use
    if qc.self.spawnflags & SPAWNFLAG_LASER:
        engine.precache_model('progs/laser.mdl')
        engine.precache_sound('enforcer/enfire.wav')
        engine.precache_sound('enforcer/enfstop.wav')        
    else:
        engine.precache_sound('weapons/spike2.wav')

def item_sigil(*qwp_extra):
    if not qc.self.spawnflags:
        qc.objerror('no spawnflags')
    engine.precache_sound('misc/runekey.wav')
    qc.self.noise = 'misc/runekey.wav'
    if qc.self.spawnflags & 1:
        engine.precache_model('progs/end1.mdl')
        qc.self.setmodel('progs/end1.mdl')
        
    if qc.self.spawnflags & 2:
        engine.precache_model('progs/end2.mdl')
        qc.self.setmodel('progs/end2.mdl')
        
    if qc.self.spawnflags & 4:
        engine.precache_model('progs/end3.mdl')
        qc.self.setmodel('progs/end3.mdl')
        
    if qc.self.spawnflags & 8:
        engine.precache_model('progs/end4.mdl')
        qc.self.setmodel('progs/end4.mdl')
        
    qc.self.touch = sigil_touch
    qc.setsize(qc.self, Vector(-16, -16, -24), Vector(16, 16, 32))
    StartItem()

def item_artifact_invulnerability(*qwp_extra):
    qc.self.touch = powerup_touch
    engine.precache_model('progs/invulner.mdl')
    engine.precache_sound('items/protect.wav')
    engine.precache_sound('items/protect2.wav')
    engine.precache_sound('items/protect3.wav')
    qc.self.noise = 'items/protect.wav'
    qc.self.setmodel('progs/invulner.mdl')
    qc.self.netname = 'Pentagram of Protection'
    qc.self.items = defs.IT_INVULNERABILITY
    qc.setsize(qc.self, Vector(-16, -16, -24), Vector(16, 16, 32))
    StartItem()

def item_artifact_super_damage(*qwp_extra):
    qc.self.touch = powerup_touch
    engine.precache_model('progs/quaddama.mdl')
    engine.precache_sound('items/damage.wav')
    engine.precache_sound('items/damage2.wav')
    engine.precache_sound('items/damage3.wav')
    qc.self.noise = 'items/damage.wav'
    qc.self.setmodel('progs/quaddama.mdl')
    qc.self.netname = 'Quad Damage'
    qc.self.items = defs.IT_QUAD
    qc.setsize(qc.self, Vector(-16, -16, -24), Vector(16, 16, 32))
    StartItem()