예제 #1
0
void cargar_bitmap(){
    start = load_wav("asd/pacman_beginning.wav");
    dead = load_wav("asd/pacman_death.wav");
    eat = load_wav("asd/pacman_chomp.wav");

    enem1 = load_bitmap("asd/enemigo1.bmp", NULL);
    enemy1 = create_bitmap(30,30);
    enem2 = load_bitmap("asd/enemigo2.bmp", NULL);
    enemy2 = create_bitmap(30,30);
    enem3 = load_bitmap("asd/enemigo3.bmp", NULL);
    enemy3 = create_bitmap(30,30);
    enem4 = load_bitmap("asd/enemigo4.bmp", NULL);
    enemy4 = create_bitmap(30,30);

    buffer = create_bitmap(880, 600);
    rock = load_bitmap("asd/rocaII.bmp", NULL);

    dish1 = load_bitmap("asd/comida1.bmp", NULL);
    dish2 = load_bitmap("asd/comida2.bmp", NULL);
    dish3 = load_bitmap("asd/comida3.bmp", NULL);
    dish4 = load_bitmap("asd/comida4.bmp", NULL);
    dish5 = load_bitmap("asd/comida5.bmp", NULL);

    pac = load_bitmap("asd/pacman.bmp", NULL);
    pacman = create_bitmap(33,33);

    portada = load_bitmap("asd/portada.bmp", NULL);
    fondo = load_bitmap("asd/fondo.bmp", NULL);
    life = load_bitmap("asd/live.bmp", NULL);
    restart = load_bitmap("asd/restart.bmp", NULL);
    die = load_bitmap("asd/muerte.bmp", NULL);
}
예제 #2
0
void eof_mix_init(void)
{
	int i;
	char fbuffer[1024] = {0};

	eof_log("eof_mix_init() entered", 1);

	eof_sound_clap = load_wav("eof.dat#clap.wav");
	if(!eof_sound_clap)
	{
		allegro_message("Couldn't load clap sound!");
	}
	eof_sound_metronome = load_wav("eof.dat#metronome.wav");
	if(!eof_sound_metronome)
	{
		allegro_message("Couldn't load metronome sound!");
	}
	eof_sound_grid_snap = load_wav("eof.dat#gridsnap.wav");
	if(!eof_sound_grid_snap)
	{
		allegro_message("Couldn't load seek sound!");
	}
	for(i = 0; i < EOF_MAX_VOCAL_TONES; i++)
	{	//Load piano tones
		(void) snprintf(fbuffer, sizeof(fbuffer) - 1, "eof.dat#piano.esp/NOTE_%02d_OGG", i);
		eof_sound_note[i] = eof_mix_load_ogg_sample(fbuffer);
	}
	eof_sound_cowbell = eof_mix_load_ogg_sample("percussion.dat#cowbell.ogg");
	eof_sound_chosen_percussion = eof_sound_cowbell;	//Until the user specifies otherwise, make cowbell the default percussion
	eof_sound_tambourine1 = eof_mix_load_ogg_sample("percussion.dat#tambourine1.ogg");
	eof_sound_tambourine2 = eof_mix_load_ogg_sample("percussion.dat#tambourine2.ogg");
	eof_sound_tambourine3 = eof_mix_load_ogg_sample("percussion.dat#tambourine3.ogg");
	eof_sound_triangle1 = eof_mix_load_ogg_sample("percussion.dat#triangle1.ogg");
	eof_sound_triangle2 = eof_mix_load_ogg_sample("percussion.dat#triangle2.ogg");
	eof_sound_woodblock1 = eof_mix_load_ogg_sample("percussion.dat#woodblock1.ogg");
	eof_sound_woodblock2 = eof_mix_load_ogg_sample("percussion.dat#woodblock2.ogg");
	eof_sound_woodblock3 = eof_mix_load_ogg_sample("percussion.dat#woodblock3.ogg");
	eof_sound_woodblock4 = eof_mix_load_ogg_sample("percussion.dat#woodblock4.ogg");
	eof_sound_woodblock5 = eof_mix_load_ogg_sample("percussion.dat#woodblock5.ogg");
	eof_sound_woodblock6 = eof_mix_load_ogg_sample("percussion.dat#woodblock6.ogg");
	eof_sound_woodblock7 = eof_mix_load_ogg_sample("percussion.dat#woodblock7.ogg");
	eof_sound_woodblock8 = eof_mix_load_ogg_sample("percussion.dat#woodblock8.ogg");
	eof_sound_woodblock9 = eof_mix_load_ogg_sample("percussion.dat#woodblock9.ogg");
	eof_sound_woodblock10 = eof_mix_load_ogg_sample("percussion.dat#woodblock10.ogg");
	eof_sound_clap1 = eof_mix_load_ogg_sample("percussion.dat#clap1.ogg");
	eof_sound_clap2 = eof_mix_load_ogg_sample("percussion.dat#clap2.ogg");
	eof_sound_clap3 = eof_mix_load_ogg_sample("percussion.dat#clap3.ogg");
	eof_sound_clap4 = eof_mix_load_ogg_sample("percussion.dat#clap4.ogg");
}
예제 #3
0
/********************************************//**
 * \brief Charge un son
 *
 * \param path char* Chemin du son a charger
 * \return SAMPLE*
 *
 ***********************************************/
