bool credit_init(int parameter)
{
	credits = new Credits;
	if (credits->Init())
	{
		staterr("Credits initilization failed");
		return 1;
	}
	
	return 0;
}
BigImage::~BigImage()
{
	for(int i=0;i<MAX_BIGIMAGES;i++)
	{
		if (images[i])
		{
			staterr("BigImage: freeing image %d", i);
			delete images[i];
			images[i] = NULL;
		}
	}
}
Exemple #3
0
// create a bitmapped font with a drop-shadow.
bool NXFont::InitBitmapCharsShadowed(SDL_Surface *sheet, uint32_t fgcolor, \
									uint32_t color, uint32_t shadowcolor)
{
Uint32 format = screen->Format()->format;
NXFont fgfont, shadowfont;
SDL_Rect dstrect;



	// create temporary fonts in the fg and shadow color
	if (fgfont.InitBitmapChars(sheet, fgcolor, color))
		return 1;
	
	if (shadowfont.InitBitmapChars(sheet, fgcolor, shadowcolor))
		return 1;

	SDL_PixelFormat* pxformat = SDL_AllocFormat(format);
	if (!pxformat)
	{
		staterr("InitBitmapChars: SDL_AllocFormat failed: %s", SDL_GetError());
		return 1;
	}
	
	// now combine the two fonts
	uint32_t transp = SDL_MapRGB(pxformat, 0, 0, 0);
	for(int i=0;i<NUM_FONT_LETTERS;i++)
	{
		if (fgfont.letters[i])
		{
			letters[i] = SDL_CreateRGBSurface(0, \
							BITMAP_CHAR_WIDTH+1, BITMAP_CHAR_HEIGHT+1+SHADOW_OFFSET,
							pxformat->BitsPerPixel, \
							pxformat->Rmask, pxformat->Gmask,
							pxformat->Bmask, pxformat->Amask);
			
			SDL_FillRect(letters[i], NULL, transp);
			SDL_SetColorKey(letters[i], SDL_TRUE, transp);
			
			dstrect.x = 0;
			dstrect.y = SHADOW_OFFSET;
			SDL_BlitSurface(shadowfont.letters[i], NULL, letters[i], &dstrect);
			
			dstrect.x = 0;
			dstrect.y = 0;
			SDL_BlitSurface(fgfont.letters[i], NULL, letters[i], &dstrect);
		}
	}

	SDL_FreeFormat(pxformat);
	
	return 0;
}
Exemple #4
0
bool Game::createplayer()
{
	if (player)
	{
		staterr("game.createplayer: player already exists!");
		return 1;
	}
	
	player = (Player *)CreateObject(0, 0, OBJ_PLAYER);
	PInitFirstTime();
	
	return 0;
}
Exemple #5
0
char SSInit(void)
{
SDL_AudioSpec fmt, obtained;

	// Set 16-bit stereo audio at 22Khz
	fmt.freq = SAMPLE_RATE;
	fmt.format = AUDIO_S16;
	fmt.channels = 2;
	fmt.samples = 512;
	fmt.callback = mixaudio;
	fmt.userdata = NULL;
	
	// Open the audio device and start playing sound!
	if (SDL_OpenAudio(&fmt, &obtained) < 0)
	{
		staterr("SS: Unable to open audio: %s", SDL_GetError());
		return 1;
	}
	
	if (obtained.format != fmt.format || \
		obtained.channels != fmt.channels)
	{
		staterr("SS: Failed to obtain the audio format I wanted");
		return 1;
	}
	
	mixbuffer = (uint8_t *)malloc(obtained.samples * obtained.channels * 2);
	
	// zero everything in all channels
	memset(channel, 0, sizeof(channel));
	for(int i=0;i<SS_NUM_CHANNELS;i++)
		channel[i].volume = SDL_MIX_MAXVOLUME;
	
	stat("sslib: initilization was successful.");
	
	lockcount = 0;
	SDL_PauseAudio(0);
	return 0;
}
void BigImage::Set(int num)
{
	if (images[num])
	{
		imgno = num;
		imagex = -images[num]->Width();
		state = BI_SLIDE_IN;
	}
	else
	{
		staterr("BigImage::Set: invalid image number %d", num);
		state = BI_CLEAR;
	}
}
Exemple #7
0
bool sound_init(void)
{
	if (SSInit()) return 1;
	if (pxt_init()) return 1;
	if (pxt_LoadSoundFX(pxt_dir, sndcache, NUM_SOUNDS)) return 1;
	
	if (org_init(org_wavetable, pxt_dir, ORG_VOLUME))
	{
		staterr("Music failed to initialize");
		return 1;
	}
	
	return 0;
}
Exemple #8
0
void CFlashingCursor::erase(int cx, int cy)
{
int x, y, line_number;
EditView *ev = editor.curev;

	visible = 0;
	if (cy < 0 || cy >= editor.height || !ev) return;
	//stat("erase[%d, %d]", cx, cy);
	
	x = GET_CURSOR_PX(cx);
	y = GET_CURSOR_PY(cy);
	
	// restore the image behind the cursor
	LockWindow();
	line_number = (ev->scroll.y + cy);
	
	if (line_number >= ev->nlines)
	{
		MainView->SetLowColor(GetEditBGColor(COLOR_TEXT));
		MainView->FillRect(BRect(x, y, x + (CURSOR_W - 1), y + (CURSOR_H - 1)), B_SOLID_LOW);
	}
	else
	{
		editor.curline_bb->Lock();
		
		if (line_number != editor.bbed_line)
		{
			clLine *line = ev->GetLineHandle(line_number);
			if (line)
			{
				if (!line->lexresult.points) lexer_update_line(line);
				UpdateLine(ev, editor.curline_bb, line, 0, line_number);
				editor.bbed_line = line_number;
			}
			else
			{
				staterr("CFlashingCursor::erase: could not obtain line handle to update BB");
			}
		}
		
		BRect source(x, 0, x + (CURSOR_W - 1), CURSOR_H-1);
		BRect dest(x, y, x + (CURSOR_W - 1), y + (CURSOR_H-1));
		
		editor.curline_bb->BlitTo(view, source, dest);
		editor.curline_bb->Unlock();
	}
	
	UnlockWindow();
}
Exemple #9
0
void SIFSpritesSect::LoadPointList(SIFPointList *lst, const uint8_t **data, const uint8_t *data_end)
{
	lst->count = read_U8(data, data_end);
	if (lst->count > SIF_MAX_BLOCK_POINTS)
	{
		staterr("SIFSpritesSect::LoadPointList: too many block points (%d, max=%d)", lst->count, SIF_MAX_BLOCK_POINTS);
		return;
	}
	
	for(int i=0;i<lst->count;i++)
	{
		lst->point[i].x = (int16_t)read_U16(data, data_end);
		lst->point[i].y = (int16_t)read_U16(data, data_end);
	}
}
Exemple #10
0
NXSurface* NXSurface::createScreen(int wd, int ht, Uint32 pixel_format)
{
	if (GraphicHacks::Init(renderer))
	{
		staterr("unable to init GraphicHacks");
		return NULL;
	}

	NXSurface* s = new NXSurface();
	s->tex_w = wd;
	s->tex_h = ht;
	s->setPixelFormat(pixel_format);

	return s;
}
Exemple #11
0
int SDL_main(int argc, char *argv[])
{
	stat("Entering main loop");
	testblit();

	if (SSInit()) return 1;
	if (pxt_init()) return 1;
	
	if (pxt_LoadSoundFX(pxt_dir, sndcache, 0x75)) {
		printf("Can't load\n");
		return 1;
	}

	if (org_init(org_wavetable, pxt_dir, ORG_VOLUME))
	{
		staterr("Music failed to initialize");
		return 1;
	}

	music(19);

	while(!quitting)
	{
		org_run();
		
		SDL_Event pie;
		if (SDL_PollEvent(&pie))
		{
			if (pie.type == SDL_KEYDOWN) {
				
				if(pie.key.keysym.sym == SDLK_F3)
					quitting = true;
				else if(pie.key.keysym.sym == SDLK_BTN_A)
					pxt_Play(-1, 1, 1);
				else if(pie.key.keysym.sym == SDLK_BTN_B)
					org_stop();
				else if(pie.key.keysym.sym == SDLK_BTN_Y)
					music(random(1,42));
			}
		}
	}


	pxt_freeSoundFX();
	SSClose();

	return 0;
}
Exemple #12
0
static void fatal(const char *str)
{
	staterr("fatal: '%s'", str);
	
	if (!safemode::init())
	{
		safemode::moveto(SM_UPPER_THIRD);
		safemode::print("Fatal Error");
		
		safemode::moveto(SM_CENTER);
		safemode::print("%s", str);
		
		safemode::run_until_key();
		safemode::close();
	}
}
Exemple #13
0
void FileBuffer::CheckFlush(int maxsize)
{
	if (fBuffer.Length() >= maxsize)
	{
		if (fFP)
		{
			//stat("CheckFlush wrote %d bytes", fBuffer.Length());
			fwrite(fBuffer.Data(), fBuffer.Length(), 1, fFP);
			fBuffer.Clear();
		}
		else
		{
			staterr("CheckFlush: no file");
		}
	}
}
Exemple #14
0
bool NXFont::InitTextures()
{
	for (int i = 0; i < NUM_FONT_LETTERS; ++i)
	{
		if (!letters[i])
			continue;

		tletters[i] = SDL_CreateTextureFromSurface(renderer, letters[i]);
		if (!tletters[i])
		{
			staterr("NXFont::InitTextures() SDL_CreateTextureFromSurface failed: %s", SDL_GetError());
			return true;
		}
	}

	return false;
}
Exemple #15
0
bool CredReader::OpenFile(void)
{
char fname[MAXPATHLEN];

	if (data) CloseFile();
	sprintf(fname, "%s/Credit.tsc", data_dir);
	
	data = tsc_decrypt(fname, &datalen);
	if (!data)
	{
		staterr("CredReader: couldn't open '%s'!", fname);
		return 1;
	}
	
	stat("CredReader: '%s' loaded ok!", fname);
	dataindex = 0;
	return 0;
}
Exemple #16
0
bool sound_init(void)
{
    pxt_dir = "pxt/";
    org_dir = "org/";
    sndcache = "sndcache.pcm";
    org_wavetable = "wavetable.dat";
	if (SSInit()) return 1;
	if (pxt_init()) return 1;
	if (pxt_LoadSoundFX(pxt_dir, sndcache, NUM_SOUNDS)) return 1;
	
	if (org_init(org_wavetable, pxt_dir, ORG_VOLUME))
	{
		staterr("Music failed to initialize");
		return 1;
	}
	
	return 0;
}
Exemple #17
0
// returns the currently playing sample within the currently playing chunk
// of channel c. If no chunk is playing, the results are undefined.
// as with "len" parameter to SSEnqueueChunk, the count counts the two
// components of a stereo sample as a single sample.
int SSGetSamplePos(int c)
{
int result;

	SSLockAudio();
	
	if (channel[c].head != channel[c].tail)
	{
		result = (channel[c].chunks[channel[c].head].bytepos / 4);
	}
	else
	{
		staterr("SSGetSamplePos: channel %d is not playing!", c);
		result = -1;
	}
	
	SSUnlockAudio();
	return result;
}
Exemple #18
0
// returns the userdata member of the currently playing chunk on channel c.
// if channel c is not playing, the results are undefined.
int SSGetCurUserData(int c)
{
int result;

	SSLockAudio();
	
	if (channel[c].head != channel[c].tail)
	{
		result = (channel[c].chunks[channel[c].head].userdata);
	}
	else
	{
		staterr("SSGetUserData: channel %d is not playing!\n", c);
		result = -1;
	}
	
	SSUnlockAudio();
	return result;
}
Exemple #19
0
// allocate for an empty surface of the given size
bool NXSurface::AllocNew(int wd, int ht, NXFormat* format)
{
	Free();

	stat("NXSurface::AllocNew this = %p", this);

	fTexture = SDL_CreateTexture(renderer, format->format, SDL_TEXTUREACCESS_TARGET, wd*SCALE, ht*SCALE);
	
	if (!fTexture)
	{
		staterr("NXSurface::AllocNew: failed to allocate texture: %s", SDL_GetError());
		return true;
	}

	tex_w = wd*SCALE;
	tex_h = ht*SCALE;
	
	return false;
}
Exemple #20
0
// save the timestamp in value to 290.rec.
bool niku_save(uint32_t value)
{
uint8_t buf_byte[20];
uint32_t *buf_dword = (uint32_t *)buf_byte;

	// place values
	buf_dword[0] = value;
	buf_dword[1] = value;
	buf_dword[2] = value;
	buf_dword[3] = value;
	
	// generate keys
	buf_byte[16] = random(0, 255);
	buf_byte[17] = random(0, 255);
	buf_byte[18] = random(0, 255);
	buf_byte[19] = random(0, 255);
	
	// encode each copy
	for(int i=0;i<4;i++)
	{
		uint8_t *ptr = (uint8_t *)&buf_dword[i];
		uint8_t key = buf_byte[i+16];
		
		ptr[0] += key;
		ptr[1] += key;
		ptr[2] += key;
		ptr[3] += key / 2;
	}
	
	const char *fname = getfname();
	FILE *fp = fopen(fname, "wb");
	if (!fp)
	{
		staterr("niku_save: failed to open '%s'", fname);
		return 1;
	}
	
	fwrite(buf_byte, 20, 1, fp);
	fclose(fp);
	
	stat("niku_save: wrote value 0x%08x", value);
	return 0;
}
bool IrregularBBox::init(Object *associatedObject, int max_rectangles)
{
        memset(&bbox, 0, sizeof(bbox));
        this->num_bboxes = max_rectangles;
        this->assoc_object = associatedObject;

        if (num_bboxes >= IB_MAX_BBOXES) {
                num_bboxes = IB_MAX_BBOXES;
                staterr("IrregularBBox::Init(): too many rectangles (%d given): max is %d", max_rectangles, IB_MAX_BBOXES);
                return 1;
        }

        for(int i=0; i<num_bboxes; i++) {
                bbox[i] = CreateObject(0, 0, OBJ_BBOX_PUPPET);
                bbox[i]->sprite = SPR_BBOX_PUPPET_1 + i;
                bbox[i]->hp = 1000;
                bbox[i]->damage = 0;
                bbox[i]->invisible = true;
        }

        return 0;
}
Exemple #22
0
bool NXFont::InitChars(TTF_Font *font, uint32_t color)
{
SDL_Color fgcolor;
SDL_Surface *letter;

	fgcolor.r = (uint8_t)(color >> 16);
	fgcolor.g = (uint8_t)(color >> 8);
	fgcolor.b = (uint8_t)(color);

#ifdef _L10N_CP1251
    char utf8_str[2];
#endif
	
	char str[2];
	str[1] = 0;
	
	for(int i=1;i<NUM_LETTERS_RENDERED;i++)
	{
		str[0] = i;
#ifndef _L10N_CP1251
        letter = TTF_RenderUTF8_Solid(font, str, fgcolor);
#else
        win1251_to_utf8(str, utf8_str);
        letter = TTF_RenderUTF8_Solid(font, utf8_str, fgcolor);
#endif
		if (!letter)
		{
			staterr("InitChars: failed to render character %d: %s", i, TTF_GetError());
			return 1;
		}
		
		letters[i] = SDL_DisplayFormat(letter);
		SDL_FreeSurface(letter);
	}
	
	return 0;
}
Exemple #23
0
// given a paletted surface add it's colors in to the screen colormap
// then return a surface with the color indexes remapped ready to
// be displayed on the screen. insfc is either freed, or reused to
// create the returned surface.
SDL_Surface *palette_add(SDL_Surface *sfc)
{
    SDL_Palette *pal = sfc->format->palette;
    int remap[MAX_COLORS];
    int x, y, i;

    if (sfc->format->BitsPerPixel > 8)
    {
        staterr("palette_add: input surface is > 8bpp");
        return NULL;
    }

    stat("palette_add: adding %d colors to screen palette...", pal->ncolors);
    for(i=0; i<pal->ncolors; i++)
    {
        remap[i] = palette_alloc(pal->colors[i].r, pal->colors[i].g, pal->colors[i].b);
        if (remap[i] == -1)
            return sfc;
    }

    SDL_SetColors(screen->GetSDLSurface(), screenpal, 0, ncolors);
    return sfc;
    /*
    	// remap indexes in surface
    	for(y=0;y<sfc->h;y++)
    	{
    		uint8_t *pixels = (uint8_t *)sfc->pixels + (y * sfc->pitch);

    		for(x=0;x<sfc->w;x++)
    		{
    			*pixels = remap[*pixels];
    			pixels++;
    		}
    	}

    	return sfc;*/
}
Exemple #24
0
void NXSurface::DrawBatchAdd(NXSurface *src, int dstx, int dsty, int srcx, int srcy, int wd, int ht)
{
	assert(renderer);
	assert(src->fTexture);

	SDL_Rect srcrect, dstrect;

	srcrect.x = srcx * SCALE;
	srcrect.y = srcy * SCALE;
	srcrect.w = wd * SCALE;
	srcrect.h = ht * SCALE;
	
	dstrect.x = dstx * SCALE;
	dstrect.y = dsty * SCALE;
	dstrect.w = srcrect.w;
	dstrect.h = srcrect.h;

	if (need_clip) clip(srcrect, dstrect);
	
	if (GraphicHacks::BatchAddCopy(renderer, src->fTexture, &srcrect, &dstrect))
	{
		staterr("NXSurface::DrawBatchAdd: GraphicHacks::BatchAddCopy failed");
	}
}
Exemple #25
0
int main(int argc, char *argv[])
{
bool inhibit_loadfade = false;
bool error = false;
bool freshstart;
	
	SetLogFilename("debug.txt");
	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0)
	{
		staterr("ack, sdl_init failed: %s.", SDL_GetError());
		return 1;
	}
	atexit(SDL_Quit);
	
	// start up inputs first thing because settings_load may remap them
	input_init();
	
	// load settings, or at least get the defaults,
	// so we know the initial screen resolution.
	settings_load();
	
	if (Graphics::init(settings->resolution)) { staterr("Failed to initialize graphics."); return 1; }
	if (font_init()) { staterr("Failed to load font."); return 1; }
	
	//speed_test();
	//return 1;
	
	#ifdef CONFIG_DATA_EXTRACTOR
	if (!settings->files_extracted)
	{
		if (extract_main())
		{
			Graphics::close();
			font_close();
			return 0;
		}
		else
		{
			settings->files_extracted = true;
			settings_save();
		}
	}
	#endif
	
	if (check_data_exists())
	{
		return 1;
	}
	
	Graphics::ShowLoadingScreen();
	if (sound_init()) { fatal("Failed to initialize sound."); return 1; }
	if (trig_init()) { fatal("Failed trig module init."); return 1; }
	
	if (tsc_init()) { fatal("Failed to initialize script engine."); return 1; }
	if (textbox.Init()) { fatal("Failed to initialize textboxes."); return 1; }
	if (Carets::init()) { fatal("Failed to initialize carets."); return 1; }
	
	if (game.init()) return 1;
	game.setmode(GM_NORMAL);
	// set null stage just to have something to do while we go to intro
	game.switchstage.mapno = 0;
	
	//#define REPLAY
	#ifdef REPLAY
		game.switchstage.mapno = START_REPLAY;
		//Replay::set_ffwd(6000);
		//Replay::set_stopat(3500);
		game.switchstage.param = 1;
	#else
		//game.switchstage.mapno = LOAD_GAME;
		//game.pause(GP_OPTIONS);
		
		if (settings->skip_intro && file_exists(GetProfileName(settings->last_save_slot)))
			game.switchstage.mapno = LOAD_GAME;
		else
			game.setmode(GM_INTRO);
	#endif
	
	// for debug
	if (game.paused) { game.switchstage.mapno = 0; game.switchstage.eventonentry = 0; }
	if (game.switchstage.mapno == LOAD_GAME) inhibit_loadfade = true;
	
	game.running = true;
	freshstart = true;
	
	stat("Entering main loop...");
	#ifdef __SDLSHIM__
		set_console_visible(false);
	#endif
	
	//speed_test();
	//return 1;
	
	while(game.running)
	{
		// SSS/SPS persists across stage transitions until explicitly
		// stopped, or you die & reload. It seems a bit risky to me,
		// but that's the spec.
		if (game.switchstage.mapno >= MAPNO_SPECIALS)
		{
			StopLoopSounds();
		}
		
		// enter next stage, whatever it may be
		if (game.switchstage.mapno == LOAD_GAME || \
			game.switchstage.mapno == LOAD_GAME_FROM_MENU)
		{
			if (game.switchstage.mapno == LOAD_GAME_FROM_MENU)
				freshstart = true;
			
			stat("= Loading game =");
			if (game_load(settings->last_save_slot))
			{
				fatal("savefile error");
				goto ingame_error;
			}
			
			Replay::OnGameStarting();
			
			if (!inhibit_loadfade) fade.Start(FADE_IN, FADE_CENTER);
			else inhibit_loadfade = false;
		}
		else if (game.switchstage.mapno == START_REPLAY)
		{
			stat(">> beginning replay '%s'", GetReplayName(game.switchstage.param));
			
			StopScripts();
			if (Replay::begin_playback(GetReplayName(game.switchstage.param)))
			{
				fatal("error starting playback");
				goto ingame_error;
			}
		}
		else
		{
			if (game.switchstage.mapno == NEW_GAME || \
				game.switchstage.mapno == NEW_GAME_FROM_MENU)
			{
				bool show_intro = (game.switchstage.mapno == NEW_GAME_FROM_MENU);
				InitNewGame(show_intro);
			}
			
			// slide weapon bar on first intro to Start Point
			if (game.switchstage.mapno == STAGE_START_POINT && \
				game.switchstage.eventonentry == 91)
			{
				freshstart = true;
			}
			
			// switch maps
			if (load_stage(game.switchstage.mapno)) goto ingame_error;
			
			player->x = (game.switchstage.playerx * TILE_W) << CSF;
			player->y = (game.switchstage.playery * TILE_H) << CSF;
		}
		
		// start the level
		if (game.initlevel()) return 1;
		
		if (freshstart)
			weapon_introslide();
		
		gameloop();
		game.stageboss.OnMapExit();
		freshstart = false;
	}
	
