// Implementation: called when read has completed. void ConsoleUI::RunL() { TKeyCode kc = con_->KeyCode(); pj_bool_t reschedule = PJ_TRUE; switch (kc) { case 'w': snd_stop(); CActiveScheduler::Stop(); reschedule = PJ_FALSE; break; case 'a': snd_start(PJMEDIA_DIR_CAPTURE_PLAYBACK); break; case 't': snd_start(PJMEDIA_DIR_CAPTURE); break; case 'p': snd_start(PJMEDIA_DIR_PLAYBACK); break; case 'd': snd_stop(); break; default: PJ_LOG(3,(THIS_FILE, "Keycode '%c' (%d) is pressed", kc, kc)); break; } PrintMenu(); if (reschedule) Run(); }
void playTaunt(int index) { if (g_num_taunts[index] > 0) { int sndIndex = 0; if (g_num_taunts[index] > 1) { sndIndex = (int) random(g_num_taunts[index]); } if (g_tauntHandles[index] != 0) { snd_stop(g_tauntHandles[index]); g_tauntHandles[index] = 0; } SOUND** sndArr = g_taunts[index]; if (sndArr != null) { SOUND* snd = sndArr[sndIndex]; if (snd != null) { g_tauntHandles[index] = snd_play(snd, g_tauntVolume, 0); } } } }
/** * Do cleanup when leaving a mission */ void training_mission_shutdown() { int i; if (Training_voice >= 0) { if (Training_voice_type) { audiostream_close_file(Training_voice_handle, 0); } else { snd_stop(Training_voice_handle); } } // Goober5000 for (i = 0; i < TRAINING_MESSAGE_QUEUE_MAX; i++) { if (Training_message_queue[i].special_message != NULL) { vm_free(Training_message_queue[i].special_message); Training_message_queue[i].special_message = NULL; } } Training_voice = -1; Training_num_lines = Training_obj_num_lines = 0; *Training_buf = 0; }
// hud_stop_looped_locking_sounds() will terminate any hud related looping sounds that are playing void hud_stop_looped_locking_sounds() { if ( Missile_track_loop > -1 ) { snd_stop(Missile_track_loop); Missile_track_loop = -1; } }
// hud_stop_looped_locking_sounds() will terminate any hud related looping sounds that are playing void hud_stop_looped_locking_sounds() { if (Missile_track_loop.isValid()) { snd_stop(Missile_track_loop); Missile_track_loop = sound_handle::invalid(); } }
void gamesnd_play_iface(int n) { if (Snds_iface_handle[n] >= 0) snd_stop(Snds_iface_handle[n]); Snds_iface_handle[n] = snd_play(&Snds_iface[n]); }
/** * Terminates any looping afterburner sounds. * This should only be called when the game decides to stop all looping sounds. */ void afterburner_stop_sounds() { if ( Player_afterburner_loop_id != -1 ) { snd_stop(Player_afterburner_loop_id); } Player_afterburner_loop_id = -1; Player_disengage_timer = 1; Player_afterburner_loop_delay = 0; }
/* Shutdown application */ static void app_fini() { if (strm) snd_stop(); pjmedia_aud_subsys_shutdown(); pjmedia_delay_buf_destroy(delaybuf); pj_pool_release(pool); pj_caching_pool_destroy(&cp); pj_shutdown(); }
// ---------------------------------------------------------------------------- // afterburner_stop_sounds() // // Terminates any looping afterburner sounds. // This should only be called when the game decides to stop all looping sounds. // void afterburner_stop_sounds() { if (Player_afterburner_loop_id != -1) { snd_stop(Player_afterburner_loop_id); // nprintf(("Alan","STOP LOOPING SOUND\n")); } Player_afterburner_loop_id = -1; Player_disengage_timer = 1; Player_afterburner_loop_delay = 0; }
// called to do cleanup when leaving a mission void training_mission_shutdown() { if (Training_voice >= 0) { if (Training_voice_type) { audiostream_close_file(Training_voice_handle, 0); } else { snd_stop(Training_voice_handle); } } Training_voice = -1; Training_num_lines = Training_obj_num_lines = 0; *Training_text = 0; }
void HudGaugeRadarDradis::doLoopSnd() { if (this->m_loop_snd < 0) { return; } if (!this->shouldDoSounds()) { if (loop_sound_handle >= 0 && snd_is_playing(loop_sound_handle)) { snd_stop(loop_sound_handle); loop_sound_handle = -1; } } else if (this->loop_sound_handle < 0 || !snd_is_playing(this->loop_sound_handle)) { loop_sound_handle = snd_play(&Snds[m_loop_snd], 0.0f, loop_sound_volume); } }
// plays the voice file associated with a training message. Automatically streams the file // from disk if it's over 100k, otherwise plays it as a normal file in memory. Returns -1 // if it didn't play, otherwise index of voice int message_play_training_voice(int index) { int len; CFILE *fp; if (index < 0) { if (Training_voice >= 0) { if (Training_voice_type) { audiostream_close_file(Training_voice_handle, 0); } else { snd_stop(Training_voice_handle); } } Training_voice = -1; return -1; } if (Message_waves[index].num < 0) { fp = cfopen(Message_waves[index].name, "rb"); if (!fp) return -1; len = cfilelength(fp); cfclose(fp); if (len > 100000) { if ((Training_voice < 0) || !Training_voice_type || (Training_voice != index)) { if (Training_voice >= 0) { if (Training_voice_type) { if (Training_voice == index) audiostream_stop(Training_voice_handle, 1, 0); else audiostream_close_file(Training_voice_handle, 0); } else { snd_stop(Training_voice_handle); } } if (stricmp(Message_waves[index].name, NOX("none.wav"))) { Training_voice_handle = audiostream_open(Message_waves[index].name, ASF_VOICE); if (Training_voice_handle < 0) { nprintf(("Warning", "Unable to load voice file %s\n", Message_waves[index].name)); // Warning(LOCATION, "Unable to load voice file %s\n", Message_waves[index].name); } } } // Training_voice should be valid and loaded now Training_voice_type = 1; if (Training_voice_handle >= 0) audiostream_play(Training_voice_handle, Master_voice_volume, 0); Training_voice = index; return Training_voice; } else { game_snd tmp_gs; memset(&tmp_gs, 0, sizeof(game_snd)); strcpy(tmp_gs.filename, Message_waves[index].name); Message_waves[index].num = snd_load(&tmp_gs, 0); if (Message_waves[index].num < 0) { nprintf(("Warning", "Cannot load message wave: %s. Will not play\n", Message_waves[index].name)); return -1; } } } if (Training_voice >= 0) { if (Training_voice_type) { audiostream_close_file(Training_voice_handle, 0); } else { snd_stop(Training_voice_handle); } } Training_voice = index; if (Message_waves[index].num >= 0) Training_voice_handle = snd_play_raw(Message_waves[index].num, 0.0f); else Training_voice_handle = -1; Training_voice_type = 0; return Training_voice; }
void HudGaugeRadarDradis::render(float frametime) { float sensors_str; int ok_to_blit_radar; ok_to_blit_radar = 1; sensors_str = ship_get_subsystem_strength(Player_ship, SUBSYSTEM_SENSORS); if (ship_subsys_disrupted(Player_ship, SUBSYSTEM_SENSORS)) sensors_str = MIN_SENSOR_STR_TO_RADAR - 1; // note that on lowest skill level, there is no radar effects due to sensors damage if ((Game_skill_level == 0) || (sensors_str > SENSOR_STR_RADAR_NO_EFFECTS)) { Radar_static_playing = 0; Radar_static_next = 0; Radar_death_timer = 0; Radar_avail_prev_frame = 1; } else if (sensors_str < MIN_SENSOR_STR_TO_RADAR) { if (Radar_avail_prev_frame) { Radar_death_timer = timestamp(2000); Radar_static_next = 1; } Radar_avail_prev_frame = 0; } else { Radar_death_timer = 0; if (Radar_static_next == 0) Radar_static_next = 1; } if (timestamp_elapsed(Radar_death_timer)) ok_to_blit_radar = 0; setupViewHtl(); //WMC - This strikes me as a bit hackish bool g3_yourself = !g3_in_frame(); if(g3_yourself) g3_start_frame(1); drawSweeps(); if (timestamp_elapsed(Radar_static_next)) { Radar_static_playing ^= 1; Radar_static_next = timestamp_rand(50, 750); } // if the emp effect is active, always draw the radar wackily if (emp_active_local()) Radar_static_playing = 1; if (ok_to_blit_radar) { if (Radar_static_playing) { drawBlipsSorted(1); // passing 1 means to draw distorted if (Radar_static_looping == -1) Radar_static_looping = snd_play_looping(&Snds[SND_STATIC]); } else { drawBlipsSorted(0); if (Radar_static_looping != -1) { snd_stop(Radar_static_looping); Radar_static_looping = -1; } } } else { if (Radar_static_looping != -1) { snd_stop(Radar_static_looping); Radar_static_looping = -1; } } if(g3_yourself) g3_end_frame(); doneDrawingHtl(); }
BYTE snd_start(void) { int psamples; if (!cfg->apu.channel[APU_MASTER]) { return (EXIT_OK); } // come prima cosa blocco eventuali riproduzioni snd_stop(); memset(&snd, 0x00, sizeof(_snd)); memset(&xaudio2, 0x00, sizeof(xaudio2)); memset(&cbd, 0x00, sizeof(_callback_data)); snd.cache = &cbd; audio_channels(cfg->channels_mode); switch (cfg->samplerate) { case S48000: snd.samplerate = 48000; break; case S44100: snd.samplerate = 44100; break; case S22050: snd.samplerate = 22050; break; case S11025: snd.samplerate = 11025; break; } if (XAudio2Create(&xaudio2.engine, 0, XAUDIO2_DEFAULT_PROCESSOR) != S_OK) { MessageBox(NULL, "ATTENTION: Unable to create XAudio2 object. Probably you\n" "have an incomplete installation of DirectX 10." , "Error!", MB_ICONEXCLAMATION | MB_OK); return (EXIT_ERROR); } if (IXAudio2_CreateMasteringVoice(xaudio2.engine, &xaudio2.master, snd.channels, snd.samplerate, 0, 0, NULL) != S_OK) { MessageBox(NULL, "ATTENTION: Unable to create XAudio2 master voice.", "Error!", MB_ICONEXCLAMATION | MB_OK); return (EXIT_ERROR); } { WAVEFORMATEX wfm; memset(&wfm, 0, sizeof(wfm)); wfm.wFormatTag = WAVE_FORMAT_PCM; wfm.nChannels = snd.channels; wfm.wBitsPerSample = 16; wfm.nSamplesPerSec = snd.samplerate; wfm.nBlockAlign = (wfm.nChannels * wfm.wBitsPerSample) / 8; wfm.nAvgBytesPerSec = wfm.nSamplesPerSec * wfm.nBlockAlign; wfm.cbSize = sizeof(wfm); if (IXAudio2_CreateSourceVoice(xaudio2.engine, &xaudio2.source, &wfm, XAUDIO2_VOICE_NOSRC | XAUDIO2_VOICE_NOPITCH, XAUDIO2_DEFAULT_FREQ_RATIO, &callbacks, NULL, NULL) != S_OK) { MessageBox(NULL, "ATTENTION: Unable to create XAudio2 source voice.\n", "Error!", MB_ICONEXCLAMATION | MB_OK); return (EXIT_ERROR); } } { double factor = (1.0f / 48000.0f) * (double) snd.samplerate; psamples = ((1024 * factor) + ((512 * factor) * cfg->audio_buffer_factor)); } snd.samples = psamples * 2; snd.frequency = machine.cpu_hz / (double) snd.samplerate; xaudio2.opened = TRUE; #if !defined (RELEASE) xaudio2.tick = gui_get_ms(); #endif { // dimensione in bytes del buffer snd.buffer.size = (psamples * snd.channels * sizeof(*cbd.write)) * 5; snd.buffer.limit.low = (snd.buffer.size / 100) * 25; snd.buffer.limit.high = (snd.buffer.size / 100) * 55; #if !defined (RELEASE) printf("softw bsize : %-6d - %-6d\n", snd.buffer.size, snd.samples); printf("softw limit : %-6d - %-6d\n", snd.buffer.limit.low, snd.buffer.limit.high); #endif // alloco il buffer in memoria if (!(cbd.start = (SWORD *) malloc(snd.buffer.size))) { MessageBox(NULL, "ATTENTION: Unable to allocate audio buffers.\n", "Error!", MB_ICONEXCLAMATION | MB_OK); return (EXIT_ERROR); } if (!(cbd.silence = (SWORD *) malloc(snd.buffer.size))) { MessageBox(NULL, "ATTENTION: Unable to allocate silence buffer.\n", "Error!", MB_ICONEXCLAMATION | MB_OK); return (EXIT_ERROR); } // inizializzo il frame di scrittura cbd.write = cbd.start; // inizializzo il frame di lettura cbd.read = (SBYTE *) cbd.start; // punto alla fine del buffer cbd.end = cbd.read + snd.buffer.size; // creo il lock if ((xaudio2.semaphore = CreateSemaphore(NULL, 1, 2, NULL)) == NULL) { MessageBox(NULL, "ATTENTION: Unable to create XAudio2 semaphore.\n", "Error!", MB_ICONEXCLAMATION | MB_OK); return (EXIT_ERROR); } // azzero completamente i buffers memset(cbd.start, 0x00, snd.buffer.size); // azzero completamente il buffer del silenzio memset(cbd.silence, 0x00, snd.buffer.size); // azzero completamente la struttura XAUDIO2_BUFFER memset(&xaudio2.buffer, 0x00, sizeof(xaudio2.buffer)); xaudio2.buffer.AudioBytes = psamples * sizeof(*cbd.write) * snd.channels; //xaudio2.buffer.pAudioData = (const BYTE *) cbd.read; xaudio2.buffer.pAudioData = (const BYTE *) cbd.silence; xaudio2.buffer.PlayBegin = 0; xaudio2.buffer.PlayLength = psamples; xaudio2.buffer.LoopBegin = 0; xaudio2.buffer.LoopLength = 0; xaudio2.buffer.LoopCount = 0; xaudio2.buffer.pContext = snd.cache; cbd.xa2buffer = &xaudio2.buffer; cbd.xa2source = xaudio2.source; cbd.lock = xaudio2.semaphore; if (IXAudio2SourceVoice_SubmitSourceBuffer(xaudio2.source, (const XAUDIO2_BUFFER *) cbd.xa2buffer, NULL) != S_OK) { MessageBox(NULL, "ATTENTION: Unable to set sound engine.\n", "Error!", MB_ICONEXCLAMATION | MB_OK); return (EXIT_ERROR); } } if (extcl_snd_start) { extcl_snd_start((WORD) snd.samplerate); } audio_channels_init_mode(); audio_quality(cfg->audio_quality); if(IXAudio2_StartEngine(xaudio2.engine) != S_OK) { MessageBox(NULL, "ATTENTION: Unable to start sound engine.\n", "Error!", MB_ICONEXCLAMATION | MB_OK); return (EXIT_ERROR); } if(IXAudio2SourceVoice_Start(xaudio2.source, 0, XAUDIO2_COMMIT_NOW) != S_OK) { MessageBox(NULL, "ATTENTION: Unable to start source voice.\n", "Error!", MB_ICONEXCLAMATION | MB_OK); return (EXIT_ERROR); } return (EXIT_OK); }
void snd_quit(void) { snd_stop(); }
// hud_do_lock_indicator() manages missle locking, both the non-rendering calculations and the 2D HUD rendering void hud_do_lock_indicator(float frametime) { ship_weapon *swp; weapon_info *wip; // if i'm a multiplayer observer, bail here if((Game_mode & GM_MULTIPLAYER) && ((Net_player->flags & NETINFO_FLAG_OBSERVER) || (Player_obj->type == OBJ_OBSERVER)) ){ return; } Assert(Player_ai->target_objnum >= 0); // be sure to unset this flag, then possibly set later in this function so that // threat indicators work properly. Player_ai->ai_flags.remove(AI::AI_Flags::Seek_lock); if ( hud_abort_lock() ) { hud_lock_reset(); return; } // if there is an EMP effect active, never update lock if(emp_active_local()){ hud_lock_reset(); return; } swp = &Player_ship->weapons; wip = &Weapon_info[swp->secondary_bank_weapons[swp->current_secondary_bank]]; Lock_start_dist = wip->min_lock_time * wip->lock_pixels_per_sec; // if secondary weapons change, reset the lock if ( hud_lock_secondary_weapon_changed(swp) ) { hud_lock_reset(); } Player_ai->last_secondary_index = swp->current_secondary_bank; object *tobjp = &Objects[Player_ai->target_objnum]; vec3d dir_to_target; vm_vec_normalized_dir(&dir_to_target, &tobjp->pos, &Player_obj->pos); if ( !(wip->is_locked_homing()) ) { hud_lock_reset(); return; } // Allow locking on ships and bombs (only targeted weapon allowed is a bomb, so don't bother checking flags) if ( (Objects[Player_ai->target_objnum].type != OBJ_SHIP) && (Objects[Player_ai->target_objnum].type != OBJ_WEAPON) ) { hud_lock_reset(); return; } // Javelins must lock on engines if locking on a ship and those must be in sight if (wip->wi_flags[Weapon::Info_Flags::Homing_javelin] && tobjp->type == OBJ_SHIP && Player->locking_subsys != NULL) { vec3d subobj_pos; vm_vec_unrotate(&subobj_pos, &Player->locking_subsys->system_info->pnt, &tobjp->orient); vm_vec_add2(&subobj_pos, &tobjp->pos); int target_subsys_in_sight = ship_subsystem_in_sight(tobjp, Player->locking_subsys, &Player_obj->pos, &subobj_pos); if (!target_subsys_in_sight || Player->locking_subsys->system_info->type != SUBSYSTEM_ENGINE) { Player->locking_subsys = ship_get_closest_subsys_in_sight(&Ships[tobjp->instance], SUBSYSTEM_ENGINE, &Player_obj->pos); } } if (wip->wi_flags[Weapon::Info_Flags::Homing_javelin] && tobjp->type == OBJ_SHIP && Player->locking_subsys == NULL) { Player->locking_subsys = ship_get_closest_subsys_in_sight(&Ships[tobjp->instance], SUBSYSTEM_ENGINE, &Player_obj->pos); if (Player->locking_subsys == NULL) { hud_lock_reset(); return; } } hud_lock_determine_lock_point(&lock_world_pos); if ( !hud_lock_has_homing_point() ) { Player->target_in_lock_cone=0; } hud_lock_check_if_target_in_lock_cone(); // check if the target is within range of the current secondary weapon. If it is not, // a lock will not be detected if ( !hud_lock_target_in_range() ) { Player->target_in_lock_cone = 0; } // If locking on a subsystem, and not in sight... can't lock // Changed by MK on 4/3/98. It was confusing me that my hornets would not lock on my target. // It will now be confusing that they lock, but don't home on your subsystem, but I think that's preferable. // Often you really care about destroying the target, not just the subsystem. /*if ( Player_ai->targeted_subsys ) { if ( !hud_lock_on_subsys_ok() ) { Player->target_in_lock_cone=0; } }*/ if ( !Player->target_in_lock_cone ) { Player->locking_on_center=0; Player->locking_subsys_parent=-1; Player->locking_subsys=NULL; } hud_calculate_lock_position(frametime); if (!Players[Player_num].lock_indicator_visible) return; if (Player_ai->current_target_is_locked) { if ( Missile_track_loop > -1 ) { snd_stop(Missile_track_loop); Missile_track_loop = -1; if (wip->hud_locked_snd >= 0) { Missile_lock_loop = snd_play(&Snds[wip->hud_locked_snd]); } else { Missile_lock_loop = snd_play(&Snds[ship_get_sound(Player_obj, SND_MISSILE_LOCK)]); } } } else { Player_ai->ai_flags.set(AI::AI_Flags::Seek_lock); // set this flag so multiplayer's properly track lock on other ships if ( Missile_lock_loop != -1 && snd_is_playing(Missile_lock_loop) ) { snd_stop(Missile_lock_loop); Missile_lock_loop = -1; } } }
// hud_calculate_lock_position() will determine where on the screen to draw the lock // indicator, and will determine when a lock has occurred. If the lock indicator is not // on the screen yet, hud_calculate_lock_start_pos() is called to pick a starting location void hud_calculate_lock_position(float frametime) { ship_weapon *swp; weapon_info *wip; static float pixels_moved_while_locking; static float pixels_moved_while_degrading; static int Need_new_start_pos = 0; static double accumulated_x_pixels, accumulated_y_pixels; double int_portion; static float last_dist_to_target; static int catching_up; static int maintain_lock_count = 0; static float catch_up_distance = 0.0f; double hypotenuse, delta_x, delta_y; swp = &Player_ship->weapons; wip = &Weapon_info[swp->secondary_bank_weapons[swp->current_secondary_bank]]; if (Player->target_in_lock_cone) { if (!Players[Player_num].lock_indicator_visible) { hud_calculate_lock_start_pos(); last_dist_to_target = 0.0f; Players[Player_num].lock_indicator_x = Players[Player_num].lock_indicator_start_x; Players[Player_num].lock_indicator_y = Players[Player_num].lock_indicator_start_y; Players[Player_num].lock_indicator_visible = 1; Players[Player_num].lock_time_to_target = i2fl(wip->min_lock_time); catching_up = 0; } Need_new_start_pos = 1; if (Player_ai->current_target_is_locked) { Players[Player_num].lock_indicator_x = Player->current_target_sx; Players[Player_num].lock_indicator_y = Player->current_target_sy; return; } delta_x = Players[Player_num].lock_indicator_x - Player->current_target_sx; delta_y = Players[Player_num].lock_indicator_y - Player->current_target_sy; if (!delta_y && !delta_x) { hypotenuse = 0; } else { hypotenuse = _hypot(delta_y, delta_x); } Players[Player_num].lock_dist_to_target = (float)hypotenuse; if (last_dist_to_target == 0) { last_dist_to_target = Players[Player_num].lock_dist_to_target; } //nprintf(("Alan","dist to target: %.2f\n",Players[Player_num].lock_dist_to_target)); //nprintf(("Alan","last to target: %.2f\n\n",last_dist_to_target)); if (catching_up) { //nprintf(("Alan","IN CATCH UP MODE catch_up_dist is %.2f\n",catch_up_distance)); if ( Players[Player_num].lock_dist_to_target < catch_up_distance ) catching_up = 0; } else { //nprintf(("Alan","IN NORMAL MODE\n")); if ( (Players[Player_num].lock_dist_to_target - last_dist_to_target) > 2.0f ) { catching_up = 1; catch_up_distance = last_dist_to_target + wip->catchup_pixel_penalty; } } last_dist_to_target = Players[Player_num].lock_dist_to_target; if (!catching_up) { Players[Player_num].lock_time_to_target -= frametime; if (Players[Player_num].lock_time_to_target < 0.0f) Players[Player_num].lock_time_to_target = 0.0f; } float lock_pixels_per_sec; if (Players[Player_num].lock_time_to_target > 0) { lock_pixels_per_sec = Players[Player_num].lock_dist_to_target / Players[Player_num].lock_time_to_target; } else { lock_pixels_per_sec = i2fl(wip->lock_pixels_per_sec); } if (lock_pixels_per_sec > wip->lock_pixels_per_sec) { lock_pixels_per_sec = i2fl(wip->lock_pixels_per_sec); } if (catching_up) { pixels_moved_while_locking = wip->catchup_pixels_per_sec * frametime; } else { pixels_moved_while_locking = lock_pixels_per_sec * frametime; } if ((delta_x != 0) && (hypotenuse != 0)) { accumulated_x_pixels += pixels_moved_while_locking * delta_x/hypotenuse; } if ((delta_y != 0) && (hypotenuse != 0)) { accumulated_y_pixels += pixels_moved_while_locking * delta_y/hypotenuse; } if (fl_abs((float)accumulated_x_pixels) > 1.0f) { modf(accumulated_x_pixels, &int_portion); Players[Player_num].lock_indicator_x -= (int)int_portion; if ( fl_abs((float)Players[Player_num].lock_indicator_x - (float)Player->current_target_sx) < fl_abs((float)int_portion) ) Players[Player_num].lock_indicator_x = Player->current_target_sx; accumulated_x_pixels -= int_portion; } if (fl_abs((float)accumulated_y_pixels) > 1.0f) { modf(accumulated_y_pixels, &int_portion); Players[Player_num].lock_indicator_y -= (int)int_portion; if ( fl_abs((float)Players[Player_num].lock_indicator_y - (float)Player->current_target_sy) < fl_abs((float)int_portion) ) Players[Player_num].lock_indicator_y = Player->current_target_sy; accumulated_y_pixels -= int_portion; } if ( Missile_track_loop == -1 ) { if (wip->hud_tracking_snd >= 0) { Missile_track_loop = snd_play_looping( &Snds[wip->hud_tracking_snd], 0.0f , -1, -1); } else { Missile_track_loop = snd_play_looping( &Snds[ship_get_sound(Player_obj, SND_MISSILE_TRACKING)], 0.0f , -1, -1); } } if (!Players[Player_num].lock_time_to_target) { if ( (Players[Player_num].lock_indicator_x == Player->current_target_sx) && (Players[Player_num].lock_indicator_y == Player->current_target_sy) ) { if (maintain_lock_count++ > 1) { Player_ai->current_target_is_locked = 1; } } else { maintain_lock_count = 0; } } } else { if ( Missile_track_loop > -1 ) { snd_stop(Missile_track_loop); Missile_track_loop = -1; } Player_ai->current_target_is_locked = 0; if (!Players[Player_num].lock_indicator_visible) { return; } catching_up = 0; last_dist_to_target = 0.0f; if (Need_new_start_pos) { hud_calculate_lock_start_pos(); Need_new_start_pos = 0; accumulated_x_pixels = 0.0f; accumulated_y_pixels = 0.0f; } delta_x = Players[Player_num].lock_indicator_x - Players[Player_num].lock_indicator_start_x; delta_y = Players[Player_num].lock_indicator_y - Players[Player_num].lock_indicator_start_y; if (!delta_y && !delta_x) { hypotenuse = 0; } else { hypotenuse = _hypot(delta_y, delta_x); } Players[Player_num].lock_time_to_target += frametime; if (Players[Player_num].lock_time_to_target > wip->min_lock_time) Players[Player_num].lock_time_to_target = i2fl(wip->min_lock_time); pixels_moved_while_degrading = 2.0f * wip->lock_pixels_per_sec * frametime; if ((delta_x != 0) && (hypotenuse != 0)) accumulated_x_pixels += pixels_moved_while_degrading * delta_x/hypotenuse; if ((delta_y != 0) && (hypotenuse != 0)) accumulated_y_pixels += pixels_moved_while_degrading * delta_y/hypotenuse; if (fl_abs((float)accumulated_x_pixels) > 1.0f) { modf(accumulated_x_pixels, &int_portion); Players[Player_num].lock_indicator_x -= (int)int_portion; if ( fl_abs((float)Players[Player_num].lock_indicator_x - (float)Players[Player_num].lock_indicator_start_x) < fl_abs((float)int_portion) ) Players[Player_num].lock_indicator_x = Players[Player_num].lock_indicator_start_x; accumulated_x_pixels -= int_portion; } if (fl_abs((float)accumulated_y_pixels) > 1.0f) { modf(accumulated_y_pixels, &int_portion); Players[Player_num].lock_indicator_y -= (int)int_portion; if ( fl_abs((float)Players[Player_num].lock_indicator_y - (float)Players[Player_num].lock_indicator_start_y) < fl_abs((float)int_portion) ) Players[Player_num].lock_indicator_y = Players[Player_num].lock_indicator_start_y; accumulated_y_pixels -= int_portion; } if ( (Players[Player_num].lock_indicator_x == Players[Player_num].lock_indicator_start_x) && (Players[Player_num].lock_indicator_y == Players[Player_num].lock_indicator_start_y) ) { Players[Player_num].lock_indicator_visible = 0; } } }
void creditsText () { static char strIni [256]; sprintf(strIni, "%s\\credits.ini", _chr(work_dir)); // start music and lyrics { snd_stop(g_fhCreditsSong); g_fhCreditsSong = snd_play(g_musicCredits, 100, 0); lyricsStart(NULL, g_txtCreditsLyrics, g_fhCreditsSong); } int pos = 0; int count = ini_read_int(strIni, "Credits", "max", "0"); var duration = ini_read_int(strIni, "Credits", "duration", "15"); var itemDuration = duration / (var)count; creditsHead1.flags |= SHOW; creditsBody1.flags |= SHOW; creditsHead2.flags |= SHOW; creditsBody2.flags |= SHOW; creditsHead2.pos_y = screen_size.y - g_lyricsBarHeight - 150; creditsBody2.pos_y = screen_size.y - g_lyricsBarHeight - 100; int size1 = 300; int size2 = 600; var x = 0; var len = 0; while (snd_playing(g_fhCreditsSong) != 0 && !g_bCreditsAllExplode) { static char section [256]; sprintf(section, "Credit%d", pos + 1); ini_read(creditsText1Head, strIni, section, "Head1", " "); ini_read(creditsText1Body, strIni, section, "Body1", " "); ini_read(creditsText2Head, strIni, section, "Head2", " "); ini_read(creditsText2Body, strIni, section, "Body2", " "); str_replaceall(creditsText1Body, "##", "\n"); str_replaceall(creditsText2Body, "##", "\n"); creditsHead1.pos_x = -size1; creditsBody1.pos_x = -size1; creditsHead2.pos_x = screen_size.x + size2; creditsBody2.pos_x = screen_size.x + size2; var fadetime = 0.22 * itemDuration; var fade = 0; var fadespeed = 16 / fadetime; for (fade = 0; fade < 100; fade += fadespeed * time_step) { creditsHead1.pos_x = -size1 + 1.5 * size1 * (1 - pow(1 - 0.01 * fade, 2)); creditsBody1.pos_x = -size1 + 1.7 * size1 * (1 - pow(1 - 0.01 * fade, 2)); if (g_bCreditsAllExplode) break; wait(1); } for (fade = 0; fade < 100; fade += fadespeed * time_step) { creditsHead2.pos_x = screen_size.x + size2 - 1.2 * size2 * (1 - pow(1 - 0.01 * fade, 2)); creditsBody2.pos_x = screen_size.x + size2 - 1.3 * size2 * (1 - pow(1 - 0.01 * fade, 2)); if (g_bCreditsAllExplode) break; wait(1); } var t_id = 0.6 * itemDuration * 16; while (t_id > 0 && !g_bCreditsAllExplode) { t_id -= time_step; wait(1); } var scrollspeed = 100; for (fade = 0; fade < 100; fade += fadespeed * time_step) { creditsHead1.pos_x += scrollspeed * time_step; if (fade > 20) creditsBody1.pos_x += scrollspeed * time_step; if (g_bCreditsAllExplode) break; wait(1); } for (fade = 0; fade < 100; fade += fadespeed * time_step) { creditsHead2.pos_x -= scrollspeed * time_step; if (fade > 20) creditsBody2.pos_x -= scrollspeed * time_step; if (g_bCreditsAllExplode) break; wait(1); } pos += 1; wait(1); } snd_stopall(4); creditsHead1.flags &= ~SHOW; creditsBody1.flags &= ~SHOW; creditsHead2.flags &= ~SHOW; creditsBody2.flags &= ~SHOW; g_bCreditsAllExplode = true; creditsFinished = true; var et = 5 * 16; while (et > 0) { camera->tilt += time_step * 0.2; camera->arc += time_step * 0.2; et -= time_step; wait(1); } // show space text { set(g_txtCreditsSpace, SHOW); g_txtCreditsSpace->pos_x = screen_size.x / 2; g_txtCreditsSpace->pos_y = screen_size.y * 0.8; on_space = creditsSpace; } }
static void ogg_play_task(mp_callback_func cb) { long ret = 0; int current_section = 0; double time_seek_to = 0; vorbis_info *vi; struct snd_device *sound_dev; int *processed_pcm; double song_time; PE_DBG_PRINTF("MusicEngine: ==> ogg_play_task()! \n"); sound_dev = (struct snd_device*)dev_get_by_type(NULL, HLD_DEV_TYPE_SND); processed_pcm = (int*)ogg_file->processed_pcm_buff; if (ov_open(ogg_file->file, &ogg_file->vf, NULL, 0) < 0) { PE_DBG_PRINTF("MusicEngine: ogg_play_task() ov_open failed! \n"); #ifdef ENABLE_PE_CACHE pe_cache_close(ogg_cache_id); // 这个ogg_cache_id是在play_file时打开 ogg_cache_id = -1; #else fclose(ogg_file->file); #endif //FREE(processed_pcm); osal_flag_set(ogg_engine.ogg_engine_flag_id, OGG_ENGINE_FLAG_UNSUCCESSFUL); return; } else { PE_DBG_PRINTF("MusicEngine: ov_opened \n"); { vorbis_info *vi = ov_info(&ogg_file->vf, -1); if (!vi) { PE_DBG_PRINTF("MusicEngine: ov_info failed!\n"); ov_clear(&ogg_file->vf); osal_flag_set(ogg_engine.ogg_engine_flag_id, OGG_ENGINE_FLAG_UNSUCCESSFUL); return; } ogg_file->samplerate = vi->rate; ogg_file->channel = vi->channels; PE_DBG_PRINTF("\nBitstream is %d channel, %ldHz\n", vi->channels, vi->rate); song_time = ov_time_total(&ogg_file->vf, -1); if (song_time <= 0) { PE_DBG_PRINTF("MusicEngine: ov_info failed!\n"); ov_clear(&ogg_file->vf); osal_flag_set(ogg_engine.ogg_engine_flag_id, OGG_ENGINE_FLAG_UNSUCCESSFUL); } } osal_flag_set(ogg_engine.ogg_engine_flag_id, OGG_ENGINE_FLAG_SUCCESS); } //all work success, we can start to play while (ogg_file->command != OGG_CMD_STOP) { if (ogg_file->seek_to != 0) { time_seek_to = ov_time_tell(&ogg_file->vf); time_seek_to = time_seek_to + (ogg_file->seek_to * 1000); if (time_seek_to < 0) { time_seek_to = 0; } else if (time_seek_to > song_time) { time_seek_to = song_time; } ret = ov_time_seek(&ogg_file->vf, time_seek_to); if (ret < 0) { //seek failed } osal_task_dispatch_off(); ogg_file->seek_to = 0; osal_task_dispatch_on(); } if (ogg_file->command == OGG_CMD_NONE) { ret = ov_read(&ogg_file->vf, (void *)ogg_file->pcm_out_buff, 2304, ¤t_section); if (ret == 0) { PE_DBG_PRINTF("file end!\n"); //EOF we need call back osal_task_dispatch_off(); if (ogg_file->command != OGG_CMD_STOP) { ogg_file->command = OGG_CMD_WAIT_FOR_STOP; } osal_task_dispatch_on(); cb(MP_MUSIC_PLAYBACK_END, 0); osal_task_sleep(10); } else if (ret < 0) { PE_DBG_PRINTF("error!!!\n"); /* error in the stream. Not a problem, just reporting it in case we (the app) cares. In this case, we don't. */ osal_task_dispatch_off(); if (ogg_file->command != OGG_CMD_STOP) { ogg_file->command = OGG_CMD_WAIT_FOR_STOP; } osal_task_dispatch_on(); cb(MP_MUSIC_PLAYBACK_END, 0); osal_task_sleep(10); } else { /* we don't bother dealing with sample rate changes, etc, but you'll have to*/ process_ogg_pcm(sound_dev, ret, processed_pcm); } } else { osal_task_sleep(10); } } ov_clear(&ogg_file->vf); ogg_avoid_under_run = 0; snd_io_control(sound_dev, SND_CC_MUTE, 0); snd_stop(sound_dev); //FREE(processed_pcm); osal_flag_set(ogg_engine.ogg_engine_flag_id, OGG_ENGINE_FLAG_TASK_EXIT); // task结束,发出EXIT消息 PE_DBG_PRINTF("MusicEngine: <== ogg_play_task()! \n"); }
void rain_off() { render_rain_stop(); snd_stop(rhandle); }
/* * Ogg-Vorbis read() callback * Called by both ov_info() and ov_read() * * This functions dequeues buffers from the fifo * */ size_t snd_ov_read_callback(void *ptr, size_t size, size_t nmemb, void* session) { struct despotify_session* ds = session; pthread_mutex_lock(&ds->fifo->lock); int totlength = 0; bool loop = true; /* process data */ while (loop) { /* Check queue status */ if (ds->fifo->start == NULL) { _DSFYDEBUG ("Waiting for data (%d bytes)\n", ds->fifo->totbytes); pthread_cond_wait (&ds->fifo->cs, &ds->fifo->lock); _DSFYDEBUG ("Got data\n"); } DSFYDEBUG_SNDQUEUE("Processing one buffer at ds->fifo->start." " %zd items of size %zd requested. Totbytes: %d\n", size, nmemb, ds->fifo->totbytes ); struct ds_snd_buffer* b = ds->fifo->start; if (!b) break; _DSFYDEBUG("loop cmd:%d bytes:%d\n", b->cmd, ds->fifo->totbytes); switch (b->cmd) { case SND_CMD_START: /* first packet of a track */ DSFYDEBUG ("Got SND_CMD_START\n"); /* Increment by one */ ds->fifo->start = ds->fifo->start->next; /* notify client */ if (ds->client_callback) ds->client_callback(ds, DESPOTIFY_NEW_TRACK, b->ptr, ds->client_callback_data); /* If this was the last entry */ if (b == ds->fifo->end) ds->fifo->end = NULL; if (b->ptr) DSFYfree (b->ptr); DSFYfree (b); break; case SND_CMD_DATA: { /* data packet */ int remaining = b->length - b->consumed; int ptrsize = size * nmemb; int length; if (totlength + remaining < ptrsize) length = remaining; /* The entire buffer will fit */ else { length = ptrsize - totlength; /* Don't overrun ptrsize */ } memcpy (ptr + totlength, b->ptr + b->consumed, length); b->consumed += length; totlength += length; /* If we have used the entire buffer, free it */ if (b->consumed == b->length) { ds->fifo->start = ds->fifo->start->next; ds->fifo->totbytes -= b->length; /* If this was the last entry */ if (b == ds->fifo->end) ds->fifo->end = NULL; DSFYfree (b->ptr); DSFYfree (b); } /* exit if input is empty or output is full */ if (!ds->fifo->start || totlength == (int)(size*nmemb)) loop = false; break; } case SND_CMD_END: /* last packet of a track, return 0 bytes to signal EOF */ DSFYDEBUG ("Got SND_CMD_END\n"); /* if there already are bytes to return, send them first and then come back here empty */ if (totlength) { loop = false; break; } /* Increment by one */ ds->fifo->start = ds->fifo->start->next; /* If this was the last entry */ if (b == ds->fifo->end) ds->fifo->end = NULL; /* If this was the last entry */ if (b == ds->fifo->end) ds->fifo->end = NULL; if (b->ptr) DSFYfree (b->ptr); DSFYfree (b); _DSFYDEBUG("Calling despotify_end_of_track\n"); if (!ds->fifo->start) { /* (snd_stop locks the mutex internally) */ pthread_mutex_unlock(&ds->fifo->lock); snd_stop(ds); pthread_mutex_lock(&ds->fifo->lock); if (ds->client_callback) ds->client_callback(ds, DESPOTIFY_END_OF_PLAYLIST, NULL, ds->client_callback_data); } /* return 0 bytes as EOF marker to decoder */ loop = false; break; } } pthread_mutex_unlock(&ds->fifo->lock); /* Return number of bytes read to ogg-layer */ _DSFYDEBUG("Returning %d bytes. %d left.\n", totlength, ds->fifo->totbytes); return totlength; }
void game_start() { #ifndef SKIP_INTRO resetPpSwirl (); level_load("menu2.wmb"); wait(3); setHdr(LVL_INTRO_HDR_STRENGTH, LVL_INTRO_HDR_THRESHOLD, LVL_INTRO_HDR_EXPOSURE); camera->arc = 60; camera->ambient = 0; fog_color = 0; camera_path("path1"); PANEL* panBlack = pan_create(" ", 100); vec_set(panBlack.blue, vector(8,8,8)); pan_setdigits(panBlack, 0, 5, 5, "Press [Space] to skip", font_create("Arial#24b"), 1, vDummy); pan_setcolor(panBlack, 1, 1, vector(255,255,255)); set(panBlack, SHOW | LIGHT | OVERLAY); var vMediaHandle = snd_play(g_musicIntro, 100, 0); while (key_esc || key_space || key_enter) wait(1); while (snd_playing(vMediaHandle) && !key_esc && !key_space && !key_enter) wait(1); proc_kill((void*)camera_path); ptr_remove(panBlack); snd_stop(vMediaHandle); vMediaHandle = 0; #endif nPlayerLifes = 3; flying_man = 0; gui_start(); // standard start level = temple #ifndef SKIP_TO lvlTempleInit(); #else #ifdef SKIP_TO_LOTTIFANTLEVEL lvlLfInit(); #endif #ifdef SKIP_TO_BOSSLEVEL lvlBossInit(); #endif #ifdef SKIP_TO_LAVASTAGE lvlLavastageInit(); #endif #ifdef SKIP_TO_CREDITS creditsInit(); #endif #endif }
void radar_frame_render(float frametime) { float sensors_str; int ok_to_blit_radar; ok_to_blit_radar = 1; sensors_str = ship_get_subsystem_strength( Player_ship, SUBSYSTEM_SENSORS ); if ( ship_subsys_disrupted(Player_ship, SUBSYSTEM_SENSORS) ) { sensors_str = MIN_SENSOR_STR_TO_RADAR-1; } // note that on lowest skill level, there is no radar effects due to sensors damage if ( (Game_skill_level == 0) || (sensors_str > SENSOR_STR_RADAR_NO_EFFECTS) ) { Radar_static_playing = 0; Radar_static_next = 0; Radar_death_timer = 0; Radar_avail_prev_frame = 1; } else if ( sensors_str < MIN_SENSOR_STR_TO_RADAR ) { if ( Radar_avail_prev_frame ) { Radar_death_timer = timestamp(2000); Radar_static_next = 1; } Radar_avail_prev_frame = 0; } else { Radar_death_timer = 0; if ( Radar_static_next == 0 ) Radar_static_next = 1; } if ( timestamp_elapsed(Radar_death_timer) ) { ok_to_blit_radar = 0; } hud_set_gauge_color(HUD_RADAR); radar_blit_gauge(); radar_draw_range(); if ( timestamp_elapsed(Radar_static_next) ) { Radar_static_playing ^= 1; Radar_static_next = timestamp_rand(50, 750); } // if the emp effect is active, always draw the radar wackily if(emp_active_local()){ Radar_static_playing = 1; } if ( ok_to_blit_radar ) { if ( Radar_static_playing ) { radar_draw_blips_sorted(1); // passing 1 means to draw distorted if ( Radar_static_looping == -1 ) { Radar_static_looping = snd_play_looping(&Snds[SND_STATIC]); } } else { radar_draw_blips_sorted(); if ( Radar_static_looping != -1 ) { snd_stop(Radar_static_looping); Radar_static_looping = -1; } } } else { if ( Radar_static_looping != -1 ) { snd_stop(Radar_static_looping); Radar_static_looping = -1; } } }
// ---------------------------------------------------------------------------- // afterburners_update() // // Update the state of the afterburner fuel remaining for an object using the // afterburner. // // for the player ship, key_up_time() is called for the afterburner key to // detect when afterburners disengage. // // input: *objp => pointer to the object starting afterburners // fl_frametime => time in seconds of the last frame // void afterburners_update(object* objp, float fl_frametime) { Assert(objp != NULL); Assert(objp->type == OBJ_SHIP); Assert(objp->instance >= 0 && objp->instance < MAX_SHIPS); ship_info* sip; ship* shipp; static int volume_chg_timer = 1; shipp = &Ships[objp->instance]; Assert(shipp->ship_info_index >= 0 && shipp->ship_info_index < Num_ship_classes); sip = &Ship_info[shipp->ship_info_index]; if ((objp->flags & OF_PLAYER_SHIP) && (Game_mode & GM_DEAD)) { return; } if (!(sip->flags & SIF_AFTERBURNER)) { return; // nothing to update, afterburners are not even on the ship } //shut the afterburners off if we're using the booster tertiary //shut the afterburners off if we're in glide mode. if ((objp->phys_info.flags & PF_AFTERBURNER_ON) && ((objp->phys_info.flags & PF_BOOSTER_ON) || (objp->phys_info.flags & PF_GLIDING))) { if (objp == Player_obj) afterburner_stop_sounds(); afterburners_stop(objp); return; } if (objp == Player_obj) { if (!timestamp_elapsed(Player_disengage_timer)) { float remaining; remaining = timestamp_until(Player_disengage_timer) / i2fl(DISENGAGE_TIME); if (remaining <= 0) { afterburner_stop_sounds(); } else { if (remaining > 1.0f) { remaining = 1.0f; } snd_set_volume(Player_afterburner_loop_id, remaining * Player_afterburner_vol); } } else { if (Player_disengage_timer != 1) { afterburner_stop_sounds(); } } } // single player, multiplayer servers, and clients for their own ships if (!(Game_mode & GM_MULTIPLAYER) || MULTIPLAYER_MASTER || (objp == Player_obj)) { if (!(objp->phys_info.flags & PF_AFTERBURNER_ON)) { // Recover afterburner fuel if (shipp->afterburner_fuel < sip->afterburner_fuel_capacity) { float recharge_scale; recharge_scale = Energy_levels[shipp->engine_recharge_index] * 2.0f * The_mission.ai_profile-> afterburner_recharge_scale[Game_skill_level]; shipp->afterburner_fuel += (sip->afterburner_recover_rate * fl_frametime * recharge_scale); if (shipp->afterburner_fuel > sip->afterburner_fuel_capacity) { shipp->afterburner_fuel = sip->afterburner_fuel_capacity; } } return; } else { // Check if there is enough afterburner fuel if (shipp->afterburner_fuel <= 0) { shipp->afterburner_fuel = 0.0f; afterburners_stop(objp); return; } } // afterburners are firing at this point // Reduce the afterburner fuel shipp->afterburner_fuel -= (sip->afterburner_burn_rate * fl_frametime); if (shipp->afterburner_fuel < 0.0f) { shipp->afterburner_fuel = 0.0f; } } if (objp == Player_obj) { if ((Viewer_mode & VM_NOT_COCKPIT)) { // stop afterburner sound if it is playing if (Player_afterburner_loop_id != -1) { snd_stop(Player_afterburner_loop_id); Player_afterburner_loop_id = -1; } return; } if (timestamp_elapsed(Player_afterburner_loop_delay)) { Player_afterburner_vol = Snds[SND_ABURN_LOOP].default_volume; Player_afterburner_loop_delay = timestamp(50); if (Player_afterburner_loop_id == -1) { Player_afterburner_loop_id = snd_play_looping(&Snds[SND_ABURN_LOOP], 0.0f, -1, -1, Player_afterburner_vol); //snd_set_volume(Player_afterburner_loop_id, Player_afterburner_vol); // nprintf(("Alan","PLAY LOOPING SOUND\n")); } } // Reduce the volume of the afterburner sound if near the end if (timestamp_elapsed(volume_chg_timer)) { float percent_afterburner_left; percent_afterburner_left = shipp->afterburner_fuel / sip->afterburner_fuel_capacity; volume_chg_timer = timestamp(AFTERBURNER_VOLUME_UPDATE); if (percent_afterburner_left < AFTERBURNER_PERCENT_VOL_ATTENUATE) { Player_afterburner_vol = percent_afterburner_left * (1 / AFTERBURNER_PERCENT_VOL_ATTENUATE) * Snds[SND_ABURN_LOOP].default_volume; snd_set_volume(Player_afterburner_loop_id, Player_afterburner_vol); } } // end if (timestamp_elapsed(volume_chg_timer)) } }
// hud_update_lock_indicator() will manage the non-rendering dependant part of // missle locking void hud_update_lock_indicator(float frametime) { ship_weapon *swp; weapon_info *wip; vector lock_world_pos; #ifndef NO_NETWORK // if i'm a multiplayer observer, bail here if((Game_mode & GM_MULTIPLAYER) && ((Net_player->flags & NETINFO_FLAG_OBSERVER) || (Player_obj->type == OBJ_OBSERVER)) ){ return; } #endif Assert(Player_ai->target_objnum != -1); // be sure to unset this flag, then possibly set later in this function so that // threat indicators work properly. Player_ai->ai_flags &= ~AIF_SEEK_LOCK; if ( hud_abort_lock() ) { hud_lock_reset(); return; } // if there is an EMP effect active, never update lock if(emp_active_local()){ hud_lock_reset(); return; } swp = &Player_ship->weapons; wip = &Weapon_info[swp->secondary_bank_weapons[swp->current_secondary_bank]]; Lock_start_dist = wip->min_lock_time * wip->lock_pixels_per_sec; // if secondary weapons change, reset the lock if ( hud_lock_secondary_weapon_changed(swp) ) { hud_lock_reset(); } Player_ai->last_secondary_index = swp->current_secondary_bank; if ( !(wip->wi_flags & WIF_HOMING_ASPECT) ) { hud_lock_reset(); return; } // Allow locking on ships and bombs (only targeted weapon allowed is a bomb, so don't bother checking flags) if ( (Objects[Player_ai->target_objnum].type != OBJ_SHIP) && (Objects[Player_ai->target_objnum].type != OBJ_WEAPON) ) { hud_lock_reset(); return; } hud_lock_determine_lock_point(&lock_world_pos); if ( !hud_lock_has_homing_point() ) { Player->target_in_lock_cone=0; } hud_lock_check_if_target_in_lock_cone(&lock_world_pos); // check if the target is within range of the current secondary weapon. If it is not, // a lock will not be detected if ( !hud_lock_target_in_range() ) { Player->target_in_lock_cone = 0; } // If locking on a subsystem, and not in sight... can't lock // Changed by MK on 4/3/98. It was confusing me that my hornets would not lock on my target. // It will now be confusing that they lock, but don't home on your subsystem, but I think that's preferable. // Often you really care about destroying the target, not just the subsystem. /*if ( Player_ai->targeted_subsys ) { if ( !hud_lock_on_subsys_ok() ) { Player->target_in_lock_cone=0; } }*/ if ( !Player->target_in_lock_cone ) { Player->locking_on_center=0; Player->locking_subsys_parent=-1; Player->locking_subsys=NULL; } hud_calculate_lock_position(frametime); if (!Players[Player_num].lock_indicator_visible) return; if (Player_ai->current_target_is_locked) { if ( Missile_track_loop > -1 ) { snd_chg_loop_status(Missile_track_loop, 0); Missile_track_loop = -1; Missile_lock_loop = snd_play(&Snds[SND_MISSILE_LOCK]); } } else { Player_ai->ai_flags |= AIF_SEEK_LOCK; // set this flag so multiplayer's properly track lock on other ships if ( Missile_lock_loop != -1 && snd_is_playing(Missile_lock_loop) ) { snd_stop(Missile_lock_loop); Missile_lock_loop = -1; } } }
int main(int argc, char *argv[]) { struct optcfg_option options[] = { { 'p', "port", "Specify port number to serve", 0, "8888" }, { 'H', "host", "Specify host name to listen", 0, NULL }, { 'F', "fps", "Specify how many frames per second will be captured", 0, "5" }, { 'r', "root", "Specify root HTML directory", 0, NULL }, { 'c', "config", "Load configuration from file", OPTCFG_CFGFILE, NULL }, { 'd', "delay", "Sound delay and fragment size in seconds", 0, "1" }, { 'f', "frequency", "Sound frequency in Hz.", 0, "8000" }, { 'b', "bits", "Bits per fragment of sound", 0, "8" }, { 'S', "stereo", "Enable stereo mode", OPTCFG_FLAG, "no" }, { 'e', "exec", "Execute program as sound source", 0, NULL } }; unsigned options_cnt = sizeof(options) / sizeof(options[0]); struct optcfg *opts; int i; int cams[64]; unsigned cam_cnt = 64; webcam_t *cam; mihl_ctx_t *ctx; struct timeval last, cur; long dtime; int port; const char *host; int bsecs, freq, bits, stereo; const char *snd_cmd = NULL; const char *root = NULL; opts = optcfg_new(); if (!opts) { return EXIT_FAILURE; } if (optcfg_default_config(opts, "wwwcam")) { return EXIT_FAILURE; } if (optcfg_parse_options(opts, "wwwcam", argc - 1, argv + 1, options, options_cnt)) { return EXIT_FAILURE; } optcfg_save(opts, stdout); dtime = optcfg_get_int(opts, "fps", 5); if (dtime > 30 || dtime < 0) dtime = 5; dtime = 1000000 / dtime; port = optcfg_get_int(opts, "port", -1); if (port < 0) { fprintf(stderr, "Error: TCP port information is not found.\n"); return EXIT_FAILURE; } host = optcfg_get(opts, "host", NULL); root = optcfg_get(opts, "root", "."); snprintf(ROOT, sizeof(ROOT), "%s/", root); ctx = mihl_init(host, port, 16, MIHL_LOG_ERROR | MIHL_LOG_WARNING | MIHL_LOG_INFO | MIHL_LOG_INFO_VERBOSE); if (webcam_list(cams, &cam_cnt)) { fprintf(stderr, "Error: Can't get list of cameras!\n"); return 1; } if (cam_cnt == 0) { fprintf(stderr, "Error: no cameras connected!\n"); return 1; } if (!ctx) { fprintf(stderr, "Error: can't init mihl!\n"); return 1; } signal(SIGINT, sigint); cam = webcam_open(cams[0], 640, 480); if (!cam) { mihl_end(ctx); fprintf(stderr, "Error: can't open camera!\n"); return 1; } snprintf(CAM_NAME, sizeof(CAM_NAME), "WEBCAM: %s", cam->name); for (i = 0; handlers[i].path; i++) { if (handlers[i].get) { mihl_handle_get(ctx, handlers[i].path, handlers[i].get, handlers[i].param); } if (handlers[i].post) { mihl_handle_post(ctx, handlers[i].path, handlers[i].post, handlers[i].param); } } webcam_start(cam); printf("Waiting for the first frame..."); fflush(stdout); while (!FRAME) { if (webcam_wait_frame_cb(cam, new_frame, NULL, 10) < 0) { webcam_stop(cam); webcam_close(cam); mihl_end(ctx); fprintf(stderr, "Error: can't get frames from camera!\n"); return 1; } gettimeofday(&last, NULL); } printf(" Ok\n"); fflush(stdout); /* Init sound: */ snd_cmd = optcfg_get(opts, "exec", NULL); if (snd_cmd) { bsecs = optcfg_get_int(opts, "delay", 1); freq = optcfg_get_int(opts, "frequency", 8000); bits = optcfg_get_int(opts, "bits", 8); stereo = optcfg_get_flag(opts, "stereo"); printf("Starting sound...\n"); sound = snd_open(snd_cmd, bsecs, 8, freq, bits, stereo); if (!sound) { fprintf(stderr, "WARNING: can't open sound!\n"); } } for (;;) { int cam_status; int status = mihl_server(ctx); if (status == -2) break; gettimeofday(&cur, NULL); if (delta_time(&last, &cur) > dtime) { cam_status = webcam_wait_frame_cb(cam, new_frame, NULL, 10); if (cam_status < 0) break; if (cam_status > 0) memcpy(&last, &cur, sizeof(struct timeval)); } if (exit_now) break; } webcam_stop(cam); webcam_close(cam); if (sound) { snd_stop(sound); sound = NULL; } printf("EXIT!\n"); mihl_end(ctx); return 0; }