void Scene_Battle::Start() {
if (Player::battle_test_flag) {
Game_Temp::battle_troop_id = Player::battle_test_troop_id;
}
if (Game_Temp::battle_troop_id <= 0 ||
Game_Temp::battle_troop_id > (int)Data::troops.size()) {
Output::Warning("Invalid Monster Party Id %d", Game_Temp::battle_troop_id);
Game_Temp::battle_result = Game_Temp::BattleVictory;
Scene::Pop();
return;
}
if (Player::battle_test_flag) {
InitBattleTest();
} else {
Main_Data::game_enemyparty.reset(new Game_EnemyParty());
Main_Data::game_enemyparty->Setup(Game_Temp::battle_troop_id);
}
Game_Battle::Init();
cycle = 0;
auto_battle = false;
enemy_action = NULL;
CreateCursors();
CreateWindows();
screen.reset(new Screen());
Game_Temp::map_bgm = NULL; // Play map BGM on Scene_Map return
Game_System::BgmPlay(Data::system.battle_music);
Game_System::SePlay(Data::system.battle_se);
if (!Game_Temp::battle_background.empty())
background.reset(new Background(Game_Temp::battle_background));
else
background.reset(new Background(Game_Temp::battle_terrain_id));
SetState(State_Start);
}
/***********************************************************************
* Procedure:
* Setup Screen - main function
************************************************************************/
void
SetupScreen()
{
Scr.Look.magic = MAGIC_MYLOOK ;
InitLook(&Scr.Look, False);
InitFeel(&Scr.Feel, False);
Scr.Vx = Scr.Vy = 0;
Scr.CurrentDesk = 0;
Scr.randomx = Scr.randomy = 0;
Scr.RootCanvas = create_ascanvas_container( Scr.Root );
SetupColormaps();
CreateCursors ();
CreateManagementWindows();
Scr.Windows = init_aswindow_list();
XSelectInput (dpy, Scr.Root, AS_ROOT_EVENT_MASK);
MenuBalloons = create_balloon_state();
TitlebarBalloons = create_balloon_state();
}
int main(int argc, char **argv)
{
unsigned long valuemask; /* mask for create windows */
XSetWindowAttributes attributes; /* attributes for create windows */
void InternUsefulAtoms(void);
void InitVariables(void);
int i, len;
extern int x_fd;
char *display_string;
char message[255];
Bool single = False;
Bool option_error = FALSE;
MenuRoot *mr;
g_argv = argv;
g_argc = argc;
OpenConsole();
DBUG("main", "Entered, about to parse args");
for (i = 1; i < argc; i++) {
if (strncasecmp(argv[i], "-debug", 6) == 0) {
debugging = True;
} else if (strncasecmp(argv[i], "-s", 2) == 0) {
single = True;
} else if (strncasecmp(argv[i], "-d", 2) == 0) {
if (++i >= argc)
usage();
display_name = argv[i];
} else if (strncasecmp(argv[i], "-f", 2) == 0) {
if (++i >= argc)
usage();
config_command = (char *) malloc(6 + strlen(argv[i]));
strcpy(config_command, "Read ");
strcat(config_command, argv[i]);
free_config_command = True;
} else if (strncasecmp(argv[i], "-cmd", 4) == 0) {
if (++i >= argc)
usage();
config_command = argv[i];
} else if (strncasecmp(argv[i], "-file", 5) == 0) {
if (++i >= argc)
usage();
output_file = argv[i];
} else if (strncasecmp(argv[i], "-h", 2) == 0) {
usage();
exit(0);
} else if (strncasecmp(argv[i], "-blackout", 9) == 0) {
Blackout = True;
} else if (strncasecmp(argv[i], "-version", 8) == 0) {
fvwm_msg(INFO, "main", "Fvwm95 Version %s compiled on %s at %s\n",
VERSION, __DATE__, __TIME__);
} else {
fvwm_msg(ERR, "main", "Unknown option: `%s'\n", argv[i]);
option_error = TRUE;
}
}
DBUG("main", "Done parsing args");
if (option_error) {
usage();
}
DBUG("main", "Installing signal handlers");
newhandler(SIGINT);
newhandler(SIGHUP);
newhandler(SIGQUIT);
newhandler(SIGTERM);
signal(SIGUSR1, Restart);
signal(SIGPIPE, DeadPipe);
ReapChildren();
if (!(dpy = XOpenDisplay(display_name))) {
fvwm_msg(ERR, "main", "can't open display %s",
XDisplayName(display_name));
exit(1);
}
Scr.screen = DefaultScreen(dpy);
Scr.NumberOfScreens = ScreenCount(dpy);
master_pid = getpid();
if (!single) {
int myscreen = 0;
char *cp;
strcpy(message, XDisplayString(dpy));
XCloseDisplay(dpy);
for (i = 1; i < Scr.NumberOfScreens; i++) {
if (fork() == 0) {
myscreen = i;
break;
}
}
/*
* Truncate the string 'whatever:n.n' to 'whatever:n',
* and then append the screen number.
*/
cp = strchr(message, ':');
if (cp != NULL) {
cp = strchr(cp, '.');
if (cp != NULL)
*cp = '\0'; /* truncate at display part */
}
sprintf(message + strlen(message), ".%d", myscreen);
dpy = XOpenDisplay(message);
Scr.screen = myscreen;
Scr.NumberOfScreens = ScreenCount(dpy);
}
x_fd = XConnectionNumber(dpy);
fd_width = GetFdWidth();
if (fcntl(x_fd, F_SETFD, 1) == -1) {
fvwm_msg(ERR, "main", "close-on-exec failed");
exit(1);
}
/* Add a DISPLAY entry to the environment, in case we were started
* with fvwm -display term:0.0
*/
len = strlen(XDisplayString(dpy));
display_string = safemalloc(len + 10);
sprintf(display_string, "DISPLAY=%s", XDisplayString(dpy));
putenv(display_string);
/* Add a HOSTDISPLAY environment variable, which is the same as
* DISPLAY, unless display = :0.0 or unix:0.0, in which case the full
* host name will be used for ease in networking . */
/* Note: Can't free the rdisplay_string after putenv, because it
* becomes part of the environment! */
if (strncmp(display_string, "DISPLAY=:", 9) == 0) {
char client[MAXHOSTNAME], *rdisplay_string;
mygethostname(client, MAXHOSTNAME);
rdisplay_string = safemalloc(len + 14 + strlen(client));
sprintf(rdisplay_string, "HOSTDISPLAY=%s:%s", client,
&display_string[9]);
putenv(rdisplay_string);
} else if (strncmp(display_string, "DISPLAY=unix:", 13) == 0) {
char client[MAXHOSTNAME], *rdisplay_string;
mygethostname(client, MAXHOSTNAME);
rdisplay_string = safemalloc(len + 14 + strlen(client));
sprintf(rdisplay_string, "HOSTDISPLAY=%s:%s", client,
&display_string[13]);
putenv(rdisplay_string);
} else {
char *rdisplay_string;
rdisplay_string = safemalloc(len + 14);
sprintf(rdisplay_string, "HOSTDISPLAY=%s", XDisplayString(dpy));
putenv(rdisplay_string);
}
Scr.Root = RootWindow(dpy, Scr.screen);
if (Scr.Root == None) {
fvwm_msg(ERR, "main", "Screen %d is not a valid screen",
(char *) Scr.screen);
exit(1);
}
#ifdef SHAPE
ShapesSupported =
XShapeQueryExtension(dpy, &ShapeEventBase, &ShapeErrorBase);
#endif /* SHAPE */
InternUsefulAtoms();
/* Make sure property priority colors is empty */
XChangeProperty(dpy, Scr.Root, _XA_MIT_PRIORITY_COLORS,
XA_CARDINAL, 32, PropModeReplace, NULL, 0);
XSetErrorHandler((XErrorHandler) CatchRedirectError);
XSetIOErrorHandler((XIOErrorHandler) CatchFatal);
XSelectInput(dpy, Scr.Root,
LeaveWindowMask | EnterWindowMask | PropertyChangeMask |
SubstructureRedirectMask | KeyPressMask |
SubstructureNotifyMask |
ButtonPressMask | ButtonReleaseMask);
XSync(dpy, 0);
XSetErrorHandler((XErrorHandler) FvwmErrorHandler);
BlackoutScreen();
CreateCursors();
InitVariables();
InitEventHandlerJumpTable();
initModules();
InitPictureCMap(dpy, Scr.Root); /* for the pixmap cache... */
Scr.gray_bitmap =
XCreateBitmapFromData(dpy, Scr.Root, g_bits, g_width, g_height);
DBUG("main", "Setting up rc file defaults...");
SetRCDefaults();
DBUG("main", "Running config_command...");
ExecuteFunction(config_command, NULL, &Event, C_ROOT, -1);
DBUG("main", "Done running config_command");
/*
CaptureAllWindows();
MakeMenus();
*/
#if 0 /* this seems to cause problems for FvwmCpp/M4 startup actually */
/* if not a direct 'Read', we'll capture all windows here, in case cmd
fails we'll still have defaults */
if (strncasecmp(config_command, "Read", 4) != 0 &&
strncasecmp(config_command, "PipeRead", 8) != 0) {
/* so if cmd (FvwmM4/Cpp most likely) fails, we can still have
borders & stuff... */
StartupStuff();
}
#endif /* 0 */
if (free_config_command) {
free(config_command);
}
if (Scr.d_depth < 2) {
Scr.gray_pixmap =
XCreatePixmapFromBitmapData(dpy, Scr.Root, g_bits, g_width,
g_height, Scr.WinColors.fore,
Scr.WinColors.back, Scr.d_depth);
Scr.light_gray_pixmap =
XCreatePixmapFromBitmapData(dpy, Scr.Root, l_g_bits, l_g_width,
l_g_height, Scr.WinColors.fore,
Scr.WinColors.back, Scr.d_depth);
}
/* create a window which will accept the keyboard focus when no other
windows have it */
attributes.event_mask = KeyPressMask | FocusChangeMask;
attributes.override_redirect = True;
Scr.NoFocusWin = XCreateWindow(dpy, Scr.Root, -10, -10, 10, 10, 0, 0,
InputOnly, CopyFromParent,
CWEventMask | CWOverrideRedirect,
&attributes);
XMapWindow(dpy, Scr.NoFocusWin);
SetMWM_INFO(Scr.NoFocusWin);
XSetInputFocus(dpy, Scr.NoFocusWin, RevertToParent, CurrentTime);
XSync(dpy, 0);
if (debugging)
XSynchronize(dpy, 1);
Scr.SizeStringWidth = XTextWidth(Scr.StdFont.font,
" +8888 x +8888 ", 15);
attributes.border_pixel = Scr.WinColors.fore;
attributes.background_pixel = Scr.WinColors.back;
attributes.bit_gravity = NorthWestGravity;
attributes.save_under = True;
valuemask = (CWBorderPixel | CWBackPixel | CWBitGravity | CWSaveUnder);
/* create the window for coordinates */
Scr.SizeWindow = XCreateWindow(dpy, Scr.Root,
Scr.MyDisplayWidth / 2 -
(Scr.SizeStringWidth +
SIZE_HINDENT * 2) / 2,
Scr.MyDisplayHeight / 2 -
(Scr.StdFont.height +
SIZE_VINDENT * 2) / 2,
(unsigned int) (Scr.SizeStringWidth +
SIZE_HINDENT * 2),
(unsigned int) (Scr.StdFont.height +
SIZE_VINDENT * 2),
(unsigned int) 0, 0,
(unsigned int) CopyFromParent,
(Visual *) CopyFromParent,
valuemask, &attributes);
#ifndef NON_VIRTUAL
initPanFrames();
#endif
XGrabServer(dpy);
#ifndef NON_VIRTUAL
checkPanFrames();
#endif
XUngrabServer(dpy);
UnBlackoutScreen();
DBUG("main", "Entering HandleEvents loop...");
HandleEvents();
DBUG("main", "Back from HandleEvents loop? Exiting...");
return 0;
}
void I_InitGraphics(void)
{
SDL_Event dummy;
byte *doompal;
char *env;
// Pass through the XSCREENSAVER_WINDOW environment variable to
// SDL_WINDOWID, to embed the SDL window into the Xscreensaver
// window.
env = getenv("XSCREENSAVER_WINDOW");
if (env != NULL)
{
char winenv[30];
int winid;
sscanf(env, "0x%x", &winid);
M_snprintf(winenv, sizeof(winenv), "SDL_WINDOWID=%i", winid);
putenv(winenv);
}
SetSDLVideoDriver();
SetWindowPositionVars();
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
I_Error("Failed to initialize video: %s", SDL_GetError());
}
// Set up title and icon. Windows cares about the ordering; this
// has to be done before the call to SDL_SetVideoMode.
I_InitWindowTitle();
I_InitWindowIcon();
// Warning to OS X users... though they might never see it :(
#ifdef __MACOSX__
if (fullscreen)
{
printf("Some old versions of OS X might crash in fullscreen mode.\n"
"If this happens to you, switch back to windowed mode.\n");
}
#endif
//
// Enter into graphics mode.
//
// When in screensaver mode, run full screen and auto detect
// screen dimensions (don't change video mode)
//
if (screensaver_mode)
{
SetVideoMode(NULL, 0, 0);
}
else
{
int w, h;
if (autoadjust_video_settings)
{
I_AutoAdjustSettings();
}
w = screen_width;
h = screen_height;
screen_mode = I_FindScreenMode(w, h);
if (screen_mode == NULL)
{
I_Error("I_InitGraphics: Unable to find a screen mode small "
"enough for %ix%i", w, h);
}
if (w != screen_mode->width || h != screen_mode->height)
{
printf("I_InitGraphics: %s (%ix%i within %ix%i)\n",
WindowBoxType(screen_mode, w, h),
screen_mode->width, screen_mode->height, w, h);
}
SetVideoMode(screen_mode, w, h);
}
// Start with a clear black screen
// (screen will be flipped after we set the palette)
SDL_FillRect(screenbuffer, NULL, 0);
// Set the palette
doompal = W_CacheLumpName(DEH_String("PLAYPAL"), PU_CACHE);
I_SetPalette(doompal);
SDL_SetColors(screenbuffer, palette, 0, 256);
CreateCursors();
UpdateFocus();
UpdateGrab();
// On some systems, it takes a second or so for the screen to settle
// after changing modes. We include the option to add a delay when
// setting the screen mode, so that the game doesn't start immediately
// with the player unable to see anything.
if (fullscreen && !screensaver_mode)
{
SDL_Delay(startup_delay);
}
// Check if we have a native surface we can use
// If we have to lock the screen, draw to a buffer and copy
// Likewise if the screen pitch is not the same as the width
// If we have to multiply, drawing is done to a separate 320x200 buf
native_surface = screen == screenbuffer
&& !SDL_MUSTLOCK(screen)
&& screen_mode == &mode_scale_1x
&& screen->pitch == SCREENWIDTH
&& aspect_ratio_correct;
// If not, allocate a buffer and copy from that buffer to the
// screen when we do an update
if (native_surface)
{
I_VideoBuffer = (unsigned char *) screen->pixels;
I_VideoBuffer += (screen->h - SCREENHEIGHT) / 2;
}
else
{
I_VideoBuffer = (unsigned char *) Z_Malloc (SCREENWIDTH * SCREENHEIGHT,
PU_STATIC, NULL);
}
V_RestoreBuffer();
// Clear the screen to black.
memset(I_VideoBuffer, 0, SCREENWIDTH * SCREENHEIGHT);
// We need SDL to give us translated versions of keys as well
SDL_EnableUNICODE(1);
// Repeat key presses - this is what Vanilla Doom does
// Not sure about repeat rate - probably dependent on which DOS
// driver is used. This is good enough though.
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
// clear out any events waiting at the start and center the mouse
while (SDL_PollEvent(&dummy));
initialized = true;
// Call I_ShutdownGraphics on quit
I_AtExit(I_ShutdownGraphics, true);
}
void I_InitGraphics(void)
{
SDL_Event dummy;
byte *doompal;
int flags = 0;
char *env;
// Pass through the XSCREENSAVER_WINDOW environment variable to
// SDL_WINDOWID, to embed the SDL window into the Xscreensaver
// window.
env = getenv("XSCREENSAVER_WINDOW");
if (env != NULL)
{
char winenv[30];
int winid;
sscanf(env, "0x%x", &winid);
sprintf(winenv, "SDL_WINDOWID=%i", winid);
putenv(winenv);
}
SetSDLVideoDriver();
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
I_Error("Failed to initialize video: %s", SDL_GetError());
}
// Check for command-line video-related parameters.
CheckCommandLine();
doompal = W_CacheLumpName (DEH_String("PLAYPAL"),PU_CACHE);
if (screensaver_mode)
{
windowwidth = 0;
windowheight = 0;
}
else
{
if (autoadjust_video_settings)
{
I_AutoAdjustSettings();
}
windowwidth = screen_width;
windowheight = screen_height;
screen_mode = I_FindScreenMode(windowwidth, windowheight);
if (screen_mode == NULL)
{
I_Error("I_InitGraphics: Unable to find a screen mode small "
"enough for %ix%i", windowwidth, windowheight);
}
if (windowwidth != screen_mode->width
|| windowheight != screen_mode->height)
{
printf("I_InitGraphics: %s (%ix%i within %ix%i)\n",
WindowBoxType(screen_mode, windowwidth, windowheight),
screen_mode->width, screen_mode->height,
windowwidth, windowheight);
}
// Generate lookup tables before setting the video mode.
if (screen_mode->InitMode != NULL)
{
screen_mode->InitMode(doompal);
}
}
// Set up title and icon. Windows cares about the ordering; this
// has to be done before the call to SDL_SetVideoMode.
I_SetWindowCaption();
#if !SDL_VERSION_ATLEAST(1, 3, 0)
I_SetWindowIcon();
#endif
// Set the video mode.
flags |= SDL_SWSURFACE | SDL_HWPALETTE | SDL_DOUBLEBUF;
if (fullscreen)
{
flags |= SDL_FULLSCREEN;
}
screen = SDL_SetVideoMode(windowwidth, windowheight, 8, flags);
if (screen == NULL)
{
I_Error("Error setting video mode: %s\n", SDL_GetError());
}
// Start with a clear black screen
// (screen will be flipped after we set the palette)
if (SDL_LockSurface(screen) >= 0)
{
byte *screenpixels;
int y;
screenpixels = (byte *) screen->pixels;
for (y=0; y<screen->h; ++y)
memset(screenpixels + screen->pitch * y, 0, screen->w);
SDL_UnlockSurface(screen);
}
// Set the palette
I_SetPalette(doompal);
SDL_SetColors(screen, palette, 0, 256);
CreateCursors();
UpdateFocus();
UpdateGrab();
// In screensaver mode, now find a screen_mode to use.
if (screensaver_mode)
{
screen_mode = I_FindScreenMode(screen->w, screen->h);
if (screen_mode == NULL)
{
I_Error("I_InitGraphics: Unable to find a screen mode small "
"enough for %ix%i", screen->w, screen->h);
}
// Generate lookup tables before setting the video mode.
if (screen_mode->InitMode != NULL)
{
screen_mode->InitMode(doompal);
}
}
// On some systems, it takes a second or so for the screen to settle
// after changing modes. We include the option to add a delay when
// setting the screen mode, so that the game doesn't start immediately
// with the player unable to see anything.
if (fullscreen && !screensaver_mode)
{
SDL_Delay(startup_delay);
}
// Check if we have a native surface we can use
// If we have to lock the screen, draw to a buffer and copy
// Likewise if the screen pitch is not the same as the width
// If we have to multiply, drawing is done to a separate 320x200 buf
native_surface = !SDL_MUSTLOCK(screen)
&& screen_mode == &mode_scale_1x
&& screen->pitch == SCREENWIDTH
&& aspect_ratio_correct;
// If not, allocate a buffer and copy from that buffer to the
// screen when we do an update
if (native_surface)
{
screens[0] = (unsigned char *) screen->pixels;
screens[0] += (screen->h - SCREENHEIGHT) / 2;
}
else
{
screens[0] = (unsigned char *) Z_Malloc (SCREENWIDTH * SCREENHEIGHT,
PU_STATIC, NULL);
}
// "Loading from disk" icon
LoadDiskImage();
// Clear the screen to black.
memset(screens[0], 0, SCREENWIDTH * SCREENHEIGHT);
// We need SDL to give us translated versions of keys as well
SDL_EnableUNICODE(1);
// Repeat key presses - this is what Vanilla Doom does
// Not sure about repeat rate - probably dependent on which DOS
// driver is used. This is good enough though.
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
// clear out any events waiting at the start and center the mouse
while (SDL_PollEvent(&dummy));
if (usemouse && !nomouse && (fullscreen || grabmouse))
{
CenterMouse();
}
initialized = true;
}