shutdown: ;
	Replay::close();
	game.close();
	Carets::close();
	
	Graphics::close();
	input_close();
	font_close();
	sound_close();
	tsc_close();
	textbox.Deinit();
	return error;
	
ingame_error: ;
	stat("");
	stat(" ************************************************");
	stat(" * An in-game error occurred. Game shutting down.");
	stat(" ************************************************");
	error = true;
	goto shutdown;
}
Exemple #26
0
bool pmd_load(const char *fname)
{
FILE *fp;
int i, t;

	stat("----------------------");
	stat("pmd_load: opening '%s'", fname);
	
	fp = fopen(fname, "rb");
	if (!fp)
	{
		staterr("pmd_load: failed to open '%s'", fname);
		return 1;
	}
	
	if (!fverifystring(fp, "PMD"))
	{
		staterr("pmd_load: not a PMD file: '%s'", fname);
		fclose(fp);
		return 1;
	}
	
	fgetc(fp);		// I dunno
	fgetl(fp);		// I dunno
	song.ms_per_beat = fgetl(fp);	// music wait
	song.loop_start = fgetl(fp);
	song.loop_end = fgetl(fp);
	song.nnotes = fgetl(fp);
	
	stat("song wait: %d (0x%04x)", song.ms_per_beat, song.ms_per_beat);
	stat("nnotes: %d (0x%04x)", song.nnotes, song.nnotes);
	stat("loop: %d-%d", song.loop_start, song.loop_end);
	
	// original PiyoPiyo and Ikachan seem to play things slightly slower than specified,
	// although PiyoPiyoPlayer plays it as spec'd in the file.
	if (strstr(fname, "Buriki"))
		song.ms_per_beat += 10;
	else
		song.ms_per_beat += 5;
	
	// load instrument samples
	for(i=0;i<NUM_TRACKS;i++)
		load_instrument(fp, &song.track[i].instrument);
	
	for(i=0;i<TOTAL_TRACKS;i++)
		song.track[i].no = i;
	
	// drum volume
	song.drum_volume = fgetl(fp);
	
	// load music notes
	for(t=0;t<TOTAL_TRACKS;t++)
	{
		stTrack *track = &song.track[t];
		
		for(i=0;i<song.nnotes;i++)
		{
			uint32_t mask = fgetl(fp);
			
			track->note[i].notemask = (mask & 0xffffff);
			
			track->note[i].panning = (mask >> 24);
			if (!track->note[i].panning)
				track->note[i].panning = PAN_CENTER;
			else
				track->note[i].panning--;
		}
	}
	
	return 0;
}
Exemple #27
0
// load savefile #num into the given Profile structure.
bool profile_load(const char *pfname, Profile *file)
{
int i, curweaponslot;
VMFILE *fp;

	stat("Loading profile from %s...", pfname);
	memset(file, 0, sizeof(Profile));
	
	fp = vm_fileopen(pfname, "rb");
	if (!fp)
	{
		staterr("profile_load: unable to open '%s'", pfname);
		return 1;
	}
	
	if (!vm_fverifystring(fp, "Do041220"))
	{
		staterr("profile_load: invalid savegame format: '%s'", pfname);
		vm_fclose(fp);
		return 1;
	}
	
	file->stage = vm_fgetl(fp);
	file->songno = vm_fgetl(fp);
	
	file->px = vm_fgetl(fp);
	file->py = vm_fgetl(fp);
	file->pdir = CVTDir(vm_fgetl(fp));
	
	file->maxhp = vm_fgeti(fp);
	file->num_whimstars = vm_fgeti(fp);
	file->hp = vm_fgeti(fp);
	
	vm_fgeti(fp);						// unknown value
	curweaponslot = vm_fgetl(fp);		// current weapon (slot, not number, converted below)
	vm_fgetl(fp);						// unknown value
	file->equipmask = vm_fgetl(fp);	// equipped items
	
	// load weapons
	vm_fseek(fp, PF_WEAPONS_OFFS, SEEK_SET);
	for(i=0;i<MAX_WPN_SLOTS;i++)
	{
		int type = vm_fgetl(fp);
		if (!type) break;
		
		int level = vm_fgetl(fp);
		int xp = vm_fgetl(fp);
		int maxammo = vm_fgetl(fp);
		int ammo = vm_fgetl(fp);
		
		file->weapons[type].hasWeapon = true;
		file->weapons[type].level = (level - 1);
		file->weapons[type].xp = xp;
		file->weapons[type].ammo = ammo;
		file->weapons[type].maxammo = maxammo;
		
		if (i == curweaponslot)
		{
			file->curWeapon = type;
		}
	}
	
	// load inventory
	file->ninventory = 0;
	vm_fseek(fp, PF_INVENTORY_OFFS, SEEK_SET);
	for(i=0;i<MAX_INVENTORY;i++)
	{
		int item = vm_fgetl(fp);
		if (!item) break;
		
		file->inventory[file->ninventory++] = item;
	}
	
	// load teleporter slots
	file->num_teleslots = 0;
	vm_fseek(fp, PF_TELEPORTER_OFFS, SEEK_SET);
	for(i=0;i<NUM_TELEPORTER_SLOTS;i++)
	{
		int slotno = vm_fgetl(fp);
		int scriptno = vm_fgetl(fp);
		if (slotno == 0) break;
		
		file->teleslots[file->num_teleslots].slotno = slotno;
		file->teleslots[file->num_teleslots].scriptno = scriptno;
		file->num_teleslots++;
	}
	
	// load flags
	vm_fseek(fp, PF_FLAGS_OFFS, SEEK_SET);
	if (!vm_fverifystring(fp, "FLAG"))
	{
		staterr("profile_load: missing 'FLAG' marker");
		vm_fclose(fp);
		return 1;
	}
	
	vm_fresetboolean();
	for(i=0;i<NUM_GAMEFLAGS;i++)
	{
		file->flags[i] = vm_fbooleanread(fp);
	}
	
	vm_fclose(fp);
	return 0;
}
Exemple #28
0
bool profile_save(const char *pfname, Profile *file)
{
VMFILE *fp;
int i;

	//stat("Writing saved game to %s...", pfname);
	fp = vm_fileopen(pfname, "wb");
	if (!fp)
	{
		staterr("profile_save: unable to open %s", pfname);
		return 1;
	}
	
	vm_fputstringnonull("Do041220", fp);
	
	vm_fputl(file->stage, fp);
	vm_fputl(file->songno, fp);
	
	vm_fputl(file->px, fp);
	vm_fputl(file->py, fp);
	vm_fputl((file->pdir == RIGHT) ? 2:0, fp);
	
	vm_fputi(file->maxhp, fp);
	vm_fputi(file->num_whimstars, fp);
	vm_fputi(file->hp, fp);
	
	vm_fseek(fp, 0x2C, SEEK_SET);
	vm_fputi(file->equipmask, fp);
	
	// save weapons
	vm_fseek(fp, PF_WEAPONS_OFFS, SEEK_SET);
	int slotno = 0, curweaponslot = 0;
	
	for(i=0;i<WPN_COUNT;i++)
	{
		if (file->weapons[i].hasWeapon)
		{
			vm_fputl(i, fp);
			vm_fputl(file->weapons[i].level + 1, fp);
			vm_fputl(file->weapons[i].xp, fp);
			vm_fputl(file->weapons[i].maxammo, fp);
			vm_fputl(file->weapons[i].ammo, fp);
			
			if (i == file->curWeapon)
				curweaponslot = slotno;
			
			slotno++;
			if (slotno >= MAX_WPN_SLOTS) break;
		}
	}
	
	if (slotno < MAX_WPN_SLOTS)
		vm_fputl(0, fp);	// 0-type weapon: terminator
	
	// go back and save slot no of current weapon
	vm_fseek(fp, PF_CURWEAPON_OFFS, SEEK_SET);
	vm_fputl(curweaponslot, fp);
	
	// save inventory
	vm_fseek(fp, PF_INVENTORY_OFFS, SEEK_SET);
	for(i=0;i<file->ninventory;i++)
	{
		vm_fputl(file->inventory[i], fp);
	}
	
	vm_fputl(0, fp);
	
	// write teleporter slots
	vm_fseek(fp, PF_TELEPORTER_OFFS, SEEK_SET);
	for(i=0;i<MAX_TELE_SLOTS;i++)
	{
		if (i < file->num_teleslots)
		{
			vm_fputl(file->teleslots[i].slotno, fp);
			vm_fputl(file->teleslots[i].scriptno, fp);
		}
		else
		{
			vm_fputl(0, fp);
			vm_fputl(0, fp);
		}
	}
	
	// write flags
	vm_fseek(fp, PF_FLAGS_OFFS, SEEK_SET);
	vm_fputstringnonull("FLAG", fp);
	
	vm_fresetboolean();
	for(i=0;i<NUM_GAMEFLAGS;i++)
	{
		vm_fbooleanwrite(file->flags[i], fp);
	}
	
	vm_fbooleanflush(fp);
	
	vm_fclose(fp);
	return 0;
}
Exemple #29
0
// load the surface from a .pbm or bitmap file
bool NXSurface::LoadImage(const char *pbm_name, bool use_colorkey, int use_display_format)
{
	stat("NXSurface::LoadImage name = %s, this = %p", pbm_name, this);

	Free();
	
	// if (use_display_format == -1)
	// {	// use value specified in settings
	// 	use_display_format = settings->displayformat;
	// }
	

	SDL_RWops* rwops = fileopen_SDL_RWops_RO(pbm_name);
	if (!rwops) { staterr("NXSurface::LoadImage: load failed of '%s'! %s", pbm_name, SDL_GetError()); return 1; }
	SDL_Surface *image = SDL_LoadBMP_RW(rwops, 1);
	if (!image) { staterr("NXSurface::LoadImage: load failed of '%s'! %s", pbm_name, SDL_GetError()); return 1; }
	
	if (use_colorkey)
	{
		SDL_SetColorKey(image, SDL_TRUE, SDL_MapRGB(image->format, 0, 0, 0));
	}

	SDL_Texture * tmptex = SDL_CreateTextureFromSurface(renderer, image);
	if (!tmptex)
	{
		staterr("NXSurface::LoadImage: SDL_CreateTextureFromSurface failed: %s", SDL_GetError());
		SDL_FreeSurface(image);
		return 1;
	}

	SDL_FreeSurface(image);

	{
		int wd, ht, access;
		Uint32 format;
		NXFormat nxformat;
		if (SDL_QueryTexture(tmptex, &format, &access, &wd, &ht)) goto error;
		nxformat.format = format;
		if (AllocNew(wd, ht, &nxformat)) goto error;
		if (SDL_SetTextureBlendMode(tmptex, SDL_BLENDMODE_NONE))	goto error;
		if (SDL_SetRenderTarget(renderer, fTexture)) goto error;
		if (SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255)) goto error;
		if (SDL_RenderClear(renderer)) goto error;
		if (SDL_RenderCopy(renderer, tmptex, NULL, NULL)) goto error;
		if (SDL_SetRenderTarget(renderer, NULL)) goto error;
		if (SDL_SetTextureBlendMode(fTexture, SDL_BLENDMODE_BLEND)) goto error;

		SDL_DestroyTexture(tmptex);

		goto done;
error:
		{
			staterr("NXSurface::LoadImage failed: %s", SDL_GetError());
			if (tmptex)  { SDL_DestroyTexture(tmptex); tmptex = NULL; }
			if (fTexture){ SDL_DestroyTexture(fTexture); fTexture = NULL; }
			SDL_SetRenderTarget(renderer, NULL);
		}
done:
		;
	}

	stat("NXSurface::LoadImage name = %s, this = %p done", pbm_name, this);

	return (fTexture == NULL);
}
Exemple #30
0
bool font_init(void)
{
bool error = false;

	// we'll be bypassing the NXSurface automatic scaling features
	// and drawing at the real resolution so we can get better-looking fonts.
//	sdl_screen = screen->GetSDLSurface();
	
	// at 320x240 switch to bitmap fonts for better appearance
	#ifdef CONFIG_ENABLE_TTF
	if (SCALE == 1)
	#endif
	{
		stat("fonts: using bitmapped from %s", bmpfontfile);
		
		SDL_RWops* rwops = fileopen_SDL_RWops_RO(bmpfontfile);
		if (!rwops) { staterr("Couldn't open bitmap font file %s: SDL_RWFromFP: %s", bmpfontfile, SDL_GetError()); return 1; }
		SDL_Surface *sheet = SDL_LoadBMP_RW(rwops, 1);
		if (!sheet) { staterr("Couldn't open bitmap font file: SDL_LoadBMP_RW: %s", SDL_GetError()); return 1; }
		
		uint32_t fgindex = SDL_MapRGB(sheet->format, 255, 255, 255);
		
		error = error || whitefont.InitBitmapChars(sheet, fgindex, 0xffffff);
		error = error || greenfont.InitBitmapChars(sheet, fgindex, 0x00ff80);
		error = error || bluefont.InitBitmapChars(sheet, fgindex, 0xa0b5de);
		error = error || shadowfont.InitBitmapCharsShadowed(sheet, fgindex, 0xffffff, 0x000000);
	}
	#ifdef CONFIG_ENABLE_TTF
	else
	{
		// It will get size 8, 17, 26, 35, ...
		// Hope ot will look nice on higher resolutions
		int pointsize = 8 + 9 * (SCALE - 1);
        
		stat("fonts: using truetype at %dpt", pointsize);

		// initilize normal TTF fonts
		if (TTF_Init() < 0)
		{
			staterr("Couldn't initialize SDL_ttf: %s", TTF_GetError());
			return 1;
		}
		
		TTF_Font *font = TTF_OpenFontRW(SDL_RWFromFP(fileopenRO(ttffontfile), SDL_TRUE), 1, pointsize);
		if (!font)
		{
			staterr("Couldn't open font: '%s'", ttffontfile);
			return 1;
		}
		
		error = error || whitefont.InitChars(font, 0xffffff);
		error = error || greenfont.InitChars(font, 0x00ff80);
		error = error || bluefont.InitChars(font, 0xa0b5de);
		error = error || shadowfont.InitCharsShadowed(font, 0xffffff, 0x000000);
		
		TTF_CloseFont(font);
	}
	#endif

	error = error || whitefont.InitTextures();
	error = error || greenfont.InitTextures();
	error = error || bluefont.InitTextures();
	error = error || shadowfont.InitTextures();
	
	error = error || create_shade_sfc();
	if (error) return 1;
	
	fontheight = (whitefont.letters['M']->h / SCALE);
	initilized = true;
	return 0;
}