void MainMenu::quitButtonClicked(Button* ) { getSound()->playSound( "Click" ); quitState = QUIT; running = false; }
void SoundInterface::commandDeleteSound(void) { int32_t id = cb->popValue().getInt(); CBSound* sound = getSound(id); if (sound == 0) return; delete sound; sounds.erase(id); }
// Load game void SaveLoad::loadGame(GameId id) { // Rewind current savegame _savegame->seek(0); // Validate main header SavegameMainHeader header; if (!loadMainHeader(_savegame, &header)) { debugC(2, kLastExpressDebugSavegame, "SaveLoad::saveGame - Cannot load main header: %s", getFilename(getMenu()->getGameId()).c_str()); return; } // Load the last entry _savegame->seek(header.offsetEntry); SavegameType type = kSavegameTypeIndex; EntityIndex entity = kEntityPlayer; uint32 val = 0; readEntry(&type, &entity, &val, header.keepIndex == 1); // Setup last loading time _gameTicksLastSavegame = getState()->timeTicks; if (header.keepIndex) { getSound()->clearQueue(); readEntry(&type, &entity, &val, false); } getEntities()->reset(); getEntities()->setup(false, entity); }
void MainMenu::optionsButtonClicked(Button* ) { getSound()->playSound( "Click" ); loadOptionsMenu(); switchMenu(optionsMenu.get()); }
void MainMenu::loadGameButtonClicked(Button* ) { getSound()->playSound( "Click" ); loadLoadGameMenu(); switchMenu(loadGameMenu.get()); }
void PickupItem_Health::executeEffect(OBJECT_ID id) { playSound(getSound()); relayMessage(id, MessageCharacterReceivesHealing(healing)); // TODO: Special FX }
void MainMenu::creditsButtonClicked(Button* ) { getSound()->playSound( "Click" ); loadCreditsMenu(); switchMenu(creditsMenu.get()); }
void ALAudio::BGS_Play(std::string const& file, int volume, int pitch) { SET_CONTEXT(ctx_); alSourcef(bgs_src_->get(), AL_PITCH, pitch * 0.01f); alSourcei(bgs_src_->get(), AL_LOOPING, AL_TRUE); bgm_src_->set_volume(volume * 0.01f); bgm_src_->play_buffer(getSound(file)); }
void Buzzer::doInterrupt() { uint16_t v2 = getSound(Timer::getInterrupts() - begin_time_); if(v2 != last_value_) { last_value_ = v2; hardware::setBuzzer(last_value_); } }
void Buzzer::doIdle() { uint8_t v2 = getSound(Time::diffU16(begin_time_U16_, Time::getInterruptsU16())); if(v2 != last_value_) { last_value_ = v2; hardware::setBuzzer(last_value_); } }
void ALAudio::BGS_Play(std::string const &file, int volume, int pitch, int fadein) { SET_CONTEXT(ctx_); BGM_Pitch(pitch); BGM_Volume(volume); bgm_src_->set_buffer_loader(getSound(*bgm_src_, file)); bgm_src_->fade_in(fadein); }
void SaveLoad::readEntry(SavegameType *type, EntityIndex *entity, uint32 *val, bool keepIndex) { #define LOAD_ENTRY(name, func, val) { \ uint32 _prevPosition = (uint32)_savegame->pos(); \ func; \ uint32 _count = (uint32)_savegame->pos() - _prevPosition; \ debugC(kLastExpressDebugSavegame, "Savegame: Reading " #name ": %d bytes", _count); \ if (_count != val) \ error("SaveLoad::readEntry: Number of bytes read (%d) differ from expected count (%d)", _count, val); \ } #define LOAD_ENTRY_ONLY(name, func) { \ uint32 _prevPosition = (uint32)_savegame->pos(); \ func; \ uint32 _count = (uint32)_savegame->pos() - _prevPosition; \ debugC(kLastExpressDebugSavegame, "Savegame: Reading " #name ": %d bytes", _count); \ } if (!type || !entity || !val) error("SaveLoad::readEntry: Invalid parameters passed!"); // Load entry header SavegameEntryHeader entry; Common::Serializer ser(_savegame, NULL); entry.saveLoadWithSerializer(ser); if (!entry.isValid()) error("SaveLoad::readEntry: entry header is invalid!"); // Init type, entity & value *type = entry.type; *val = entry.value; // Save position uint32 originalPosition = (uint32)_savegame->pos(); // Load game data LOAD_ENTRY("entity index", ser.syncAsUint32LE(*entity), 4); LOAD_ENTRY("state", getState()->saveLoadWithSerializer(ser), 4 + 4 + 4 + 4 + 1 + 4 + 4); LOAD_ENTRY("selected item", getInventory()->saveSelectedItem(ser), 4); LOAD_ENTRY("positions", getEntities()->savePositions(ser), 4 * 1000); LOAD_ENTRY("compartments", getEntities()->saveCompartments(ser), 4 * 16 * 2); LOAD_ENTRY("progress", getProgress().saveLoadWithSerializer(ser), 4 * 128); LOAD_ENTRY("events", getState()->syncEvents(ser), 512); LOAD_ENTRY("inventory", getInventory()->saveLoadWithSerializer(ser), 7 * 32); LOAD_ENTRY("objects", getObjects()->saveLoadWithSerializer(ser), 5 * 128); LOAD_ENTRY("entities", getEntities()->saveLoadWithSerializer(ser), 1262 * 40); LOAD_ENTRY_ONLY("sound", getSound()->saveLoadWithSerializer(ser)); LOAD_ENTRY_ONLY("savepoints", getSavePoints()->saveLoadWithSerializer(ser)); // Update chapter getProgress().chapter = entry.chapter; // Skip padding uint32 offset = _savegame->pos() - originalPosition; if (offset & 0xF) { _savegame->seek((~offset & 0xF) + 1, SEEK_SET); } }
void AudioPluginAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages) { synth.clearSounds(); synth.addSound(getSound()); const int numSamples = buffer.getNumSamples(); int channel, dp = 0; // Go through the incoming data, and apply our gain to it... for (channel = 0; channel < getNumInputChannels(); ++channel) buffer.applyGain (channel, 0, buffer.getNumSamples(), gain); // Now pass any incoming midi messages to our keyboard state object, and let it // add messages to the buffer if the user is clicking on the on-screen keys keyboardState.processNextMidiBuffer (midiMessages, 0, numSamples, true); // and now get the synth to process these midi events and generate its output. synth.renderNextBlock (buffer, midiMessages, 0, numSamples); // Apply our delay effect to the new output.. for (channel = 0; channel < getNumInputChannels(); ++channel) { float* channelData = buffer.getSampleData (channel); float* delayData = delayBuffer.getSampleData (jmin (channel, delayBuffer.getNumChannels() - 1)); dp = delayPosition; for (int i = 0; i < numSamples; ++i) { const float in = channelData[i]; channelData[i] += delayData[dp]; delayData[dp] = (delayData[dp] + in) * delay; if (++dp >= delayBuffer.getNumSamples()) dp = 0; } } delayPosition = dp; // In case we have more outputs than inputs, we'll clear any output // channels that didn't contain input data, (because these aren't // guaranteed to be empty - they may contain garbage). for (int i = getNumInputChannels(); i < getNumOutputChannels(); ++i) buffer.clear (i, 0, buffer.getNumSamples()); // ask the host for the current time so we can display it... AudioPlayHead::CurrentPositionInfo newTime; if (getPlayHead() != nullptr && getPlayHead()->getCurrentPosition (newTime)) { // Successfully got the current time from the host.. lastPosInfo = newTime; } else { // If the host fails to fill-in the current time, we'll just clear it to a default.. lastPosInfo.resetToDefault(); } }
void MainMenu::loadGameLoadButtonClicked(Button *) { getSound()->playSound( "Click" ); if( loadCityNG( mFilename ) ){ quitState = INGAME; running = false; } }
String JuceBoxAudioProcessor::infoString() { SamplerSound* sound = getSound(); if (sound == NULL) return ""; return " proc: " + String(blocksStarted) + "/" + String(blocksFinished); }
void SoundEffect::inheritedBegin() { SoundUnrecPtr sound = getSound(); if(sound != NULL) { sound->addSoundListener(&theInternalSoundListener); sound->play(); } }
void PCMAudioManager::unloadSound(S32 soundId) { if (soundId != -1) { PCMSound *sound = getSound(soundId); if (sound) { pcmSounds->remove(sound); delete sound; } } }
void check_bulldoze_area (int x, int y) { //no need to bulldoze desert if( MP_GROUP( x, y ) == GROUP_DESERT ) return; int xx, yy, g; if (MP_TYPE(x,y) == CST_USED) { xx = MP_INFO(x,y).int_1; yy = MP_INFO(x,y).int_2; } else { xx = x; yy = y; } g = MP_GROUP(xx,yy); if (g == GROUP_MONUMENT && monument_bul_flag == 0) { if( last_message_group != GROUP_MONUMENT ){ new Dialog( BULLDOZE_MONUMENT, xx, yy ); // deletes itself last_message_group = GROUP_MONUMENT; } return; } else if (g == GROUP_RIVER && river_bul_flag == 0) { if( last_message_group != GROUP_RIVER ){ new Dialog( BULLDOZE_RIVER, xx, yy ); // deletes itself last_message_group = GROUP_RIVER; } return; } else if (g == GROUP_SHANTY && shanty_bul_flag == 0) { if( last_message_group != GROUP_SHANTY ){ new Dialog( BULLDOZE_SHANTY, xx, yy ); // deletes itself last_message_group = GROUP_SHANTY; } return; } else if (g == GROUP_TIP) { if( last_message_group != GROUP_TIP ){ ok_dial_box ("nobull-tip.mes", BAD, 0L); last_message_group = GROUP_TIP; } return; } last_message_group = 0; getSound()->playSound( "Raze" ); bulldoze_item (xx,yy); }
void dialogCheckHardware::programInit() { connect(pushClose, SIGNAL(clicked()), this, SLOT(slotClose())); // Get the various hardware details getVideo(); getNetwork(); getSound(); }
void Audio::BGS_Play(std::string const& file, int volume, int pitch) { BGS_Stop(); alSourceRewind(*bgsSource_); alSourcei(*bgsSource_, AL_BUFFER, getSound(file)); alSourcef(*bgsSource_, AL_GAIN, volume * 0.01f); alSourcei(*bgsSource_, AL_PITCH, pitch * 0.01f); alSourcei(*bgsSource_, AL_LOOPING, AL_TRUE); alSourcePlay(*bgsSource_); }
/*********************************************************** synopsis: displays the graphical representation of time inputs: screen - the SDL_Surface to display the image outputs: n/a ***********************************************************/ static void updateTime(SDL_Surface* screen) { /* the time is x seconds minus the number of seconds of game time */ int thisTime; int seconds; int minutes; int minute_units; int minute_tens; int second_units; int second_tens; SDL_Rect fromrect, torect, blankRect; blankRect.x = CLOCK_WIDTH * 11; blankRect.y = 0; blankRect.w = CLOCK_WIDTH; blankRect.h = CLOCK_HEIGHT; fromrect.x = 0; fromrect.y = 0; fromrect.w = CLOCK_WIDTH; fromrect.h = CLOCK_HEIGHT; torect.y = 0; torect.w = CLOCK_WIDTH; torect.h = CLOCK_HEIGHT; thisTime = (int)((time_t)AVAILABLE_TIME - gameTime); minutes = thisTime/60; seconds = thisTime-(minutes*60); minute_tens = minutes/10; minute_units = minutes-(minute_tens*10); second_tens = seconds/10; second_units = seconds-(second_tens*10); fromrect.x = CLOCK_WIDTH * minute_tens; torect.x = CLOCK_WIDTH * 0; SDL_BlitSurface(numberBank, &fromrect, clockSprite->sprite, &torect); fromrect.x = CLOCK_WIDTH * minute_units; torect.x = CLOCK_WIDTH * 1; SDL_BlitSurface(numberBank, &fromrect, clockSprite->sprite, &torect); fromrect.x = CLOCK_WIDTH * second_tens; torect.x = CLOCK_WIDTH * 3; SDL_BlitSurface(numberBank, &fromrect, clockSprite->sprite, &torect); fromrect.x = CLOCK_WIDTH * second_units; torect.x = CLOCK_WIDTH * 4; SDL_BlitSurface(numberBank, &fromrect, clockSprite->sprite, &torect); /* tick out the last 10 seconds */ if (thisTime<=10 && thisTime>0) { Mix_PlayChannel(-1, getSound("clock-tick"), 0); } }
void ALAudio::SE_Play(std::string const &file, int volume, int pitch) { SET_CONTEXT(ctx_); EASYRPG_SHARED_PTR<source> src = create_source(false); alSourcef(src->get(), AL_PITCH, pitch * 0.01f); src->set_volume(volume * 0.01f); src->set_buffer_loader(getSound(*src, file)); se_src_.push_back(src); }
void Buzzer::doInterrupt() { uint32_t v = getSound(timer.getInterrupts() - begin_time_); v *= volume_; v /= 100; uint16_t v2 = v; if(v2 != last_value_) { last_value_ = v2; hardware::setBuzzer(last_value_); } }
FMCSoundStyleB::FMCSoundStyleB(Config* main_config, FMCControl* fmc_control) : FMCSounds(main_config, CFG_SOUNDS_STYLE_B_FILENAME, fmc_control) { setupDefaultConfig(); m_sounds_cfg->saveToFile(); // load sounds loadBaseSounds(); loadSound(CFG_SOUNDS_TOO_LOW_GEAR, m_sounds_cfg->getValue(CFG_SOUNDS_TOO_LOW_GEAR), FMCSoundBase::SOUND_SOURCE_COMPUTER); loadSound(CFG_SOUNDS_TOO_LOW_FLAPS, m_sounds_cfg->getValue(CFG_SOUNDS_TOO_LOW_FLAPS), FMCSoundBase::SOUND_SOURCE_COMPUTER); loadSound(CFG_SOUNDS_APP_MINIMUMS, m_sounds_cfg->getValue(CFG_SOUNDS_APP_MINIMUMS), FMCSoundBase::SOUND_SOURCE_COMPUTER); loadSound(CFG_SOUNDS_MINIMUMS, m_sounds_cfg->getValue(CFG_SOUNDS_MINIMUMS), FMCSoundBase::SOUND_SOURCE_COMPUTER); loadSound(CFG_SOUNDS_ALT_ALERT, m_sounds_cfg->getValue(CFG_SOUNDS_ALT_ALERT), FMCSoundBase::SOUND_SOURCE_COMPUTER); loadSound(CFG_SOUNDS_ALT_ALERT_CONT, m_sounds_cfg->getValue(CFG_SOUNDS_ALT_ALERT_CONT), FMCSoundBase::SOUND_SOURCE_COMPUTER); loadSound(CFG_SOUNDS_AP_DISCO, m_sounds_cfg->getValue(CFG_SOUNDS_AP_DISCO), FMCSoundBase::SOUND_SOURCE_COMPUTER); loadSound(CFG_SOUNDS_AT_DISCO, m_sounds_cfg->getValue(CFG_SOUNDS_AT_DISCO), FMCSoundBase::SOUND_SOURCE_COMPUTER); loadSound(CFG_SOUNDS_STALL, m_sounds_cfg->getValue(CFG_SOUNDS_STALL), FMCSoundBase::SOUND_SOURCE_COMPUTER); loadSound(CFG_SOUNDS_CHIME, m_sounds_cfg->getValue(CFG_SOUNDS_CHIME), FMCSoundBase::SOUND_SOURCE_COMPUTER); loadSound(CFG_SOUNDS_OVERSPEED, m_sounds_cfg->getValue(CFG_SOUNDS_OVERSPEED), FMCSoundBase::SOUND_SOURCE_COMPUTER); loadSound(CFG_SOUNDS_ALT_ALERT_CONT, m_sounds_cfg->getValue(CFG_SOUNDS_ALT_ALERT_CONT), FMCSoundBase::SOUND_SOURCE_COMPUTER); if (getSound(CFG_SOUNDS_STALL)) getSound(CFG_SOUNDS_STALL)->setPlayLooped(true); if (getSound(CFG_SOUNDS_OVERSPEED)) getSound(CFG_SOUNDS_OVERSPEED)->setPlayLooped(true); if (getSound(CFG_SOUNDS_ALT_ALERT_CONT)) getSound(CFG_SOUNDS_ALT_ALERT_CONT)->setPlayLooped(true); }
////////////////////////////////////////////////////////////////////////// // Opponent ////////////////////////////////////////////////////////////////////////// FighterOpponentMilos::FighterOpponentMilos(LastExpressEngine *engine) : Opponent(engine) { _sequences.push_back(loadSequence("2001or.seq")); _sequences.push_back(loadSequence("2001oal.seq")); _sequences.push_back(loadSequence("2001oam.seq")); _sequences.push_back(loadSequence("2001okl.seq")); _sequences.push_back(loadSequence("2001okm.seq")); _sequences.push_back(loadSequence("2001dbk.seq")); _sequences.push_back(loadSequence("2001wbk.seq")); getSound()->playSound(kEntityTables0, "MUS027", kFlagDefault); _field_38 = 35; }
void BabelClient::sendSound(unsigned int thread_id, ISocket *client) { while (client->getStatus() != ISocket::Canceled) { #ifdef _WIN_32 Sleep(100); #else usleep(100); #endif client->writePacket(Packet::pack<SoundPacket>(*(getSound()->getStruct()))); } }
void Audio::SE_Play(std::string const& file, int volume, int pitch) { eraseStopped(seSource_); boost::shared_ptr<ALuint> src = create_source(); alSourcei(*src, AL_BUFFER, getSound(file)); alSourcef(*src, AL_GAIN, volume * 0.01f); alSourcei(*src, AL_PITCH, pitch * 0.01f); alSourcei(*src, AL_LOOPING, AL_FALSE); alSourcePlay(*src); seSource_.push_back(src); }
void sfzero::SFZeroAudioProcessor::getStateInformation(MemoryBlock &destData) { auto obj = new DynamicObject(); obj->setProperty("sfzFilePath", sfzFile.getFullPathName()); auto sound = getSound(); if (sound) { int subsound = sound->selectedSubsound(); if (subsound != 0) obj->setProperty("subsound", subsound); } MemoryOutputStream out(destData, false); JSON::writeToStream(out, var(obj)); }
////////////////////////////////////////////////////////////////////////// // Opponent ////////////////////////////////////////////////////////////////////////// FighterOpponentVesna::FighterOpponentVesna(LastExpressEngine *engine) : Opponent(engine) { _sequences.push_back(loadSequence("2005or.seq")); _sequences.push_back(loadSequence("2005oam.seq")); _sequences.push_back(loadSequence("2005oar.seq")); _sequences.push_back(loadSequence("2005okml.seq")); _sequences.push_back(loadSequence("2005okr.seq")); _sequences.push_back(loadSequence("2005odm1.seq")); _sequences.push_back(loadSequence("2005csbm.seq")); _sequences.push_back(loadSequence("2005oam4.seq")); getSound()->playSound(kEntityTables0, "MUS038", kVolumeFull); _countdown = 4; _field_38 = 30; }
void updateMenu(Inputs *input, Map **map) { if (input->up && getInfoGame()->choiceMenu != MIN_CHOICE_MENU) { --getInfoGame()->choiceMenu; playSound(getSound().menuMove); } else if (input->down && getInfoGame()->choiceMenu != MAX_CHOICE_MENU) { ++getInfoGame()->choiceMenu; playSound(getSound().menuMove); } else if (input->enter) { if (getInfoGame()->choiceMenu == 0) { getInfoGame()->isOnMenu = IS_IN_CHOOSEMAP_MENU; getInfoGame()->choicePause = 0; } else if (getInfoGame()->choiceMenu == 1) getInfoGame()->isOnMenu = IS_IN_EDITOR; else if (getInfoGame()->choiceMenu == 2) { getInfoGame()->isOnMenu = IS_IN_OPTION_MENU; } else if (getInfoGame()->choiceMenu == 3) exit(0); playSound(getSound().menuChoose); } }