SAMPLE *son_load_check(char *path)
{
    SAMPLE *ptr = load_wav(path);
    if (ptr == NULL)
        ft_error("load sound");
    return ptr;
}
예제 #4
0
void Sound::sndLoadSound (const std::string &SoundFilename)
{
  if(!EnableSound)
    return;
  if (!Sounds[SoundFilename])
    Sounds[SoundFilename] = load_wav (SoundFilename.c_str());
}
예제 #5
0
파일: sound.cpp 프로젝트: sidpoison/dokun
bool Sound::load(const std::string& file_name)
{
	std::string extension = String::lower(file_name.substr(file_name.find_last_of(".") + 1));
	if(extension == "wav" || extension == "wave")
	{
		return load_wav(file_name);
	}	
	if(extension == "raw" || extension == "pcm")
	{
		return load_pcm(file_name);
	}		
    return load_ogg(file_name);
}
예제 #6
0
		void Load_SFX(unsigned char i, const char* directory)
		{
			#ifdef DEBUG
				fprintf(stderr, "Loading sound effect %d (%s) in memory\n", i, directory);
			#endif
			
			if (sfx_id[i])
			{
				destroy_sample(sfx_id[i]);
			}
			
			sfx_id[i] = load_wav(directory);
		}
예제 #7
0
unsigned int Resources::audio(const std::string &audioFile)
{
	std::string fullpath;
	if (audioMap.find(audioFile) == audioMap.end()) {
		DEBUG_PRINT("loading " << audioFile);
		if (search_path(audioFile, fullpath)) {
			audioMap[audioFile] = load_wav(fullpath);
		}
		else {
			DEBUG_ERROR("file " << audioFile << " doesnt exist or not reachable");
		}
	}
	else {
		DEBUG_PRINT("using already loaded " << audioFile);
	}
	return audioMap[audioFile];
}
예제 #8
0
SOUNDCLIP *my_load_wave(const char *filename, int voll, int loop)
{
#ifdef MAC_VERSION
  SAMPLE *new_sample = load_wav(filename);
#else
  SAMPLE *new_sample = load_sample(filename);
#endif

  if (new_sample == NULL)
    return NULL;

  thiswave = new MYWAVE();
  thiswave->wave = new_sample;
  thiswave->vol = voll;
  thiswave->firstTime = 1;
  thiswave->repeat = loop;

  return thiswave;
}
예제 #9
0
int startGame(){
	configAll();

	BITMAP * nave = load_bitmap("img/35x45/nave.bmp",NULL);
	BITMAP * alien = load_bitmap("img/35x45/alien.bmp", NULL);
	BITMAP * gun = load_bitmap("img/35x45/gun.bmp", NULL);
	BITMAP * init = load_bitmap("img/start.bmp", NULL);
	BITMAP * bg = load_bitmap("img/bartop.bmp", NULL);
	BITMAP * buffer = create_bitmap(SCREEN_W,SCREEN_H);
	SAMPLE * sound = load_wav("wav/tiro.wav");
	SAMPLE * music = load_sample("wav/laserHit.wav");

	initStart(buffer,init);
	install_int_ex(countXa,SECS_TO_TIMER(1));
	install_int_ex(countGun,MSEC_TO_TIMER(1));
	gameControll(nave,buffer,alien,gun,bg,sound,music);
	destroyAll(nave,buffer,alien,gun,init,bg,sound,music);
	return 0;
}
예제 #10
0
파일: som.cpp 프로젝트: kenjasi75202/libegl
bool som::carregar(string arquivo)
{
	if(!egl_init) 
		return false;
	
	string ext = arquivo.substr(arquivo.size()-4,arquivo.size()-1);
	std::transform(ext.begin(), ext.end(), ext.begin(),static_cast < int(*)(int) > (tolower));

	if (ext == ".wav") {
		tipo = T_WAV;

		if(smp)
		{
			destroy_sample(smp);
			voice = -1;
		}
		smp = load_wav(arquivo.c_str());
		if(!smp) 
		{
			egl_erro("Erro carregando arquivo: " + arquivo);
			egl_debug = true;
			return false;
		}
	} else {
		tipo = T_MID;
		if(mid)
		{
			destroy_midi(mid);
			voice = -1;
		}
		mid = load_midi(arquivo.c_str());
		if(!mid) 
		{
			egl_erro("Erro carregando arquivo: " + arquivo);
			egl_debug = true;
			return false;
		}
	}
	return true;
}
예제 #11
0
void *loom_asset_soundDeserializer( void *buffer, size_t bufferLen, LoomAssetCleanupCallback *dtor )
{
    loom_asset_sound_t *sound = (loom_asset_sound_t*)lmAlloc(gAssetAllocator, sizeof(loom_asset_sound_t));
    memset(sound, 0, sizeof(loom_asset_sound_t));
    unsigned char *charBuff = (unsigned char *)buffer;

    // Look for magic header in buffer.
    if(charBuff[0] == 0x4f 
        && charBuff[1] == 0x67
        && charBuff[2] == 0x67
        && charBuff[3] == 0x53)
    {
        // It's an Ogg, assume vorbis and throw it to stb_vorbis.
        int channels = 0;
        short *outputBuffer = NULL;
        int sampleCount = stb_vorbis_decode_memory(charBuff, (int)bufferLen, &channels, &outputBuffer);
        if(sampleCount < 0)
        {
            lmLogError(gSoundAssetGroup, "Failed to decode Ogg Vorbis");
            loom_asset_soundDtor(&sound);
            return NULL;
        }

        sound->channels = channels;
        sound->bytesPerSample = 2;
        sound->sampleCount = sampleCount;
        sound->bufferSize = sampleCount * channels * 2;
        sound->sampleRate = 44100; // TODO: This should be variable

        // We can skip this if we get clever about allocations in stbv.
        sound->buffer = lmAlloc(gAssetAllocator, sound->bufferSize);
        memcpy(sound->buffer, outputBuffer, sound->bufferSize);

        free(outputBuffer);
    }
    else if((charBuff[0] == 0x49 // ID3
        &&   charBuff[1] == 0x44
        &&   charBuff[2] == 0x33)
        ||  (charBuff[0] == 0xff // Missing ID3 Tag
        &&   charBuff[1] == 0xfb))
    {
        // It's an MP3, y'all!
        short *outBuffer = (short*)lmAlloc(gAssetAllocator, MP3_MAX_SAMPLES_PER_FRAME * 2);
        mp3_info_t mp3Info;

        // Decode once to get total size.
        size_t totalBytes = 0;
        size_t bytesRead = 0, bytesLeft = bufferLen;

        mp3_decoder_t decmp3 = mp3_create();
        for(;;)
        {
            int bytesDecoded = mp3_decode(decmp3, charBuff + bytesRead, (int)bytesLeft, outBuffer, &mp3Info);
            bytesRead += bytesDecoded;
            bytesLeft -= bytesDecoded;
            totalBytes += mp3Info.audio_bytes;
            if(bytesDecoded > 0)
                continue;

            // Clean up.
            mp3_done(decmp3);
            break;
        }

        // Great, set up the sound asset.
        // TODO: Warn about non 44.1khz mp3s.
        sound->channels = mp3Info.channels;
        sound->bytesPerSample = 2;
        sound->sampleCount = (int)totalBytes / sound->bytesPerSample;
        sound->bufferSize = sound->channels * sound->bytesPerSample * sound->sampleCount;
        sound->sampleRate = 44100; // TODO: This should be variable
        sound->buffer = lmAlloc(gAssetAllocator, sound->bufferSize);

        // Decode again to get real samples.        
        decmp3 = mp3_create();
        bytesRead = 0; bytesLeft = bufferLen;
        int curBufferOffset = 0;
        for(;;)
        {
            int bytesDecoded = mp3_decode(decmp3, charBuff + bytesRead, (int)bytesLeft, outBuffer, &mp3Info);
            bytesRead += bytesDecoded;
            bytesLeft -= bytesDecoded;

            memcpy(((unsigned char*)sound->buffer) + curBufferOffset, outBuffer, mp3Info.audio_bytes);
            curBufferOffset += mp3Info.audio_bytes;

            if(bytesDecoded > 0)
                continue;

            // Clean up.
            mp3_done(decmp3);
            break;
        }

        // Awesome, all set!
        lmFree(gAssetAllocator, outBuffer);
    }
    else if(charBuff[0] == 0x52 // 'RIFF'
         && charBuff[1] == 0x49
         && charBuff[2] == 0x46
         && charBuff[3] == 0x46)
    {
        // We've got a wav file
        wav_info wav;
        bool wavLoadSuccess = load_wav(charBuff, bufferLen, NULL, &wav);
        if (!wavLoadSuccess)
        {
            lmLogError(gSoundAssetGroup, "Failed to load wav format info");
            loom_asset_soundDtor(sound);
            return 0;
        }
        
        sound->channels = wav.numChannels;
        sound->bytesPerSample = wav.sampleSize / 8; // wav sample size is in bits
        if (sound->bytesPerSample != 1 && sound->bytesPerSample != 2)
        {
            lmLogError(gSoundAssetGroup, "Unsupported wav format. Currently only 8-bit or 16-bit PCM are supported");
            loom_asset_soundDtor(sound);
            return 0;
        }
        sound->bufferSize = wav.sampleDataSize;
        sound->sampleCount = sound->bufferSize / sound->bytesPerSample;
        sound->sampleRate = wav.samplesPerSecond;
        
        sound->buffer = lmAlloc(gAssetAllocator, sound->bufferSize);
        bool dataCopySuccess = load_wav(charBuff, bufferLen, (uint8_t*)sound->buffer, NULL);
        if (!dataCopySuccess)
        {
            lmLogError(gSoundAssetGroup, "Failed to copy wav data");
            loom_asset_soundDtor(sound);
            return 0;
        }
    }
    else
    {
        lmLogError(gSoundAssetGroup, "Failed to identify sound buffer by magic number!");
        loom_asset_soundDtor(sound);
        return 0;
    }

   *dtor = loom_asset_soundDtor;
   if(!sound->buffer)
   {
      lmLogError(gSoundAssetGroup, "Sound load failed due to this cryptic reason: %s", "(unknown)");
      lmFree(gAssetAllocator, sound);
      return 0;
   }

    lmLogDebug(gSoundAssetGroup, "Sound allocation: %d bytes", sound->bufferSize);
    return sound;
}
예제 #12
0
파일: main.cpp 프로젝트: bryancjd1/trabajo
            blit(muertebmp,enemigom,0,0,0,0,33,33);//carga la imagen sobre el buffer pacman
            draw_sprite(buffer,enemigom,_x,_y);
            blit(buffer, screen ,0,0,0,0,1280,600);
            rest(80);

        _x = 0;
        _y = 0;
        vidaenemigo--;
    }
}

int main()
{

    allegro_init();
    install_keyboard();

    set_color_depth(32);
    set_gfx_mode(GFX_AUTODETECT_WINDOWED,1280, 600 , 0, 0);

    //inicializa la musica en allegro
    if (install_sound(DIGI_AUTODETECT, MIDI_AUTODETECT, NULL) != 0)
        {
            allegro_message("Error: inicializando sistema de sonido\n%s\n", allegro_error);
            return 1;
        }
    // ajuste de volumen
    set_volume(70, 70);//cuanto se oye a la izquierdsa y a la derecha

    intro = load_wav("music/start.wav");
    sirenafantasma = load_wav("music/sirene.wav");
    muertes = load_wav("music/muerte.wav");

    buffer = create_bitmap(1280,600); //870 570
    pacman = create_bitmap(33,33);
    complemento = create_bitmap(400,600);
    vid =create_bitmap(33,33);
    ataqueb = create_bitmap(33,33);

    atabmp = load_bitmap("images/ataque.bmp",NULL);
    roca = load_bitmap("images/tile2.bmp",NULL);
    pacbmp =load_bitmap("images/tank2.bmp", NULL);
    comida = load_bitmap("images/Comida.bmp",NULL);
    muertebmp = load_bitmap("images/muerte1.bmp",NULL);
    combmp =load_bitmap("images/complemento.bmp",NULL);
    vidas = load_bitmap("images/vidas.bmp",NULL);

    mapa1 mapa;
    enemigo A1(30*1,30*18) ;
    enemigo A2(30*27,30*1) ;
    enemigo A3(30*14,30*11) ;
    enemigo A4(30*27,30*18) ;
    enemigo A5(30*27,30*18);
    personaje1 personaje;
    personaje2 personaje3;



    play_sample(intro,200,150,1000,0); // volumen,sonido,,velocidad a la que se reproduce,distribucion 1000 es punto medio,para que no se repita
    rest(4000);

    play_sample(sirenafantasma,150,150,1000,1);

    while (!key[KEY_ESC] && mapa.game_over())
    {
        if(A1.getvida()==0 && A2.getvida()==0 && A3.getvida()==0 && A4.getvida()==0) return false;

        personaje.mover_personaje();
        mapa.dibujar_mapa();
        personaje.dibujar_personaje();
        personaje.ataque();
        personaje.ataque1();
        personaje3.dibujar_personaje();
        personaje3.mover_personaje();
        A1.mover_enemigo();
        A2.mover_enemigo();
        A4.mover_enemigo();
        A3.mover_enemigo();
        personaje3.ataque();
        personaje3.ataque1();
        A1.ataque2();
        A1.ataque_enemigo();
        A2.ataque2();
        A2.ataque_enemigo();
        A4.ataque2();
        A4.ataque_enemigo();
        A3.ataque2();
        A3.ataque_enemigo();
        A1.muerte_enemigo();
        A2.muerte_enemigo();
예제 #13
0
		void Load_Music(const char* directory)
		{
			Clean_Music();
			music = load_wav(directory);
		}
예제 #14
0
파일: main.c 프로젝트: furrtek/PSGTalk
int main(int argc, char *argv[]) {
	// mallocated stuff
	float * wave_buffer;
	float * aa_buffer;
	float * work_buffer;
	float * frame_buffer;
	float * dft_bins;
	unsigned int * frequencies;
	unsigned int * volumes;
	unsigned char * out_buffer;
	
	unsigned char consolidate;
	unsigned long wave_size, work_size;
	unsigned int frame_size, frame_inc;
	unsigned int i;
	int ofs;
	unsigned long idx;
	
	unsigned long c, m, k, t, f;
	unsigned int kmax;
	float max_power;
	float in_r, sum_r, sum_i;
	float ratio;
	unsigned long frame_idx = 0, frames;
	char outfilepath[256];
	unsigned int ext;
	
	puts("PSGTalk 0.3 - furrtek 2017\n");
	
	// Overlap = 0
	//   Data: ######################## (24)
	// Frames: AAAAAAAA
	//                 BBBBBBBB
	//                         CCCCCCCC
	//  Count: 3
	// Length: 8 = 24 / 3 * (0 + 1)
	// Offset: 8 = Length * (1 - 0)
	
	// Overlap = 0.5
	//   Data: ######################## (24)
	// Frames: AAAAAAAAAAAA
	//               BBBBBBBBBBBB
	//                     CCCCCCCCCCCC
	//  Count: 3
	// Length: 12 = 24 / 3 * (0.5 + 1)
	// Offset: Length * (1 - 0.5)
	
	// Defaults
	overlap = 0.25;
	updates_per_frame = 2;
	psg_channels = 3;
	sim = 0;
	mode = MODE_VGM;
	fps = 60;
	freq_res = 64;
	
	if (parse_args(argc, argv))
		return 1;

	wave_size = load_wav(argv[argc - 1], &wave_buffer);
	if (!wave_size) {
		puts("Can't load wave file.\n");
		return 1;
	}
	
	// Anti-alias filtering
	aa_buffer = calloc(wave_size, sizeof(float));
	if (aa_buffer == NULL) {
		puts("Memory allocation failed\n");
		free(wave_buffer);
		return 1;
	}
	lowpass(wave_buffer, aa_buffer, 8192.0, samplerate_in, wave_size);
	
	// Decimate
	ratio = ((float)samplerate_in / 8192.0);
	work_size = (int)(wave_size / ratio);
	work_buffer = calloc(work_size, sizeof(float));
	if (work_buffer == NULL) {
		puts("Memory allocation failed\n");
		free(wave_buffer);
		free(aa_buffer);
		return 1;
	}
	
	for (i = 0; i < work_size; i++)
		work_buffer[i] = aa_buffer[(int)(i * ratio)];

	update_rate = fps * updates_per_frame;
	frame_size = (8192.0 * (overlap + 1.0)) / update_rate;
	frame_inc = (float)frame_size * (1.0 - overlap);
	m = 1;									// Discrimination between power peaks
	frames = work_size / frame_inc;			// Total number of frames
	freq_step = (8192 / freq_res) / 2;
	
	frame_buffer = calloc(frame_size, sizeof(float));
	dft_bins = calloc(freq_res, sizeof(float));
	frequencies = calloc(frames * psg_channels, sizeof(unsigned int));
	volumes = calloc(frames * psg_channels, sizeof(unsigned int));
	
	if ((dft_bins == NULL) || (frame_buffer == NULL) || (frequencies == NULL) || (volumes == NULL)) {
		puts("Memory allocation failed\n");
		return 1;
	}
	
	if (!make_LUTs(frame_size)) {
		puts("Table generation failed\n");
		return 1;
	}
	
	// Show recap
	printf("Frames: %lu\n", frames);
	printf("Overlap: %u%%\n", (unsigned int)(overlap * 100.0));
	printf("Samplerate: %luHz -> %uHz\n", samplerate_in, 8192);
	printf("Resolution: %uHz\n", freq_step);
	printf("Update rate: %u/frame (%uHz @ %ufps)\n", updates_per_frame, update_rate, fps);
	printf("PSG channels: %u\n", psg_channels);
	printf("Mode: %s\n", modestr[mode]);
	
	
	f = 0;
	do {
		// Copy frame
		memcpy(frame_buffer, &work_buffer[f], frame_size * sizeof(float));
		
		// Apply window
		for (t = 0; t < frame_size; t++)
			frame_buffer[t] *= window_lut[t];
		
		// Do DFT
    	for (k = 0; k < freq_res; k++) {		// For each output element
  	      	sum_r = 0;
  	      	sum_i = 0;
        	for (t = 0; t < frame_size; t++) {			// For each input element
            	c = ((32768 * t * k / 2) / frame_size) & 0x7FFF;
            	in_r = frame_buffer[t];
            	sum_r += (in_r * cos_lut[c]);
            	sum_i += (in_r * sin_lut[c]);
			}
            sum_r /= frame_size;
        	sum_i /= frame_size;
        
        	dft_bins[k] = sqrt((sum_i * sum_i) + (sum_r * sum_r));
    		//if (f == 0) printf("SAMP=%f POW=%f (%uHz)\n", frame_buffer[k], dft_bins[k], k * freq_step);
		}

		// Find highest peaks
		consolidate = 0;
		for (c = 0; c < psg_channels; c++) {
			idx = (frame_idx * psg_channels) + c;
			if (consolidate) {
				max_power -= 0.4;
	    		frequencies[idx] = frequencies[idx - 1];
	    		volumes[idx] = lintolog(max_power);
			} else {
				// Find highest power and its associated frequency (skip DC bin)
		    	max_power = 0;
		    	for (k = 1; k < (frame_size - 1); k++) {
					if (dft_bins[k] > max_power) {
						max_power = dft_bins[k];
						kmax = k;
					}
				}
				// Clear surrounding bins if needed
				for (t = 0; t < m; t++) {
					ofs = kmax - t - 1;
					if (ofs >= 0) dft_bins[ofs] = 0;
					ofs = kmax + t + 1;
					if (ofs < freq_res) dft_bins[ofs] = 0;	
				}
				
		    	frequencies[idx] = kmax;
		    	volumes[idx] = lintolog(max_power);
			}
			
			consolidate = (max_power >= 0.4) ? 1 : 0;
			
			if (frame_idx == 0) printf("C%lu=%uHz\n", c, kmax * freq_step);		// DEBUG
		}
        
    	frame_idx++;
    	f += frame_inc;
    
    	printf("\rComputing frame %lu/%lu.", frame_idx, frames);

	} while (f < (work_size - frame_size));
	
	puts(" Done.\n");
	
	// Generate output file
	strcpy(outfilepath, argv[argc - 1]);
	ext = strlen(outfilepath) - 3;
	if (mode == MODE_VGM) {
		outfilepath[ext++] = 'v';
		outfilepath[ext++] = 'g';
		outfilepath[ext] = 'm';
	} else {
		outfilepath[ext++] = 'b';
		outfilepath[ext++] = 'i';
		outfilepath[ext] = 'n';
	}


	FILE * fo = fopen(outfilepath, "wb");
	
	if (mode == MODE_RAW) {
		out_raw(&out_buffer, frequencies, volumes, frame_idx, freq_res);
	} else if (mode == MODE_VGM) {
		out_vgm(&out_buffer, frequencies, volumes, frame_idx);
	} else if (mode == MODE_NGP) {
		out_ngp(&out_buffer, frequencies, volumes, frame_idx);
	}

	fwrite(out_buffer, file_length, 1, fo);
	fclose(fo);

	free(out_buffer);
	
	puts("Output file written.");
	printf("Size: %lukB\n", file_length / 1024);

	// Generate simulation file if needed
	if (sim) {
		if (gen_sim(frame_size, frame_idx, psg_channels, frequencies, volumes))
			puts("\nSimulation file written.\n");
	}
	
	free(frequencies);
	free(volumes);
	free(frame_buffer);
	free(wave_buffer);
	free(work_buffer); 
	free(dft_bins);
	
    system("pause");
    //return 0;

	return 0;
}
예제 #15
0
void main() 
{	
	allegro_init();
	install_keyboard();
	set_color_depth(32);
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 1000, 600, 0, 0);
	install_int_ex(ContaMsec, MSEC_TO_TIMER(1));
	install_int_ex(ContaSec, SECS_TO_TIMER(1));	
	install_sound(DIGI_AUTODETECT,MIDI_AUTODETECT,NULL);
	MIDI* bgSound = load_midi("sounds/BGM.mid");
	SAMPLE* snakeHit = load_wav("sounds/cobraDamage.wav");
	SAMPLE* snakeHitSelf = load_wav("sounds/cobraDamage2.wav");
    SAMPLE* snakeDeath = load_wav("sounds/cobraDeath.wav");	
    SAMPLE* gameOver = load_wav("sounds/gameOver.wav");	
	InicializaPP();

	int swt = 0;
	

	
	struct Cobra snake[500]; //Estrutura que representa a cobra e suas bmpPartes.

	int xst=0, yst=10, xst2=190, yst2 = 40; //Coordenadas de referência da área de Status do jogo
	int xL = 0, yL = 425, xL2 = 190, yL2 = 590; //Coordenadas de referência da Tabela de Comidas
	
	buffer = create_bitmap(800,600); //Bitmap principal de desenho
	status = create_bitmap(200,600); //Bitmap principal de desenho
	clear_to_color(status, makecol(0,0,0));
	clear_to_color(buffer, makecol(0,0,0));

	//INICIO: Inicializacao Sprites
	bmpSapo = load_bitmap("images/sapo_20x20.bmp",pallet);
	bmpAranha = load_bitmap("images/ARANHA_20X20.bmp",pallet);
	bmpMaca = load_bitmap("images/MACA_20x20.bmp",pallet);
	bmpMilho = load_bitmap("images/milho_20X20.bmp",pallet);
	bmpCobraHead = load_bitmap("images/cobraHeadVerde.bmp",pallet);
	bmpFundo = load_bitmap("images/fundoAreia.bmp",pallet);
	bmpCobrinha = load_bitmap("images/cobrinha.bmp",pallet);
	bmpParte = load_bitmap("images/cobraCorpo2.BMP",pallet);
	bmpBordaVert = load_bitmap("images/bordaVert.bmp",pallet);
	bmpBordaHoriz = load_bitmap("images/bordaHoriz.bmp",pallet);
	myfont = load_font("Terminal.pcx", pallet, NULL); //Fonte personalizada
	//FIM: Inicializacao Sprites



	//INICIO: Comidas
	Comida	cmdSapo;
	cmdSapo.x = 300;
	cmdSapo.y = 400;
	cmdSapo.bmp = bmpSapo;
	cmdSapo.spStand = load_wav("sounds/sapoStand.wav");
	cmdSapo.spDie = load_wav("sounds/sapoDie.wav");
	cmdSapo.visible = true;
	cmdSapo.ponto = 50;
	cmdSapo.taman = 1;
	
	Comida	cmdAranha;
	cmdAranha.x = 60;
	cmdAranha.y = 500;	
	cmdAranha.bmp = bmpAranha;
	cmdAranha.spStand = load_wav("sounds/sapoStand.wav");
	cmdAranha.spDie = load_wav("sounds/aranhaDie.wav");	
	cmdAranha.visible = true;
	cmdAranha.ponto = 30;
	cmdAranha.taman = 3;
		
	Comida	cmdMaca;
	cmdMaca.x = 100;
	cmdMaca.y = 100;
	cmdMaca.bmp = bmpMaca;
    cmdMaca.spStand = load_wav("sounds/sapoStand.wav");
	cmdMaca.spDie = snakeBit;
	cmdMaca.visible = true;
	cmdMaca.ponto = 20;
	cmdMaca.taman = 4;
	
	
	Comida	cmdMilho;
	cmdMilho.x = 600;
	cmdMilho.y = 100;	
	cmdMilho.bmp = bmpMilho;
	//cmdmilho.spStand = load_wav("sounds/sapoStand.wav");
	cmdMilho.spDie = snakeBit;	
	cmdMilho.visible = true;
	cmdMilho.ponto = 10;
	cmdMilho.taman = 5;
	
	Comida	cmdCobrinha;	
	cmdCobrinha.x = 600;
	cmdCobrinha.y = 480;	
	cmdCobrinha.bmp = bmpCobrinha;
	cmdCobrinha.spStand = load_wav("sounds/cobrinhaStand.wav");
	cmdCobrinha.spDie = load_wav("sounds/cobrinhaDie.wav");	
	cmdCobrinha.visible = true;
	cmdCobrinha.ponto = 40;
	cmdCobrinha.taman = 2;
	
	Comida comidas[20];
	comidas[0] = cmdSapo;
	comidas[1] = cmdAranha;
	comidas[2] = cmdMaca;
	comidas[3] = cmdMilho;
	comidas[4] = cmdCobrinha;
	comidas[5] = cmdAranha;
	comidas[6] = cmdMilho;
	comidas[7] = cmdMilho;
	comidas[8] = cmdMilho;
	comidas[9] = cmdCobrinha;
	comidas[10] = cmdSapo;
	comidas[11] = cmdAranha;
	comidas[12] = cmdMaca;
	comidas[13] = cmdMilho;
	comidas[14] = cmdCobrinha;
	comidas[15] = cmdAranha;
	comidas[16] = cmdMilho;
	comidas[17] = cmdMilho;
	comidas[18] = cmdMilho;
	comidas[19] = cmdCobrinha;
	//FIM: Comidas
	
	Vida vidas[6];
    for (int i = 0;i < 6; i++){
        vidas[i].x = i*30; 
        vidas[i].y = 0;
        vidas[i].bmp = bmpCobraHead;
        vidas[i].visible = true;
    }
    	
	//INICIO: Desenho da área de status do jogo. Pontos, Fase, Tamanho, Tempo, Vidas
	for (int i = -1;i<2;i++){rect(status, xst+i, yst+i, xst2-i, 40-i, makecol(210,192,152));}
	
	textprintf_ex(status, myfont, xst+5,68, makecol(255,0,0), -1,"Fase: 1" );
	for (int i = -1;i<2;i++){rect(status, xst+i, yst+50+i, xst2-i, yst2+50-i, makecol(210,192,152));}
		
	for (int i = -1;i<2;i++){rect(status, xst+i, yst+100+i, xst2-i, yst2+100-i, makecol(210,192,152));}
	
	for (int i = -1;i<2;i++){rect(status, xst+i, yst+150+i, xst2-i, yst2+150-i, makecol(210,192,152));}
	
	for (int i = 0;i < 6; i++){
        if (vidas[i].visible){
           draw_sprite(status, vidas[i].bmp, vidas[i].x, vidas[i].y+195);
        }
    }
	//FIM: Desenho da área status do jogo. Pontos, Fase, Tamanho, Tempo, Vidas
		
	//INICIO: Desenho da Tabela de Comida do jogo.
	textprintf_ex(status, myfont, xL,yL-20, makecol(255,0,0 ), -1,"Comidas" );
	for (int i = -1;i<2;i++){rect(status, xL+i, yL+i, xL2-i, yL2-i, makecol(210,192,152));}
	draw_sprite(status, bmpMilho, xL+10, yL+10);
	textprintf_ex(status, font, xL+40,yL+20, makecol(255,255,0 ), -1,"10 pontos" );
	draw_sprite(status, bmpMaca, xL+10, yL+40);
	textprintf_ex(status, font, xL+40,yL+50, makecol(255,0,0 ), -1,"20 pontos" );
	draw_sprite(status, bmpAranha, xL+10, yL+70);
	textprintf_ex(status, font, xL+40,yL+80, makecol(153,0,255 ), -1,"30 pontos" );
	draw_sprite(status, bmpCobrinha, xL+10, yL+100);
	textprintf_ex(status, font, xL+40,yL+110, makecol(255,255,153 ), -1,"40 pontos" );
	draw_sprite(status, bmpSapo, xL+10, yL+130);
	textprintf_ex(status, font, xL+40,yL+140, makecol(110,220,0 ), -1,"50 pontos " );
	//FIM: Desenho da Tabela de Comida do jogo.


	//INICIO: Desenho do campo de ação da cobra.
    draw_sprite(buffer, bmpFundo, xC,yC);
	draw_sprite(buffer, bmpBordaVert, xC,yC);
	draw_sprite(buffer, bmpBordaVert, xC2-20,yC);
	draw_sprite(buffer, bmpBordaHoriz, xC,xC);
	draw_sprite(buffer, bmpBordaHoriz, xC,yC2-20);
	//FIM: Desenho do campo de ação da cobra
	

	//INICIO: Desenho da cobra
	snake[0].bmp = bmpCobraHead;  		     		
	for (int i = 1;i<tamCobra;i++){
			snake[i].bmp = bmpParte;  		   
	}
	//FIM: Desenho da cobra	
	
    char control;
    int veloc;
 control = menu_inicial();
  if (control == 'j'){veloc = 120;}else{veloc = 50;}
	
	play_midi(bgSound,0);		
	
	draw_sprite(screen,status,800,0);
	
	DesenhaCampoAcao();
		int x=20, y=20 , xx, yy;
		int dirx = 20, diry = 0;		
		int tipoCol = 0;
		int tamComida; //Tamanho que a comida capturada aumentará a cobra
		int ptsComida; //Quantidade de pontos que a comida vale
		int pontosAtual = 0; //Quantidade de pontos
	
	
	

	
		while (!key[KEY_ESC]) {

			DesenhaCampoAcao();		
			

 if(control == 't'){
			if (key[KEY_UP]){
		 	   if (dirx != 0) {
	 	  		  diry = -20;
		 	   	  dirx = 0;
	  			  }
			}
			
			if (key[KEY_DOWN]){
			   if (dirx != 0) {
				   diry = 20;
				   dirx = 0;
			   }
			}
			if (key[KEY_LEFT]){
			   if (diry != 0) {
				   dirx = -20;
				   diry = 0;
			   }
			}
			if (key[KEY_RIGHT]){
			   if (diry != 0) {
		  		  dirx = 20;
			   	  diry = 0;
	  			  }
			}

}
else if(control = 'j') {
     
 swt = inp32(0x379);
                 
         if (swt == 95){
		       if ((countMsecCmd / 100) > 1){
     		 	   if (dirx == 20 && diry == 0) {
		              diry = 20;
				      dirx = 0;
 			        }
		 	        else if (dirx == 0 && diry == 20) {
	                  dirx = -20;
				      diry = 0;
			        }	  			  
		 	        else if (dirx == -20 && diry == 0) {
	  		          diry = -20;
		 	   	      dirx = 0;
                    }	 
		 	        else if (dirx == 0 && diry == -20) {
                      dirx = 20;
			   	      diry = 0;
	  			    }	            
                    countMsecCmd = 0;  
               }       			  	  			  
			}
			
            if (swt == 63){
		       if ((countMsecCmd / 100) > 1){
     		 	   if (dirx == 0 && diry == 20) {
		              diry = 0;
				      dirx = 20;
 			        }
		 	        else if (dirx == 20 && diry == 0) {
	                  dirx = 0;
				      diry = -20;
			        }	  			  
		 	        else if (dirx == 0 && diry == -20) {
	  		          diry = 0;
		 	   	      dirx = -20;
                    }	 
		 	        else if (dirx == -20 && diry == 0) {
                      dirx = 0;
			   	      diry = 20;
	  			    }	            
                    countMsecCmd = 0;  
               }       			  	  			  
			}    
}     
			
		if ((countMsec / veloc) > 1){
		   			   
			x += dirx;
			y += diry;

			if (VerifCollision(snake, comidas, x, y, &xx, &yy, tamCobra, &tipoCol, &ptsComida, &tamComida)){
	           switch (tipoCol){
			   		  case 0:
					  	   break;
				  	   case 1://colisao com corpo
		           	   		textprintf_ex(screen, font, 0,560, makecol(255,0,0 ), -1,"Colisao Em   : x: %d  y: %d TipoCol: %d", xx, yy, tipoCol); 
				   			tipoCol = 0;
				   			ResetaPosicaoCobra(snake, tamCobra);
				   			play_sample(snakeHitSelf,255,90,1000,0);				   			
				   			if (qtdVidas > 1){qtdVidas=0;} else {qtdVidas = -1;}
                            MostraVidas(qtdVidas,vidas);
 				   			x=20; 
				   			y=20; 
				   			dirx = 20; 
				   			diry = 0;
				   			
				   			AcendeLuzes(); 
				   				
				  	   break;
			 		   case 2://colisao obstaculos
		           	   		textprintf_ex(screen, font, 0,560, makecol(255,0,0 ), -1,"Colisao Em   : x: %d  y: %d TipoCol: %d", xx, yy, tipoCol); 
				   			tipoCol = 0;
				   			ResetaPosicaoCobra(snake, tamCobra);
				   			play_sample(snakeHit,255,90,1000,0);
				   			qtdVidas--;
				   			MostraVidas(qtdVidas,vidas);				   			
 				   			x=20; 
				   			y=20; 
				   			dirx = 20; 
				   			diry = 0;
				   			
      				        AcendeLuzes(); 
                            						
					   break;
				  	   case 3: //colisao comida
					   		textprintf_ex(screen, font, 0,560, makecol(255,0,0 ), -1,"Colisao Em   : x: %d  y: %d TipoCol: %d", xx, yy, tipoCol); 
					   		AumentaCobra(snake, &tamCobra, tamComida, bmpParte);
					   		pontosAtual += ptsComida;
					   		tipoCol = 0;
					   		CriaComida(comidas);
				  	   break;					   
				  	  
	  			}
	  			
				 			
	  		}
	  		
	   			   
		   MoveSnake(snake, x, y, tamCobra); 
		   
		   MostraStatus(pontosAtual, tamCobra);
		   draw_sprite(screen,status,800,0);
		   countMsec = 0;
	  		
			
			for (int i = 0;i < tamCobra;i++){
		  		draw_sprite(buffer, snake[i].bmp, snake[i].x,snake[i].y);
			}



			for (int i = 0;i < 10;i++){
		 		if (comidas[i].visible){
				   	 draw_sprite(buffer, comidas[i].bmp, comidas[i].x,comidas[i].y);
				}
			}			
			
			

			draw_sprite(screen,buffer,0,0);
				
 		    IntercalaLeds();
			
		  }
        else if(qtdVidas < 0)
        {
            play_sample(snakeDeath,255,90,1000,0);
  			stop_midi();
 			play_sample(gameOver,255,90,1000,0);
            GravaRank(pontosAtual, countSec, tamCobra);
            clear_to_color(buffer, makecol(165,229,101));
            clear_to_color(screen, makecol(165,229,101));
            MostraRank();
            textprintf_ex(buffer, myfont, 300,500, makecol(255,0,0), -1,"Aperte ESC para sair...." );
            draw_sprite(screen,buffer,0,0);        
  			break;
        }
        }

        while (!key[KEY_ESC]) {}
        FinalizaPP();
}
예제 #16
0
void IntercalaLeds();



volatile int countMsec; // Variável Global
volatile int countSec; // Variável Global
volatile int countMsecCmd; // Variável Global
volatile int countMsecLed; // Variável Global

void ContaMsec();
void ContaSec();

PALLETE pallet;
BITMAP* buffer;
BITMAP* status;
SAMPLE* snakeBit = load_wav("sounds/snakeEat.wav");


int tamCobra = 2;
int qtdVidas = 6;
int xC=0, yC=0, xC2=780, yC2 = 580; //Coordenadas do campo de ação da cobra 

int as = 0;


BITMAP* bmpSapo;
BITMAP* bmpAranha;
BITMAP* bmpMaca;
BITMAP* bmpMilho;
BITMAP* bmpCobraHead;
BITMAP* bmpFundo;