mirror of
https://github.com/ZDoom/raze-gles.git
synced 2024-11-18 10:11:50 +00:00
ee5dd2cf32
As inauguration, move G_AddGroup, G_AddPath and struct strllist there. The header is located in build/include, because in the future, code that resides closer to (but is not strictly part of) the engine might need to be factored into here. The source file, however, is in the source/ directory. git-svn-id: https://svn.eduke32.com/eduke32@2542 1a8010ca-5511-0410-912e-c29ae57300e0
13124 lines
398 KiB
C
13124 lines
398 KiB
C
//-------------------------------------------------------------------------
|
|
/*
|
|
Copyright (C) 2010 EDuke32 developers and contributors
|
|
|
|
This file is part of EDuke32.
|
|
|
|
EDuke32 is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License version 2
|
|
as published by the Free Software Foundation.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
//-------------------------------------------------------------------------
|
|
|
|
#include "compat.h"
|
|
#include "build.h"
|
|
#include "editor.h"
|
|
#include "pragmas.h"
|
|
#include "baselayer.h"
|
|
#include "osd.h"
|
|
#include "cache1d.h"
|
|
|
|
#include "osdfuncs.h"
|
|
#include "names.h"
|
|
|
|
#include "common.h"
|
|
#include "mapster32.h"
|
|
#include "keys.h"
|
|
|
|
#include "keyboard.h"
|
|
#include "scriptfile.h"
|
|
#include "crc32.h"
|
|
|
|
#include "sounds_mapster32.h"
|
|
#include "fx_man.h"
|
|
|
|
#include "macros.h"
|
|
#include "quicklz.h"
|
|
|
|
#include "m32script.h"
|
|
#include "m32def.h"
|
|
|
|
#include "rev.h"
|
|
|
|
#ifdef _WIN32
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <windows.h>
|
|
#include <shellapi.h>
|
|
#endif
|
|
|
|
#include <signal.h>
|
|
|
|
static int32_t floor_over_floor;
|
|
static int32_t g_fillCurSector = 0;
|
|
|
|
static char g_modDir[BMAX_PATH];
|
|
char defsfilename[BMAX_PATH] = "duke3d.def";
|
|
static char levelname[BMAX_PATH];
|
|
|
|
// static char *startwin_labeltext = "Starting Mapster32...";
|
|
static char *setupfilename = "mapster32.cfg";
|
|
static char defaultduke3dgrp[BMAX_PATH] = "duke3d.grp";
|
|
static char *g_grpNamePtr = defaultduke3dgrp;
|
|
char *g_defNamePtr = defsfilename;
|
|
int32_t fixmaponsave_sprites = 1;
|
|
static int32_t fixmaponsave_walls = 0;
|
|
static int32_t lastsave = -180*60;
|
|
static int32_t NoAutoLoad = 0;
|
|
static int32_t spnoclip=1;
|
|
|
|
static char *default_tiles_cfg = "tiles.cfg";
|
|
static int32_t pathsearchmode_oninit;
|
|
|
|
// Sound in Mapster32
|
|
static char defaultgamecon[2][BMAX_PATH] = { "eduke.con", "game.con" };
|
|
|
|
char * defaultgameconfile(void)
|
|
{
|
|
int32_t script; // scriptfile *script;
|
|
|
|
script = kopen4load(defaultgamecon[0],0); // script = scriptfile_fromfile(defaultgamecon[0]);
|
|
|
|
if (script >= 0)
|
|
return defaultgamecon[0];
|
|
|
|
return defaultgamecon[1];
|
|
}
|
|
|
|
static char *gamecon = "\0";
|
|
static int32_t g_skipDefaultCons = 0;
|
|
static int32_t g_skipDefaultDefs = 0; // primarily for NAM/WWII GI appeasement
|
|
|
|
char **g_scriptModules = NULL;
|
|
int32_t g_scriptModulesNum = 0;
|
|
char **g_defModules = NULL;
|
|
int32_t g_defModulesNum = 0;
|
|
|
|
#ifdef HAVE_CLIPSHAPE_FEATURE
|
|
char **g_clipMapFiles = NULL;
|
|
int32_t g_clipMapFilesNum = 0;
|
|
#endif
|
|
|
|
#pragma pack(push,1)
|
|
sound_t g_sounds[MAXSOUNDS];
|
|
#pragma pack(pop)
|
|
|
|
static int16_t g_definedsndnum[MAXSOUNDS]; // maps parse order index to g_sounds index
|
|
static int16_t g_sndnum[MAXSOUNDS]; // maps current order index to g_sounds index
|
|
int32_t g_numsounds = 0;
|
|
static int32_t lastupdate, mousecol, mouseadd = 1, bstatus;
|
|
|
|
#if !defined(_WIN32)
|
|
static int32_t usecwd = 0;
|
|
#endif
|
|
|
|
const char *scripthist[SCRIPTHISTSIZ];
|
|
int32_t scripthistend = 0;
|
|
|
|
int32_t g_lazy_tileselector = 0;
|
|
int32_t showambiencesounds=2;
|
|
|
|
int32_t autocorruptcheck = 0;
|
|
static int32_t corruptchecktimer;
|
|
static int32_t curcorruptthing=-1, corrupt_tryfix_alt=0;
|
|
int32_t corruptcheck_noalreadyrefd=0;
|
|
|
|
int32_t corruptlevel=0, numcorruptthings=0, corruptthings[MAXCORRUPTTHINGS];
|
|
|
|
static uint32_t templenrepquot=1;
|
|
|
|
//////////////////// Key stuff ////////////////////
|
|
|
|
#define eitherALT (keystatus[KEYSC_LALT] || keystatus[KEYSC_RALT])
|
|
#define eitherCTRL (keystatus[KEYSC_LCTRL] || keystatus[KEYSC_RCTRL])
|
|
#define eitherSHIFT (keystatus[KEYSC_LSHIFT] || keystatus[KEYSC_RSHIFT])
|
|
|
|
#define PRESSED_KEYSC(Key) (keystatus[KEYSC_##Key] && !(keystatus[KEYSC_##Key]=0))
|
|
|
|
|
|
//////////////////// Aiming ////////////////////
|
|
static const char *Typestr[] = { "Wall", "Ceiling", "Floor", "Sprite", "Wall" };
|
|
static const char *typestr[] = { "wall", "ceiling", "floor", "sprite", "wall" };
|
|
static const char *Typestr_wss[] = { "Wall", "Sector", "Sector", "Sprite", "Wall" };
|
|
/*static const char *typestr_wss[] = { "wall", "sector", "sector", "sprite", "wall" };*/
|
|
|
|
/** The following macros multiplex between identically named fields of sector/wall/sprite,
|
|
* based on a macro parameter or the currently aimed at object (AIMED_ versions).
|
|
* They can be used on either side of an assignment. */
|
|
|
|
// select wall, only makes a difference with walls that have 'swap bottom of walls' bit set
|
|
#define SELECT_WALL() (AIMING_AT_WALL ? searchbottomwall : searchwall)
|
|
|
|
#define SECFLD(i, Field) (sector[i].Field)
|
|
#define WALFLD(i, Field) (wall[i].Field)
|
|
#define SPRFLD(i, Field) (sprite[i].Field)
|
|
|
|
// valid fields: z, stat, picnum, heinum, shade, pal, xpanning, ypanning
|
|
#define CEILINGFLOOR(iSec, Field) (*(AIMING_AT_CEILING ? &(sector[iSec].ceiling##Field) : &(sector[iSec].floor##Field)))
|
|
#define AIMED_CEILINGFLOOR(Field) CEILINGFLOOR(searchsector, Field)
|
|
|
|
#define AIMED_SEL_WALL(Field) WALFLD(SELECT_WALL(), Field)
|
|
|
|
// selects from wall proper or its mask
|
|
#define OVR_WALL(iWal, Field) (*(AIMING_AT_WALL ? &WALFLD(iWal, Field) : &(wall[iWal].over##Field)))
|
|
#define AIMED_SELOVR_WALL(Field) OVR_WALL(SELECT_WALL(), Field)
|
|
|
|
// the base macro to construct field multiplexing macros: wall and sector cases undetermined
|
|
#define MUXBASE(Field, SectorCase, WallCase) (*(AIMING_AT_CEILING_OR_FLOOR ? (SectorCase) : \
|
|
(AIMING_AT_WALL_OR_MASK ? (WallCase) : \
|
|
&SPRFLD(searchwall, Field))))
|
|
|
|
#define SFBASE_CF(Field, WallCase) MUXBASE(Field, &AIMED_CEILINGFLOOR(Field), WallCase)
|
|
|
|
#define SFBASE_(Field, WallCase) MUXBASE(Field, &SECFLD(searchsector,Field), WallCase)
|
|
|
|
#define AIMED(Field) SFBASE_(Field, &WALFLD(searchwall, Field))
|
|
#define AIMED_SEL(Field) SFBASE_(Field, &AIMED_SEL_WALL(Field))
|
|
//#define AIMED_CF(Field) SFBASE_CF(Field, &WALFLD(searchwall,Field))
|
|
#define AIMED_CF_SEL(Field) SFBASE_CF(Field, &AIMED_SEL_WALL(Field))
|
|
|
|
// OVR makes sense only with picnum
|
|
//#define AIMED_OVR_PICNUM SFBASE_CF(picnum, &OVR_WALL(searchwall, picnum))
|
|
#define AIMED_SELOVR_PICNUM SFBASE_CF(picnum, &AIMED_SELOVR_WALL(picnum))
|
|
|
|
|
|
static const char *ONOFF_[] = {"OFF","ON"};
|
|
#define ONOFF(b) (ONOFF_[!!(b)])
|
|
|
|
// always CRLF for us
|
|
#ifdef _WIN32
|
|
# define OURNEWL "\n"
|
|
#else
|
|
# define OURNEWL "\r\n"
|
|
#endif
|
|
|
|
static CACHE1D_FIND_REC *finddirs=NULL, *findfiles=NULL, *finddirshigh=NULL, *findfileshigh=NULL;
|
|
static int32_t numdirs=0, numfiles=0;
|
|
static int32_t currentlist=0;
|
|
static int32_t tsign, mouseaction=0, mouseax=0, mouseay=0;
|
|
static int32_t repeatcountx, repeatcounty;
|
|
static int32_t infobox=3; // bit0: current window, bit1: mouse pointer, the variable should be renamed
|
|
|
|
static char wallshades[MAXWALLS];
|
|
static char sectorshades[MAXSECTORS][2];
|
|
static char spriteshades[MAXSPRITES];
|
|
static char wallpals[MAXWALLS];
|
|
static char sectorpals[MAXSECTORS][2];
|
|
static char spritepals[MAXSPRITES];
|
|
static uint8_t wallflag[MAXWALLS>>3];
|
|
|
|
#ifdef YAX_ENABLE
|
|
static char *yupdownwall[2] = {"upwall","downwall"};
|
|
static char *YUPDOWNWALL[2] = {"UPWALL","DOWNWALL"};
|
|
|
|
static uint8_t havebunch[YAX_MAXBUNCHES];
|
|
static int32_t *tempzar[YAX_MAXBUNCHES];
|
|
|
|
static void silentmessage(const char *fmt, ...);
|
|
static int32_t yax_invalidop()
|
|
{
|
|
silentmessage("Operation forbidden on extended sector.");
|
|
return 0;
|
|
}
|
|
|
|
static int32_t yax_invalidslope()
|
|
{
|
|
silentmessage("Firstwalls must coincide for changing slope.");
|
|
return 0;
|
|
}
|
|
|
|
// 1: ok
|
|
static int32_t yax_checkslope(int16_t sectnum, int32_t othersectnum)
|
|
{
|
|
int16_t w1 = sector[sectnum].wallptr, w2 = wall[w1].point2;
|
|
int16_t nw1 = sector[othersectnum].wallptr, nw2 = wall[nw1].point2;
|
|
|
|
if (nw1 < 0)
|
|
return 0; // error
|
|
|
|
nw2 = wall[nw1].point2;
|
|
if (wall[w1].x != wall[nw1].x || wall[w1].y != wall[nw1].y ||
|
|
wall[w2].x != wall[nw2].x || wall[w2].y != wall[nw2].y)
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
# define YAXSLOPECHK(s,os) (yax_checkslope(s,os) || yax_invalidslope())
|
|
# define YAXCHK(p) ((p) || yax_invalidop())
|
|
#endif
|
|
|
|
// tile marking in tile selector for custom creation of tile groups
|
|
static uint8_t tilemarked[(MAXTILES+7)>>3];
|
|
|
|
#ifdef POLYMER
|
|
static int16_t spritelightid[MAXSPRITES];
|
|
_prlight *spritelightptr[MAXSPRITES];
|
|
|
|
static int32_t check_prlight_colors(int32_t i)
|
|
{
|
|
return (sprite[i].xvel != spritelightptr[i]->color[0]) ||
|
|
(sprite[i].yvel != spritelightptr[i]->color[1]) ||
|
|
(sprite[i].zvel != spritelightptr[i]->color[2]);
|
|
}
|
|
|
|
static void copy_prlight_colors(_prlight *mylightptr, int32_t i)
|
|
{
|
|
mylightptr->color[0] = sprite[i].xvel;
|
|
mylightptr->color[1] = sprite[i].yvel;
|
|
mylightptr->color[2] = sprite[i].zvel;
|
|
}
|
|
|
|
static void addprlight_common1(_prlight *mylightptr, int32_t i)
|
|
{
|
|
mylightptr->sector = SECT;
|
|
Bmemcpy(mylightptr, &sprite[i], sizeof(vec3_t));
|
|
mylightptr->range = SHT;
|
|
copy_prlight_colors(mylightptr, i);
|
|
mylightptr->angle = SA;
|
|
mylightptr->horiz = SH;
|
|
mylightptr->minshade = sprite[i].xoffset;
|
|
mylightptr->maxshade = sprite[i].yoffset;
|
|
|
|
// overridden for spot lights
|
|
mylightptr->radius = mylightptr->faderadius = mylightptr->tilenum = 0;
|
|
|
|
if (CS & 2)
|
|
{
|
|
if (CS & 512)
|
|
mylightptr->priority = PR_LIGHT_PRIO_LOW;
|
|
else
|
|
mylightptr->priority = PR_LIGHT_PRIO_HIGH;
|
|
}
|
|
else
|
|
mylightptr->priority = PR_LIGHT_PRIO_MAX;
|
|
|
|
spritelightid[i] = polymer_addlight(mylightptr);
|
|
if (spritelightid[i] >= 0)
|
|
spritelightptr[i] = &prlights[spritelightid[i]];
|
|
}
|
|
|
|
static void DeletePolymerLights(void)
|
|
{
|
|
int32_t i;
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
if (spritelightptr[i] != NULL)
|
|
{
|
|
polymer_deletelight(spritelightid[i]);
|
|
spritelightid[i] = -1;
|
|
spritelightptr[i] = NULL;
|
|
}
|
|
}
|
|
|
|
void G_Polymer_UnInit(void)
|
|
{
|
|
DeletePolymerLights();
|
|
}
|
|
#endif
|
|
|
|
extern int32_t mskip;
|
|
|
|
//extern int32_t fillsector(int16_t sectnum, char fillcolor);
|
|
|
|
static void drawgradient(void)
|
|
{
|
|
int32_t i, col = whitecol-21;
|
|
begindrawing();
|
|
for (i=ydim-STATUS2DSIZ+16; i<ydim && col>0; i++,col--)
|
|
CLEARLINES2D(i, 1, (col<<24)|(col<<16)|(col<<8)|col);
|
|
CLEARLINES2D(i, ydim-i, 0);
|
|
enddrawing();
|
|
}
|
|
|
|
static void message_common1(const char *tmpstr)
|
|
{
|
|
Bstrncpy(getmessage,tmpstr,sizeof(getmessage));
|
|
getmessage[sizeof(getmessage)-1] = 0;
|
|
|
|
getmessageleng = Bstrlen(getmessage);
|
|
getmessagetimeoff = totalclock + 120*2 + getmessageleng*(120/30);
|
|
// lastmessagetime = totalclock;
|
|
}
|
|
|
|
void message(const char *fmt, ...)
|
|
{
|
|
char tmpstr[256];
|
|
va_list va;
|
|
|
|
va_start(va, fmt);
|
|
Bvsnprintf(tmpstr, 256, fmt, va);
|
|
va_end(va);
|
|
|
|
message_common1(tmpstr);
|
|
|
|
if (!mouseaction)
|
|
OSD_Printf("%s\n", tmpstr);
|
|
}
|
|
|
|
static void silentmessage(const char *fmt, ...)
|
|
{
|
|
char tmpstr[256];
|
|
va_list va;
|
|
|
|
va_start(va, fmt);
|
|
Bvsnprintf(tmpstr, 256, fmt, va);
|
|
va_end(va);
|
|
|
|
message_common1(tmpstr);
|
|
}
|
|
|
|
|
|
static int32_t osdcmd_quit(const osdfuncparm_t *parm);
|
|
|
|
////////// UNDO/REDO SYSTEM //////////
|
|
#if M32_UNDO
|
|
typedef struct mapundo_
|
|
{
|
|
int32_t revision;
|
|
int32_t num[3]; // numsectors, numwalls, numsprites
|
|
|
|
// These exist temporarily as sector/wall/sprite data, but are compressed
|
|
// most of the time. +4 bytes refcount at the beginning.
|
|
char *sws[3]; // sector, wall, sprite
|
|
|
|
uint32_t crc[3];
|
|
|
|
struct mapundo_ *next; // 'redo' loads this
|
|
struct mapundo_ *prev; // 'undo' loads this
|
|
} mapundo_t;
|
|
|
|
mapundo_t *mapstate = NULL;
|
|
|
|
int32_t map_revision = 1;
|
|
|
|
#define QADDNSZ 400
|
|
|
|
|
|
static int32_t try_match_with_prev(int32_t idx, int32_t numsthgs, uint32_t crc)
|
|
{
|
|
if (mapstate->prev && mapstate->prev->num[idx]==numsthgs && mapstate->prev->crc[idx]==crc)
|
|
{
|
|
// found match!
|
|
mapstate->sws[idx] = mapstate->prev->sws[idx];
|
|
(*(int32_t *)mapstate->sws[idx])++; // increase refcount!
|
|
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void create_compressed_block(int32_t idx, const void *srcdata, uint32_t size, uint32_t crc)
|
|
{
|
|
uint32_t j;
|
|
|
|
// allocate
|
|
mapstate->sws[idx] = Bmalloc(4 + size + QADDNSZ);
|
|
if (!mapstate->sws[idx]) { initprintf("OUT OF MEM in undo/redo\n"); osdcmd_quit(NULL); }
|
|
|
|
// compress & realloc
|
|
j = qlz_compress(srcdata, mapstate->sws[idx]+4, size, state_compress);
|
|
mapstate->sws[idx] = Brealloc(mapstate->sws[idx], 4 + j);
|
|
if (!mapstate->sws[idx]) { initprintf("COULD not realloc in undo/redo\n"); osdcmd_quit(NULL); }
|
|
|
|
// write refcount
|
|
*(int32_t *)mapstate->sws[idx] = 1;
|
|
|
|
mapstate->crc[idx] = crc;
|
|
}
|
|
|
|
static void free_self_and_successors(mapundo_t *mapst)
|
|
{
|
|
mapundo_t *cur = mapst;
|
|
|
|
mapst->prev = NULL; // break the back link
|
|
|
|
while (cur->next)
|
|
cur = cur->next;
|
|
|
|
while (1)
|
|
{
|
|
int32_t i;
|
|
mapundo_t *const prev = cur->prev;
|
|
|
|
for (i=0; i<3; i++)
|
|
{
|
|
int32_t *const refcnt = (int32_t *)cur->sws[i];
|
|
|
|
if (refcnt)
|
|
{
|
|
(*refcnt)--;
|
|
if (*refcnt == 0)
|
|
Bfree(refcnt); // free the block!
|
|
}
|
|
}
|
|
|
|
Bfree(cur);
|
|
|
|
if (!prev)
|
|
break;
|
|
|
|
cur = prev;
|
|
}
|
|
}
|
|
|
|
// NOTE: only _consecutive_ matching (size+crc) sector/wall/sprite blocks are
|
|
// shared!
|
|
void create_map_snapshot(void)
|
|
{
|
|
if (mapstate == NULL)
|
|
{
|
|
// create initial mapstate
|
|
|
|
map_revision = 1;
|
|
|
|
mapstate = Bcalloc(1, sizeof(mapundo_t));
|
|
mapstate->revision = map_revision;
|
|
mapstate->prev = mapstate->next = NULL;
|
|
}
|
|
else
|
|
{
|
|
if (mapstate->next)
|
|
free_self_and_successors(mapstate->next);
|
|
// now, have no successors
|
|
|
|
// calloc because not everything may be set in the following:
|
|
mapstate->next = Bcalloc(1, sizeof(mapundo_t));
|
|
mapstate->next->prev = mapstate;
|
|
|
|
mapstate = mapstate->next;
|
|
|
|
mapstate->revision = ++map_revision;
|
|
}
|
|
|
|
|
|
fixspritesectors();
|
|
|
|
mapstate->num[0] = numsectors;
|
|
mapstate->num[1] = numwalls;
|
|
mapstate->num[2] = Numsprites;
|
|
|
|
|
|
if (numsectors)
|
|
{
|
|
int32_t j;
|
|
uint32_t tempcrc = crc32once((uint8_t *)sector, numsectors*sizeof(sectortype));
|
|
|
|
if (!try_match_with_prev(0, numsectors, tempcrc))
|
|
create_compressed_block(0, sector, numsectors*sizeof(sectortype), tempcrc);
|
|
|
|
if (numwalls)
|
|
{
|
|
tempcrc = crc32once((uint8_t *)wall, numwalls*sizeof(walltype));
|
|
|
|
if (!try_match_with_prev(1, numwalls, tempcrc))
|
|
create_compressed_block(1, wall, numwalls*sizeof(walltype), tempcrc);
|
|
}
|
|
|
|
if (Numsprites)
|
|
{
|
|
tempcrc = crc32once((uint8_t *)sprite, MAXSPRITES*sizeof(spritetype));
|
|
|
|
if (!try_match_with_prev(2, Numsprites, tempcrc))
|
|
{
|
|
int32_t i = 0;
|
|
spritetype *const tspri = Bmalloc(Numsprites*sizeof(spritetype) + 4);
|
|
spritetype *spri = tspri;
|
|
|
|
if (!tspri) { initprintf("OUT OF MEM in undo/redo (2)\n"); osdcmd_quit(NULL); }
|
|
|
|
for (j=0; j<MAXSPRITES && i < Numsprites; j++)
|
|
if (sprite[j].statnum != MAXSTATUS)
|
|
{
|
|
Bmemcpy(spri++, &sprite[j], sizeof(spritetype));
|
|
i++;
|
|
}
|
|
|
|
create_compressed_block(2, tspri, Numsprites*sizeof(spritetype), tempcrc);
|
|
Bfree(tspri);
|
|
}
|
|
}
|
|
}
|
|
|
|
CheckMapCorruption(5, 0);
|
|
}
|
|
|
|
void map_undoredo_free(void)
|
|
{
|
|
if (mapstate)
|
|
{
|
|
free_self_and_successors(mapstate);
|
|
mapstate = NULL;
|
|
}
|
|
|
|
map_revision = 1;
|
|
}
|
|
|
|
int32_t map_undoredo(int32_t dir)
|
|
{
|
|
int32_t i;
|
|
|
|
if (mapstate == NULL) return 1;
|
|
|
|
if (dir)
|
|
{
|
|
if (mapstate->next == NULL || !mapstate->next->num[0]) return 1;
|
|
|
|
// while (map_revision+1 != mapstate->revision && mapstate->next)
|
|
mapstate = mapstate->next;
|
|
}
|
|
else
|
|
{
|
|
if (mapstate->prev == NULL || !mapstate->prev->num[0]) return 1;
|
|
|
|
// while (map_revision-1 != mapstate->revision && mapstate->prev)
|
|
mapstate = mapstate->prev;
|
|
}
|
|
|
|
numsectors = mapstate->num[0];
|
|
numwalls = mapstate->num[1];
|
|
map_revision = mapstate->revision;
|
|
|
|
Bmemset(show2dsector, 0, sizeof(show2dsector));
|
|
Bmemset(show2dsprite, 0, sizeof(show2dsprite));
|
|
Bmemset(show2dwall, 0, sizeof(show2dwall));
|
|
Bmemset(hlsectorbitmap, 0, sizeof(hlsectorbitmap));
|
|
|
|
initspritelists();
|
|
|
|
if (mapstate->num[0])
|
|
{
|
|
// restore sector[]
|
|
qlz_decompress(mapstate->sws[0]+4, sector, state_decompress);
|
|
|
|
if (mapstate->num[1]) // restore wall[]
|
|
qlz_decompress(mapstate->sws[1]+4, wall, state_decompress);
|
|
|
|
if (mapstate->num[2]) // restore sprite[]
|
|
qlz_decompress(mapstate->sws[2]+4, sprite, state_decompress);
|
|
}
|
|
|
|
// insert sprites
|
|
for (i=0; i<mapstate->num[2]; i++)
|
|
{
|
|
if ((sprite[i].cstat & 48) == 48) sprite[i].cstat &= ~48;
|
|
assert((unsigned)sprite[i].sectnum < (unsigned)numsectors
|
|
&& (unsigned)sprite[i].statnum < MAXSTATUS);
|
|
insertsprite(sprite[i].sectnum, sprite[i].statnum);
|
|
}
|
|
|
|
assert(Numsprites == mapstate->num[2]);
|
|
|
|
#ifdef POLYMER
|
|
if (qsetmode == 200 && rendmode == 4)
|
|
polymer_loadboard();
|
|
#endif
|
|
#ifdef YAX_ENABLE
|
|
yax_update(0);
|
|
yax_updategrays(pos.z);
|
|
#endif
|
|
CheckMapCorruption(4, 0);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
|
|
#define M32_NUM_SPRITE_MODES ((signed)(sizeof(SpriteMode)/sizeof(SpriteMode[0])))
|
|
static const char *SpriteMode[]=
|
|
{
|
|
"NONE",
|
|
"SECTORS",
|
|
"WALLS",
|
|
"SPRITES",
|
|
"ALL",
|
|
"ITEMS ONLY",
|
|
"CURRENT SPRITE ONLY",
|
|
"ONLY SECTOREFFECTORS AND SECTORS",
|
|
"NO SECTOREFFECTORS OR SECTORS"
|
|
};
|
|
|
|
#define MAXSKILL 5
|
|
static const char *SKILLMODE[MAXSKILL]=
|
|
{
|
|
"Actor skill display: PIECE OF CAKE",
|
|
"Actor skill display: LET'S ROCK",
|
|
"Actor skill display: COME GET SOME",
|
|
"Actor skill display: DAMN I'M GOOD",
|
|
"Actor skill display: ALL SKILL LEVELS"
|
|
};
|
|
|
|
#define MAXNOSPRITES 4
|
|
static const char *SPRDSPMODE[MAXNOSPRITES]=
|
|
{
|
|
"Sprite display: DISPLAY ALL SPRITES",
|
|
"Sprite display: NO EFFECTORS",
|
|
"Sprite display: NO ACTORS",
|
|
"Sprite display: NO EFFECTORS OR ACTORS"
|
|
};
|
|
|
|
#define MAXHELP3D ((signed)(sizeof(Help3d)/sizeof(Help3d[0])))
|
|
static const char *Help3d[]=
|
|
{
|
|
"Mapster32 3D mode help",
|
|
" ",
|
|
" F2 = TOGGLE CLIPBOARD",
|
|
" F3 = TOGGLE MOUSELOOK",
|
|
" F4 = TOGGLE AMBIENT SOUNDS",
|
|
" F6 = AUTOMATIC SECTOREFFECTOR HELP",
|
|
" F7 = AUTOMATIC SECTOR TAG HELP",
|
|
"",
|
|
" ' A = TOGGLE AUTOSAVE",
|
|
" ' D = CYCLE SPRITE SKILL DISPLAY",
|
|
" ' R = TOGGLE FRAMERATE DISPLAY",
|
|
" ' W = TOGGLE SPRITE DISPLAY",
|
|
" ' X = MAP SHADE PREVIEW",
|
|
" ' I = TOGGLE INVISIBLE SPRITES",
|
|
"",
|
|
" ' T = CHANGE LOTAG",
|
|
" ' H = CHANGE HITAG",
|
|
" ' S = CHANGE SHADE",
|
|
" ' M = CHANGE EXTRA",
|
|
" ' V = CHANGE VISIBILITY",
|
|
" ' L = CHANGE OBJECT COORDINATES",
|
|
" ' C = CHANGE GLOBAL SHADE",
|
|
"",
|
|
" ' ENTER = PASTE GRAPHIC ONLY",
|
|
" ' P & ; P = PASTE PALETTE TO ALL SELECTED SECTORS",
|
|
" ; V = SET VISIBILITY ON ALL SELECTED SECTORS",
|
|
" ' DEL = CSTAT=0",
|
|
" CTRL-S = SAVE BOARD",
|
|
" HOME = PGUP/PGDN MODIFIER (256 UNITS)",
|
|
" END = PGUP/PGDN MODIFIER (512 UNITS)",
|
|
};
|
|
|
|
int32_t kopen4loadfrommod(const char *filename, char searchfirst)
|
|
{
|
|
static char fn[BMAX_PATH];
|
|
int32_t r=-1;
|
|
|
|
if (g_modDir[0])
|
|
{
|
|
Bsnprintf(fn,sizeof(fn),"%s/%s",g_modDir,filename);
|
|
r = kopen4load(fn,searchfirst);
|
|
}
|
|
|
|
if (r < 0)
|
|
r = kopen4load(filename,searchfirst);
|
|
|
|
return r;
|
|
}
|
|
|
|
static void clearfilenames(void)
|
|
{
|
|
klistfree(finddirs);
|
|
klistfree(findfiles);
|
|
finddirs = findfiles = NULL;
|
|
numfiles = numdirs = 0;
|
|
}
|
|
|
|
static int32_t getfilenames(const char *path, const char *kind)
|
|
{
|
|
CACHE1D_FIND_REC *r;
|
|
|
|
clearfilenames();
|
|
finddirs = klistpath(path,"*",CACHE1D_FIND_DIR);
|
|
findfiles = klistpath(path,kind,CACHE1D_FIND_FILE);
|
|
for (r = finddirs; r; r=r->next) numdirs++;
|
|
for (r = findfiles; r; r=r->next) numfiles++;
|
|
|
|
finddirshigh = finddirs;
|
|
findfileshigh = findfiles;
|
|
currentlist = 0;
|
|
if (findfileshigh) currentlist = 1;
|
|
|
|
return(0);
|
|
}
|
|
|
|
const char *ExtGetVer(void)
|
|
{
|
|
return s_buildRev;
|
|
}
|
|
|
|
static void MultiPskyInit(void)
|
|
{
|
|
int32_t i;
|
|
|
|
// new-style multi-psky handling
|
|
pskymultilist[0] = MOONSKY1;
|
|
pskymultilist[1] = BIGORBIT1;
|
|
pskymultilist[2] = LA;
|
|
|
|
pskymultiyscale[0] = 32768;
|
|
pskymultiyscale[1] = 32768;
|
|
pskymultiyscale[2] = 16384+1024;
|
|
|
|
for (i=0; i<3; i++)
|
|
{
|
|
pskymultibits[i] = 3;
|
|
Bmemset(pskymultioff[i], 0, sizeof(pskymultioff[i]));
|
|
}
|
|
|
|
// MOONSKY1
|
|
// earth mountian mountain sun
|
|
pskymultioff[0][6]=1;
|
|
pskymultioff[0][1]=2;
|
|
pskymultioff[0][4]=2;
|
|
pskymultioff[0][2]=3;
|
|
|
|
// BIGORBIT1 // orbit
|
|
// earth1 2 3 moon/sun
|
|
pskymultioff[1][5]=1;
|
|
pskymultioff[1][6]=2;
|
|
pskymultioff[1][7]=3;
|
|
pskymultioff[1][2]=4;
|
|
|
|
// LA // la city
|
|
// earth1 2 3 moon/sun
|
|
pskymultioff[2][0]=1;
|
|
pskymultioff[2][1]=2;
|
|
pskymultioff[2][2]=1;
|
|
pskymultioff[2][3]=3;
|
|
pskymultioff[2][4]=4;
|
|
pskymultioff[2][5]=0;
|
|
pskymultioff[2][6]=2;
|
|
pskymultioff[2][7]=3;
|
|
|
|
pskynummultis = 3;
|
|
|
|
// default in game:
|
|
parallaxyscale = 32768;
|
|
}
|
|
|
|
|
|
void ExtSetupMapFilename(const char *mapname)
|
|
{
|
|
Bstrcpy(levelname, mapname);
|
|
|
|
Bsprintf(tempbuf, "Mapster32 - %s", mapname);
|
|
wm_setapptitle(tempbuf);
|
|
}
|
|
|
|
void ExtLoadMap(const char *mapname)
|
|
{
|
|
int32_t i;
|
|
int32_t sky=0;
|
|
|
|
getmessageleng = 0;
|
|
getmessagetimeoff = 0;
|
|
|
|
ExtSetupMapFilename(mapname);
|
|
|
|
// old-fashioned multi-psky handling
|
|
|
|
Bmemset(pskyoff, 0, sizeof(pskyoff));
|
|
|
|
for (i=0; i<numsectors; i++)
|
|
{
|
|
switch (sector[i].ceilingpicnum)
|
|
{
|
|
case MOONSKY1 :
|
|
case BIGORBIT1 : // orbit
|
|
case LA : // la city
|
|
sky=sector[i].ceilingpicnum;
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch (sky)
|
|
{
|
|
case MOONSKY1 :
|
|
// keep in sync with MultiPskyInit
|
|
// -v-
|
|
Bmemcpy(pskyoff, pskymultioff[0], sizeof(pskymultioff[0]));
|
|
break;
|
|
|
|
case BIGORBIT1 : // orbit
|
|
Bmemcpy(pskyoff, pskymultioff[1], sizeof(pskymultioff[0]));
|
|
break;
|
|
|
|
case LA : // la city
|
|
Bmemcpy(pskyoff, pskymultioff[2], sizeof(pskymultioff[0]));
|
|
break;
|
|
}
|
|
|
|
pskybits=3;
|
|
parallaxtype=0;
|
|
|
|
//////////
|
|
#if M32_UNDO
|
|
map_undoredo_free();
|
|
#endif
|
|
}
|
|
|
|
void ExtSaveMap(const char *mapname)
|
|
{
|
|
UNREFERENCED_PARAMETER(mapname);
|
|
saveboard("backup.map",&pos.x,&pos.y,&pos.z,&ang,&cursectnum);
|
|
}
|
|
|
|
|
|
////////// tag labeling system //////////
|
|
|
|
typedef struct
|
|
{
|
|
hashtable_t hashtab;
|
|
char *label[32768];
|
|
int32_t numlabels;
|
|
} taglab_t;
|
|
|
|
static taglab_t g_taglab;
|
|
|
|
static void tstrtoupper(char *s)
|
|
{
|
|
int32_t i;
|
|
for (i=0; s[i]; i++)
|
|
s[i] = Btoupper(s[i]);
|
|
}
|
|
|
|
void taglab_init()
|
|
{
|
|
int32_t i;
|
|
|
|
g_taglab.numlabels = 0;
|
|
g_taglab.hashtab.size = 16384;
|
|
hash_init(&g_taglab.hashtab);
|
|
|
|
for (i=0; i<32768; i++)
|
|
{
|
|
if (g_taglab.label[i])
|
|
Bfree(g_taglab.label[i]);
|
|
g_taglab.label[i] = NULL;
|
|
}
|
|
}
|
|
|
|
int32_t taglab_load(const char *filename, int32_t flags)
|
|
{
|
|
int32_t fil, len, i;
|
|
char buf[BMAX_PATH], *dot, *filebuf;
|
|
|
|
taglab_init();
|
|
|
|
len = Bstrlen(filename);
|
|
if (len >= BMAX_PATH-1)
|
|
return -1;
|
|
Bmemcpy(buf, filename, len+1);
|
|
|
|
//
|
|
dot = Bstrrchr(buf, '.');
|
|
if (!dot)
|
|
dot = &buf[len];
|
|
|
|
if (dot-buf+8 >= BMAX_PATH)
|
|
return -1;
|
|
Bmemcpy(dot, ".maptags", 9);
|
|
//
|
|
|
|
if ((fil = kopen4load(buf,flags)) == -1)
|
|
return -1;
|
|
|
|
len = kfilelength(fil);
|
|
|
|
filebuf = Bmalloc(len+1);
|
|
if (!filebuf)
|
|
{
|
|
kclose(fil);
|
|
return -1;
|
|
}
|
|
|
|
kread(fil, filebuf, len);
|
|
filebuf[len] = 0;
|
|
kclose(fil);
|
|
|
|
// ----
|
|
|
|
{
|
|
int32_t tag;
|
|
char *cp=filebuf, *bp, *ep;
|
|
|
|
while (1)
|
|
{
|
|
#define XTAGLAB_STRINGIFY(X) TAGLAB_STRINGIFY(X)
|
|
#define TAGLAB_STRINGIFY(X) #X
|
|
i = sscanf(cp, "%d %" XTAGLAB_STRINGIFY(TAGLAB_MAX) "s", &tag, buf);
|
|
#undef XTAGLAB_STRINGIFY
|
|
#undef TAGLAB_STRINGIFY
|
|
if (i != 2 || !buf[0] || tag<0 || tag>=32768)
|
|
goto nextline;
|
|
|
|
buf[TAGLAB_MAX-1] = 0;
|
|
|
|
i = Bstrlen(buf);
|
|
bp = buf; while (*bp && isspace(*bp)) bp++;
|
|
ep = &buf[i-1]; while (ep>buf && isspace(*ep)) ep--;
|
|
ep++;
|
|
|
|
if (!(ep > bp))
|
|
goto nextline;
|
|
*ep = 0;
|
|
|
|
taglab_add(bp, tag);
|
|
//initprintf("add tag %s:%d\n", bp, tag);
|
|
nextline:
|
|
while (*cp && *cp!='\n')
|
|
cp++;
|
|
while (*cp=='\r' || *cp=='\n')
|
|
cp++;
|
|
if (*cp == 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
// ----
|
|
Bfree(filebuf);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t taglab_save(const char *mapname)
|
|
{
|
|
int32_t fil, len, i;
|
|
char buf[BMAX_PATH], *dot;
|
|
const char *label;
|
|
|
|
if (g_taglab.numlabels==0)
|
|
return 1;
|
|
|
|
Bstrncpy(buf, mapname, BMAX_PATH);
|
|
buf[BMAX_PATH-1] = 0;
|
|
|
|
len = Bstrlen(buf);
|
|
//
|
|
dot = Bstrrchr(buf, '.');
|
|
if (!dot)
|
|
dot = &buf[len];
|
|
|
|
if (dot-buf+8 >= BMAX_PATH)
|
|
return -1;
|
|
Bmemcpy(dot, ".maptags", 9);
|
|
//
|
|
|
|
if ((fil = Bopen(buf,BO_BINARY|BO_TRUNC|BO_CREAT|BO_WRONLY,BS_IREAD|BS_IWRITE)) == -1)
|
|
{
|
|
initprintf("Couldn't open \"%s\" for writing: %s\n", buf, strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
for (i=0; i<32768; i++)
|
|
{
|
|
label = taglab_getlabel(i);
|
|
if (!label)
|
|
continue;
|
|
|
|
len = Bsprintf(buf, "%d %s"OURNEWL, i, label);
|
|
if (Bwrite(fil, buf, len)!=len)
|
|
break;
|
|
}
|
|
|
|
Bclose(fil);
|
|
|
|
return (i!=32768);
|
|
}
|
|
|
|
int32_t taglab_add(const char *label, int16_t tag)
|
|
{
|
|
const char *otaglabel;
|
|
char buf[TAGLAB_MAX];
|
|
int32_t olabeltag, diddel=0;
|
|
|
|
if (tag < 0)
|
|
return -1;
|
|
|
|
Bstrncpy(buf, label, sizeof(buf));
|
|
buf[sizeof(buf)-1] = 0;
|
|
// upcase the tag for storage and comparison
|
|
tstrtoupper(buf);
|
|
|
|
otaglabel = g_taglab.label[tag];
|
|
if (otaglabel)
|
|
{
|
|
if (!Bstrcasecmp(otaglabel, buf))
|
|
return 0;
|
|
|
|
// hash_delete(&g_taglab.hashtab, g_taglab.label[tag]);
|
|
|
|
// a label having the same tag number as 'tag' is deleted
|
|
Bfree(g_taglab.label[tag]);
|
|
g_taglab.label[tag] = NULL;
|
|
diddel |= 1;
|
|
}
|
|
else
|
|
{
|
|
olabeltag = hash_findcase(&g_taglab.hashtab, buf);
|
|
if (olabeltag==tag)
|
|
return 0;
|
|
|
|
if (olabeltag>=0)
|
|
{
|
|
// the label gets assigned to a new tag number ('tag deleted')
|
|
Bfree(g_taglab.label[olabeltag]);
|
|
g_taglab.label[olabeltag] = NULL;
|
|
diddel |= 2;
|
|
}
|
|
}
|
|
|
|
if (!diddel)
|
|
g_taglab.numlabels++;
|
|
g_taglab.label[tag] = Bstrdup(buf);
|
|
//initprintf("added %s %d to hash\n", g_taglab.label[tag], tag);
|
|
hash_add(&g_taglab.hashtab, g_taglab.label[tag], tag, 1);
|
|
|
|
return diddel;
|
|
}
|
|
|
|
const char *taglab_getlabel(int16_t tag)
|
|
{
|
|
if (tag < 0) // || tag>=32768 implicitly
|
|
return NULL;
|
|
|
|
return g_taglab.label[tag];
|
|
}
|
|
|
|
int32_t taglab_gettag(const char *label)
|
|
{
|
|
char buf[TAGLAB_MAX];
|
|
|
|
Bstrncpy(buf, label, TAGLAB_MAX);
|
|
buf[sizeof(buf)-1] = 0;
|
|
|
|
// need to upcase since hash_findcase doesn't work as expected:
|
|
// getting the code is still (necessarily) case-sensitive...
|
|
tstrtoupper(buf);
|
|
|
|
return hash_findcase(&g_taglab.hashtab, buf);
|
|
}
|
|
|
|
#define TLCHAR "+"
|
|
#define TLCHR(Cond) ((Cond)?TLCHAR:"")
|
|
static uint64_t taglab_nolink_SEs = (1ull<<10)|(1ull<<27)|(1ull<<28)|(1ull<<29)|(1ull<<49)|(1ull<<50);
|
|
|
|
// Whether the individual tags have linking semantics. Based on
|
|
// http://infosuite.duke4.net/index.php?page=references_special_textures
|
|
// The return value is an OR of the following:
|
|
// 1: lotag has linking semantics
|
|
// 2: hitag
|
|
// 4: extra
|
|
// 8: xvel
|
|
// 16: yvel
|
|
// 32: zvel
|
|
// 64: owner
|
|
// This function is only supposed to say something about the potential of a tag:
|
|
// it will also 'say yes' if a particular tag is zero.
|
|
int32_t taglab_linktags(int32_t spritep, int32_t num)
|
|
{
|
|
int32_t picnum;
|
|
int32_t l, link = 0;
|
|
|
|
if (spritep)
|
|
picnum = sprite[num].picnum;
|
|
else
|
|
picnum = wall[num].picnum;
|
|
|
|
if (spritep)
|
|
{
|
|
switch (picnum)
|
|
{
|
|
case SECTOREFFECTOR:
|
|
// SEs potentially link by their hitag
|
|
l = sprite[num].lotag;
|
|
if (l>=0 && l<=63 && (taglab_nolink_SEs&(1ull<<l)))
|
|
break;
|
|
// if (sprite[num].hitag > 0)
|
|
link = 2;
|
|
break;
|
|
|
|
// various lotag-linkers
|
|
case ACTIVATOR: case TOUCHPLATE: case ACTIVATORLOCKED: case MASTERSWITCH:
|
|
case RESPAWN: // ---
|
|
case ACCESSSWITCH: case ACCESSSWITCH2:
|
|
case MULTISWITCH: // *
|
|
case DIPSWITCH: case TECHSWITCH: case ALIENSWITCH: case TARGET: case DUCK:
|
|
case REACTOR:
|
|
case CAMERA1:
|
|
// if (sprite[num].lotag > 0)
|
|
link = 1;
|
|
break;
|
|
|
|
// various hitag-linkers
|
|
case VIEWSCREEN2: case VIEWSCREEN:
|
|
case CRACK1: case CRACK2: case CRACK3: case CRACK4: case FIREEXT:
|
|
case FEM1: case FEM2: case FEM3: case FEM4: case FEM5: case FEM6:
|
|
case FEM7: case FEM8: case FEM9: case FEM10: case PODFEM1: case NAKED1: //case STATUE: //?
|
|
case SEENINE: case OOZFILTER:
|
|
case CRANEPOLE: case CRANE:
|
|
case NATURALLIGHTNING:
|
|
// if (sprite[num].hitag > 0)
|
|
link = 2;
|
|
break;
|
|
}
|
|
}
|
|
else // walls
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getnextwall(num, YAX_CEILING) < 0)
|
|
#endif
|
|
switch (picnum)
|
|
{
|
|
case TECHLIGHT2: case TECHLIGHT4: case WALLLIGHT4:
|
|
case WALLLIGHT3: case WALLLIGHT1: case WALLLIGHT2:
|
|
case BIGFORCE: case W_FORCEFIELD:
|
|
// if (wall[num].lotag > 0)
|
|
link = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!link)
|
|
#ifdef YAX_ENABLE
|
|
if (spritep || yax_getnextwall(num, YAX_CEILING) < 0)
|
|
#endif
|
|
{
|
|
// try a few that work both as sprites and as walls
|
|
switch (picnum)
|
|
{
|
|
case ACCESSSWITCH: case SLOTDOOR: case LIGHTSWITCH: case SPACEDOORSWITCH:
|
|
case SPACELIGHTSWITCH: case FRANKENSTINESWITCH: case MULTISWITCH:
|
|
case DIPSWITCH: case DIPSWITCH2: case TECHSWITCH: case DIPSWITCH3:
|
|
case ACCESSSWITCH2: case LIGHTSWITCH2: case POWERSWITCH1: case LOCKSWITCH1:
|
|
case POWERSWITCH2: case HANDSWITCH: case PULLSWITCH: case ALIENSWITCH: // ---
|
|
case DOORTILE5: case DOORTILE6: case DOORTILE1: case DOORTILE2: case DOORTILE3:
|
|
case DOORTILE4: case DOORTILE7: case DOORTILE8: case DOORTILE9: case DOORTILE10:
|
|
case DOORTILE22: case DOORTILE18: case DOORTILE19: case DOORTILE20:
|
|
case DOORTILE14: case DOORTILE16: case DOORTILE15: case DOORTILE21:
|
|
case DOORTILE17: case DOORTILE11: case DOORTILE12: case DOORTILE23: // ---
|
|
// if ((!spritep && wall[num].lotag>0) || (spritep && sprite[num].lotag>0))
|
|
link = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
g_iReturnVar = link;
|
|
VM_OnEvent(EVENT_LINKTAGS, spritep?num:-1);
|
|
link = g_iReturnVar;
|
|
|
|
return link;
|
|
}
|
|
|
|
int32_t taglab_getnextfreetag(void)
|
|
{
|
|
int32_t i, lt, nextfreetag=1;
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
{
|
|
if (sprite[i].statnum == MAXSTATUS)
|
|
continue;
|
|
|
|
if (sprite[i].picnum==MULTISWITCH)
|
|
{
|
|
// MULTISWITCH needs special care
|
|
int32_t endtag = sprite[i].lotag+3;
|
|
if (nextfreetag <= endtag)
|
|
nextfreetag = endtag+1;
|
|
continue;
|
|
}
|
|
|
|
lt = taglab_linktags(1, i);
|
|
if ((lt&1) && nextfreetag <= sprite[i].lotag)
|
|
nextfreetag = sprite[i].lotag+1;
|
|
if ((lt&2) && nextfreetag <= sprite[i].hitag)
|
|
nextfreetag = sprite[i].hitag+1;
|
|
}
|
|
|
|
for (i=0; i<numwalls; i++)
|
|
{
|
|
lt = taglab_linktags(0, i);
|
|
if ((lt&1) && nextfreetag <= wall[i].lotag)
|
|
nextfreetag = wall[i].lotag+1;
|
|
if ((lt&2) && nextfreetag <= wall[i].hitag)
|
|
nextfreetag = wall[i].hitag+1;
|
|
}
|
|
|
|
if (nextfreetag < 32768)
|
|
return nextfreetag;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void taglab_handle1(int32_t linktagp, int32_t tagnum, char *buf)
|
|
{
|
|
const char *label = NULL;
|
|
if (linktagp && showtags==2)
|
|
label = taglab_getlabel(tagnum);
|
|
|
|
if (label)
|
|
Bsprintf(buf, "%d<%s>", tagnum, label);
|
|
else
|
|
Bsprintf(buf, "%d%s", tagnum, TLCHR(linktagp));
|
|
}
|
|
////////// end tag labeling system //////////
|
|
|
|
|
|
static int32_t getTileGroup(const char *groupName)
|
|
{
|
|
int32_t temp;
|
|
for (temp = 0; temp < MAX_TILE_GROUPS; temp++)
|
|
{
|
|
if (s_TileGroups[temp].szText == NULL)
|
|
return -1;
|
|
|
|
if (!Bstrcmp(s_TileGroups[temp].szText, groupName))
|
|
return temp;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int32_t tileInGroup(int32_t group, int32_t tilenum)
|
|
{
|
|
// @todo Make a bitmap instead of doing this slow search..
|
|
int32_t temp;
|
|
if (group < 0 || group >= MAX_TILE_GROUPS || s_TileGroups[group].szText == NULL)
|
|
{
|
|
// group isn't valid.
|
|
return 0;
|
|
}
|
|
for (temp=0; temp<s_TileGroups[group].nIds; temp++)
|
|
{
|
|
if (tilenum == s_TileGroups[group].pIds[temp])
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
const char *ExtGetSectorType(int32_t lotag)
|
|
{
|
|
switch (lotag)
|
|
{
|
|
case 1: return "WATER (SE 7)";
|
|
case 2: return "UNDERWATER (SE 7)";
|
|
case 9: return "STAR TREK DOORS";
|
|
case 15: return "ELEVATOR TRANSPORT (SE 17)";
|
|
case 16: return "ELEVATOR PLATFORM DOWN";
|
|
case 17: return "ELEVATOR PLATFORM UP";
|
|
case 18: return "ELEVATOR DOWN";
|
|
case 19: return "ELEVATOR UP";
|
|
case 20: return "CEILING DOOR";
|
|
case 21: return "FLOOR DOOR";
|
|
case 22: return "SPLIT DOOR";
|
|
case 23: return "SWING DOOR (SE 11)";
|
|
case 25: return "SLIDE DOOR (SE 15)";
|
|
case 26: return "SPLIT STAR TREK DOOR";
|
|
case 27: return "BRIDGE (SE 20)";
|
|
case 28: return "DROP FLOOR (SE 21)";
|
|
case 29: return "TEETH DOOR (SE 22)";
|
|
case 30: return "ROTATE RISE BRIDGE";
|
|
case 31: return "2 WAY TRAIN (SE=30)";
|
|
case 32767: return "SECRET ROOM";
|
|
case -1: return "END OF LEVEL";
|
|
default:
|
|
if (lotag > 10000 && lotag < 32767)
|
|
return "1 TIME SOUND";
|
|
// else Bsprintf(tempbuf,"%hu",lotag);
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
const char *ExtGetSectorCaption(int16_t sectnum)
|
|
{
|
|
static char tempbuf[64];
|
|
|
|
Bmemset(tempbuf, 0, sizeof(tempbuf));
|
|
|
|
if (qsetmode != 200 && ((onnames!=1 && onnames!=4 && onnames!=7) || onnames==8))
|
|
return tempbuf;
|
|
|
|
if (qsetmode == 200 || (sector[sectnum].lotag|sector[sectnum].hitag))
|
|
{
|
|
Bstrcpy(lo, ExtGetSectorType(sector[sectnum].lotag));
|
|
if (qsetmode != 200)
|
|
Bsprintf(tempbuf,"%hu,%hu %s", sector[sectnum].hitag, sector[sectnum].lotag, lo);
|
|
else
|
|
Bsprintf(tempbuf,"%hu %s", sector[sectnum].lotag, lo);
|
|
}
|
|
return(tempbuf);
|
|
}
|
|
|
|
const char *ExtGetWallCaption(int16_t wallnum)
|
|
{
|
|
static char tempbuf[64];
|
|
|
|
Bmemset(tempbuf,0,sizeof(tempbuf));
|
|
|
|
if (wall[wallnum].cstat & (1<<14))
|
|
{
|
|
Bsprintf(tempbuf,"%d", wallength(wallnum));
|
|
wall[wallnum].cstat &= ~(1<<14);
|
|
return(tempbuf);
|
|
}
|
|
|
|
if (!(onnames==2 || onnames==4))
|
|
{
|
|
tempbuf[0] = 0;
|
|
return(tempbuf);
|
|
}
|
|
|
|
// HERE
|
|
|
|
if ((wall[wallnum].lotag|wall[wallnum].hitag) == 0)
|
|
tempbuf[0] = 0;
|
|
else
|
|
{
|
|
int32_t lt = taglab_linktags(0, wallnum);
|
|
char histr[TAGLAB_MAX+16], lostr[TAGLAB_MAX+16];
|
|
|
|
lt &= ~(wall[wallnum].lotag<=0);
|
|
lt &= ~((wall[wallnum].hitag<=0)<<1);
|
|
|
|
taglab_handle1(lt&2, wall[wallnum].hitag, histr);
|
|
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getnextwall(wallnum, YAX_CEILING) >= 0) // ceiling nextwall: lotag
|
|
{
|
|
if (wall[wallnum].hitag == 0)
|
|
tempbuf[0] = 0;
|
|
else
|
|
Bsprintf(tempbuf, "%s,*", histr);
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
taglab_handle1(lt&1, wall[wallnum].lotag, lostr);
|
|
Bsprintf(tempbuf, "%s,%s", histr, lostr);
|
|
}
|
|
}
|
|
|
|
return(tempbuf);
|
|
} //end
|
|
|
|
const char *SectorEffectorTagText(int32_t lotag)
|
|
{
|
|
static char tempbuf[64];
|
|
|
|
static const char *tags[] =
|
|
{
|
|
"ROTATED SECTOR", // 0
|
|
"PIVOT SPRITE FOR SE 0",
|
|
"EARTHQUAKE",
|
|
"RANDOM LIGHTS AFTER SHOT OUT",
|
|
"RANDOM LIGHTS",
|
|
"(UNKNOWN)", // 5
|
|
"SUBWAY",
|
|
"TRANSPORT",
|
|
"UP OPEN DOOR LIGHTS",
|
|
"DOWN OPEN DOOR LIGHTS",
|
|
"DOOR AUTO CLOSE (H=DELAY)", // 10
|
|
"ROTATE SECTOR DOOR",
|
|
"LIGHT SWITCH",
|
|
"EXPLOSIVE",
|
|
"SUBWAY CAR",
|
|
"SLIDE DOOR (ST 25)", // 15
|
|
"ROTATE REACTOR SECTOR",
|
|
"ELEVATOR TRANSPORT (ST 15)",
|
|
"INCREMENTAL SECTOR RISE/FALL",
|
|
"CEILING FALL ON EXPLOSION",
|
|
"BRIDGE (ST 27)", // 20
|
|
"DROP FLOOR (ST 28)",
|
|
"TEETH DOOR (ST 29)",
|
|
"1-WAY SE7 DESTINATION (H=SE 7)",
|
|
"CONVEYER BELT",
|
|
"ENGINE", // 25
|
|
"(UNKNOWN)",
|
|
"CAMERA FOR PLAYBACK",
|
|
"LIGHTNING (H=TILE#4890)",
|
|
"FLOAT",
|
|
"2 WAY TRAIN (ST=31)", // 30
|
|
"FLOOR RISE/FALL",
|
|
"CEILING RISE/FALL",
|
|
"SPAWN JIB W/QUAKE",
|
|
};
|
|
|
|
Bmemset(tempbuf,0,sizeof(tempbuf));
|
|
|
|
if (lotag>=0 && lotag<(int32_t)(sizeof(tags)/sizeof(tags[0])))
|
|
Bsprintf(tempbuf, "%d: %s", lotag, tags[lotag]);
|
|
else
|
|
switch (lotag)
|
|
{
|
|
case 36:
|
|
Bsprintf(tempbuf,"%d: SHOOTER",lotag);
|
|
break;
|
|
case 49:
|
|
Bsprintf(tempbuf,"%d: POINT LIGHT",lotag);
|
|
break;
|
|
case 50:
|
|
Bsprintf(tempbuf,"%d: SPOTLIGHT",lotag);
|
|
break;
|
|
default:
|
|
Bsprintf(tempbuf,"%d: (UNKNOWN)",lotag);
|
|
break;
|
|
}
|
|
|
|
return (tempbuf);
|
|
}
|
|
|
|
const char *MusicAndSFXTagText(int32_t lotag)
|
|
{
|
|
static char tempbuf[16];
|
|
|
|
Bmemset(tempbuf, 0, sizeof(tempbuf));
|
|
|
|
if (g_numsounds <= 0)
|
|
return tempbuf;
|
|
|
|
if (lotag>0 && lotag<999 && g_sounds[lotag].definedname)
|
|
return g_sounds[lotag].definedname;
|
|
|
|
if (lotag>=1000 && lotag<2000)
|
|
Bsprintf(tempbuf, "REVERB");
|
|
return tempbuf;
|
|
}
|
|
|
|
const char *SectorEffectorText(int32_t spritenum)
|
|
{
|
|
static char tempbuf[64];
|
|
|
|
Bmemset(tempbuf, 0, sizeof(tempbuf));
|
|
Bmemset(lo, 0, sizeof(lo));
|
|
|
|
Bstrcpy(lo, SectorEffectorTagText(sprite[spritenum].lotag));
|
|
if (!lo[5]) // tags are 5 chars or less
|
|
SpriteName(spritenum, tempbuf);
|
|
else
|
|
Bsprintf(tempbuf, "SE %s",lo);
|
|
|
|
return (tempbuf);
|
|
}
|
|
|
|
const char *ExtGetSpriteCaption(int16_t spritenum)
|
|
{
|
|
static char tempbuf[1024];
|
|
int32_t retfast = 0, lt;
|
|
|
|
Bmemset(tempbuf,0,sizeof(tempbuf));
|
|
|
|
if (!(onnames>=3 && onnames<=8) || (onnames==7 && sprite[spritenum].picnum!=SECTOREFFECTOR))
|
|
retfast = 1;
|
|
if (onnames==5 && !tileInGroup(tilegroupItems, sprite[spritenum].picnum))
|
|
retfast = 1;
|
|
if (onnames==6 && sprite[spritenum].picnum != sprite[cursprite].picnum)
|
|
retfast = 1;
|
|
|
|
if (retfast)
|
|
return tempbuf;
|
|
|
|
lt = taglab_linktags(1, spritenum);
|
|
lt &= ~(sprite[spritenum].lotag<=0);
|
|
lt &= ~((sprite[spritenum].hitag<=0)<<1);
|
|
|
|
if ((sprite[spritenum].lotag|sprite[spritenum].hitag) == 0)
|
|
{
|
|
SpriteName(spritenum,lo);
|
|
if (lo[0]!=0)
|
|
{
|
|
if (sprite[spritenum].pal==1)
|
|
Bsprintf(tempbuf,"%s (MULTIPLAYER)",lo);
|
|
else
|
|
Bsprintf(tempbuf,"%s",lo);
|
|
}
|
|
|
|
return tempbuf;
|
|
}
|
|
|
|
{
|
|
char histr[TAGLAB_MAX+16], lostr[TAGLAB_MAX+16];
|
|
|
|
taglab_handle1(lt&2, sprite[spritenum].hitag, histr);
|
|
|
|
if (sprite[spritenum].picnum==SECTOREFFECTOR)
|
|
{
|
|
if (onnames!=8)
|
|
{
|
|
Bsprintf(lo,"%s",SectorEffectorText(spritenum));
|
|
Bsprintf(tempbuf,"%s, %s",lo, histr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
taglab_handle1(lt&1, sprite[spritenum].lotag, lostr);
|
|
|
|
SpriteName(spritenum,lo);
|
|
if (sprite[spritenum].extra != -1)
|
|
Bsprintf(tempbuf,"%s,%s,%d %s", histr, lostr, sprite[spritenum].extra, lo);
|
|
else
|
|
Bsprintf(tempbuf,"%s,%s %s", histr, lostr, lo);
|
|
}
|
|
}
|
|
|
|
return tempbuf;
|
|
|
|
} //end
|
|
|
|
//printext16 parameters:
|
|
//printext16(int32_t xpos, int32_t ypos, int16_t col, int16_t backcol,
|
|
// char name[82], char fontsize)
|
|
// xpos 0-639 (top left)
|
|
// ypos 0-479 (top left)
|
|
// col 0-15
|
|
// backcol 0-15, -1 is transparent background
|
|
// name
|
|
// fontsize 0=8*8, 1=3*5
|
|
|
|
//drawline16 parameters:
|
|
// drawline16(int32_t x1, int32_t y1, int32_t x2, int32_t y2, char col)
|
|
// x1, x2 0-639
|
|
// y1, y2 0-143 (status bar is 144 high, origin is top-left of STATUS BAR)
|
|
// col 0-15
|
|
|
|
static void PrintStatus(const char *string, int32_t num, int32_t x, int32_t y, int32_t color)
|
|
{
|
|
Bsprintf(tempbuf, "%s %d", string, num);
|
|
printext16(x*8, ydim-STATUS2DSIZ+y*8, editorcolors[color], -1, tempbuf, 0);
|
|
}
|
|
|
|
void ExtShowSectorData(int16_t sectnum) //F5
|
|
{
|
|
int32_t x,x2,y;
|
|
int32_t i,yi;
|
|
int32_t secrets=0;
|
|
int32_t totalactors1=0,totalactors2=0,totalactors3=0,totalactors4=0;
|
|
int32_t totalrespawn=0;
|
|
|
|
UNREFERENCED_PARAMETER(sectnum);
|
|
if (qsetmode==200)
|
|
return;
|
|
|
|
for (i=0; i<numsectors; i++)
|
|
secrets += (sector[i].lotag==32767);
|
|
|
|
for (i=headspritestat[0]; i != -1; i=nextspritestat[i])
|
|
{
|
|
// Count all non-player actors.
|
|
if (tileInGroup(tilegroupActors, sprite[i].picnum))
|
|
{
|
|
if (sprite[i].lotag<=1) totalactors1++;
|
|
if (sprite[i].lotag<=2) totalactors2++;
|
|
if (sprite[i].lotag<=3) totalactors3++;
|
|
if (sprite[i].lotag<=4) totalactors4++;
|
|
}
|
|
|
|
if (sprite[i].picnum == RESPAWN)
|
|
totalrespawn++;
|
|
}
|
|
|
|
Bmemset(numsprite, 0, sizeof(numsprite));
|
|
Bmemset(multisprite, 0, sizeof(numsprite));
|
|
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
{
|
|
if (sprite[i].statnum==0 && sprite[i].picnum>=0 && sprite[i].picnum<MAXTILES)
|
|
{
|
|
if (sprite[i].pal!=0)
|
|
multisprite[sprite[i].picnum]++;
|
|
else
|
|
numsprite[sprite[i].picnum]++;
|
|
}
|
|
}
|
|
|
|
clearmidstatbar16(); //Clear middle of status bar
|
|
|
|
ydim -= 8;
|
|
drawgradient();
|
|
ydim += 8;
|
|
|
|
printmessage16("Level %s next tag %d", levelname, taglab_getnextfreetag());
|
|
|
|
#define PRSTAT(Str, Tiledef) \
|
|
PrintStatus(Str, numsprite[Tiledef], x, y+yi, numsprite[Tiledef]?11:7); \
|
|
PrintStatus("",multisprite[Tiledef], x2,y+yi, multisprite[Tiledef]?9:7); \
|
|
yi++;
|
|
|
|
ydim -= 8; // vvvvvv reset at end!!
|
|
|
|
begindrawing(); //{{{
|
|
|
|
x=1; x2=14;
|
|
y=4; yi=2;
|
|
printext16(x*8, ydim-STATUS2DSIZ+y*8, editorcolors[11], -1, "Item Count", 0);
|
|
|
|
PRSTAT("10%health=", COLA);
|
|
PRSTAT("30%health=", SIXPAK);
|
|
PRSTAT("Med-Kit =", FIRSTAID);
|
|
PRSTAT("Atom =", ATOMICHEALTH);
|
|
PRSTAT("Shields =", SHIELD);
|
|
|
|
x=17; x2=30;
|
|
y=4; yi=2;
|
|
printext16(x*8, ydim-STATUS2DSIZ+y*8, editorcolors[11], -1, "Inventory", 0);
|
|
|
|
PRSTAT("Steroids =", STEROIDS);
|
|
PRSTAT("Airtank =", AIRTANK);
|
|
PRSTAT("Jetpack =", JETPACK);
|
|
PRSTAT("Goggles =", HEATSENSOR);
|
|
PRSTAT("Boots =", BOOTS);
|
|
PRSTAT("HoloDuke =", HOLODUKE);
|
|
PRSTAT("Multi D =", APLAYER);
|
|
|
|
x=33; x2=46;
|
|
y=4; yi=2;
|
|
printext16(x*8, ydim-STATUS2DSIZ+y*8, editorcolors[11], -1, "Weapon Count", 0);
|
|
|
|
PRSTAT("Pistol =", FIRSTGUNSPRITE);
|
|
PRSTAT("Shotgun =", SHOTGUNSPRITE);
|
|
PRSTAT("Chaingun =", CHAINGUNSPRITE);
|
|
PRSTAT("RPG =", RPGSPRITE);
|
|
PRSTAT("Pipe Bomb=", HEAVYHBOMB);
|
|
PRSTAT("Shrinker =", SHRINKERSPRITE);
|
|
PRSTAT("Devastatr=", DEVISTATORSPRITE);
|
|
PRSTAT("Trip mine=", TRIPBOMBSPRITE);
|
|
PRSTAT("Freezeray=", FREEZESPRITE);
|
|
|
|
x=49; x2=62;
|
|
y=4; yi=2;
|
|
printext16(x*8,ydim-STATUS2DSIZ+y*8,editorcolors[11],-1,"Ammo Count",0);
|
|
|
|
PRSTAT("Pistol =", AMMO);
|
|
PRSTAT("Shot =", SHOTGUNAMMO);
|
|
PRSTAT("Chain =", BATTERYAMMO);
|
|
PRSTAT("RPG Box =", RPGAMMO);
|
|
PRSTAT("Pipe Bomb=", HBOMBAMMO);
|
|
PRSTAT("Shrinker =", CRYSTALAMMO);
|
|
PRSTAT("Devastatr=", DEVISTATORAMMO);
|
|
PRSTAT("Expander =", GROWAMMO);
|
|
PRSTAT("Freezeray=", FREEZEAMMO);
|
|
|
|
printext16(65*8, ydim-STATUS2DSIZ+4*8, editorcolors[11], -1, "MISC", 0);
|
|
printext16(65*8, ydim-STATUS2DSIZ+8*8, editorcolors[11], -1, "ACTORS", 0);
|
|
|
|
#undef PRSTAT
|
|
|
|
PrintStatus("Secrets =", secrets, 65, 6, 11);
|
|
PrintStatus("Skill 1 =", totalactors1, 65, 10, 11);
|
|
PrintStatus("Skill 2 =", totalactors2, 65, 11, 11);
|
|
PrintStatus("Skill 3 =", totalactors3, 65, 12, 11);
|
|
PrintStatus("Skill 4 =", totalactors4, 65, 13, 11);
|
|
PrintStatus("Respawn =", totalrespawn, 65, 14, 11);
|
|
|
|
enddrawing(); //}}}
|
|
|
|
ydim += 8; // ^^^^^^ see above!
|
|
}
|
|
|
|
void ExtShowWallData(int16_t wallnum) //F6
|
|
{
|
|
int32_t i, runi, total=0, x, y, yi;
|
|
|
|
UNREFERENCED_PARAMETER(wallnum);
|
|
|
|
if (qsetmode==200)
|
|
return;
|
|
|
|
clearmidstatbar16();
|
|
drawgradient();
|
|
|
|
printmessage16("Level %s next tag %d", levelname, taglab_getnextfreetag());
|
|
|
|
|
|
#define CASES_LIZTROOP \
|
|
LIZTROOP: case LIZTROOPRUNNING : case LIZTROOPSTAYPUT: case LIZTROOPSHOOT: \
|
|
case LIZTROOPJETPACK: case LIZTROOPONTOILET: case LIZTROOPDUCKING
|
|
#define CASES_BOSS1 BOSS1: case BOSS1STAYPUT: case BOSS1SHOOT: case BOSS1LOB: case BOSSTOP
|
|
|
|
Bmemset(numsprite, 0, sizeof(numsprite));
|
|
Bmemset(multisprite, 0, sizeof(multisprite));
|
|
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
{
|
|
if (sprite[i].statnum==0 && sprite[i].pal)
|
|
switch (sprite[i].picnum)
|
|
{
|
|
case CASES_LIZTROOP:
|
|
numsprite[LIZTROOP]++;
|
|
break;
|
|
case CASES_BOSS1:
|
|
multisprite[BOSS1]++;
|
|
break;
|
|
case BOSS2:
|
|
multisprite[BOSS2]++;
|
|
break;
|
|
case BOSS3:
|
|
multisprite[BOSS3]++;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// runi==0: Count Normal Actors
|
|
// runi==1: Count Respawn Actors
|
|
for (runi=0; runi<2; runi++)
|
|
{
|
|
if (runi==1)
|
|
{
|
|
Bmemset(numsprite, 0, sizeof(numsprite));
|
|
Bmemset(multisprite, 0, sizeof(multisprite));
|
|
}
|
|
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
{
|
|
int32_t pic;
|
|
|
|
if (sprite[i].statnum!=0)
|
|
continue;
|
|
|
|
if (runi==0 && sprite[i].pal!=0)
|
|
continue;
|
|
|
|
if (runi==1 && sprite[i].picnum!=RESPAWN)
|
|
continue;
|
|
|
|
pic = (runi==0) ? sprite[i].picnum : sprite[i].hitag;
|
|
if (pic<0 || pic>=MAXTILES)
|
|
continue;
|
|
|
|
switch (pic)
|
|
{
|
|
case CASES_LIZTROOP:
|
|
numsprite[LIZTROOP]++;
|
|
break;
|
|
case PIGCOP: case PIGCOPSTAYPUT: case PIGCOPDIVE:
|
|
numsprite[PIGCOP]++;
|
|
break;
|
|
case LIZMAN: case LIZMANSTAYPUT: case LIZMANSPITTING: case LIZMANFEEDING: case LIZMANJUMP:
|
|
numsprite[LIZMAN]++;
|
|
break;
|
|
case CASES_BOSS1:
|
|
if (runi==0 || sprite[i].pal==0)
|
|
numsprite[BOSS1]++;
|
|
else
|
|
multisprite[BOSS1]++;
|
|
break;
|
|
case COMMANDER:
|
|
case COMMANDERSTAYPUT:
|
|
numsprite[COMMANDER]++;
|
|
break;
|
|
case OCTABRAIN:
|
|
case OCTABRAINSTAYPUT:
|
|
numsprite[OCTABRAIN]++;
|
|
break;
|
|
case RECON: case DRONE: case ROTATEGUN: case EGG: case ORGANTIC: case GREENSLIME:
|
|
case BOSS2: case BOSS3: case TANK: case NEWBEAST: case NEWBEASTSTAYPUT: case BOSS4:
|
|
numsprite[pic]++;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
#undef CASES_LIZTROOP
|
|
#undef CASES_BOSS1
|
|
|
|
total=0;
|
|
for (i=0; i<MAXTILES; i++)
|
|
total += numsprite[i];
|
|
for (i=0; i<MAXTILES; i++)
|
|
total += multisprite[i];
|
|
|
|
begindrawing(); //{{{
|
|
|
|
x=2+runi*34;
|
|
y=4;
|
|
PrintStatus(runi==0?"Normal actors:":"Respawn actors:", total, x, y, 11);
|
|
|
|
#define PRSTAT(Str, Tiledef) PrintStatus(Str, numsprite[Tiledef], x, y+(yi++), numsprite[Tiledef]?11:7);
|
|
yi=1;
|
|
|
|
PRSTAT(" Liztroop =", LIZTROOP);
|
|
PRSTAT(" Lizman =", LIZMAN);
|
|
PRSTAT(" Commander =", COMMANDER);
|
|
PRSTAT(" Octabrain =", OCTABRAIN);
|
|
PRSTAT(" PigCop =", PIGCOP);
|
|
PRSTAT(" Recon Car =", RECON);
|
|
PRSTAT(" Drone =", DRONE);
|
|
PRSTAT(" Turret =", ROTATEGUN);
|
|
PRSTAT(" Egg =", EGG);
|
|
|
|
x+=17;
|
|
yi=1;
|
|
PRSTAT("Slimer =", GREENSLIME);
|
|
PRSTAT("Boss1 =", BOSS1);
|
|
PrintStatus("MiniBoss1 =", multisprite[BOSS1], x, y+(yi++), multisprite[BOSS1]?11:7);
|
|
PRSTAT("Boss2 =", BOSS2);
|
|
PRSTAT("Boss3 =", BOSS3);
|
|
PRSTAT("Riot Tank =", TANK);
|
|
PRSTAT("Newbeast =", NEWBEAST);
|
|
PRSTAT("Boss4 =", BOSS4);
|
|
#undef PRSTAT
|
|
|
|
enddrawing(); //}}}
|
|
}
|
|
}
|
|
|
|
// formerly Show2dText and Show3dText
|
|
static void ShowFileText(const char *name)
|
|
{
|
|
int32_t fp,t, in3dmode=(qsetmode==200);
|
|
uint8_t x=0,y=4,xmax=0,xx=0,col=0;
|
|
|
|
if (!in3dmode)
|
|
{
|
|
clearmidstatbar16();
|
|
drawgradient();
|
|
}
|
|
|
|
if ((fp=kopen4load(name,0)) == -1)
|
|
{
|
|
Bsprintf(tempbuf, "ERROR: file \"%s\" not found.", name);
|
|
if (in3dmode)
|
|
printext256(1*4,4*8,whitecol,-1,tempbuf,0);
|
|
else
|
|
printext16(1*4,ydim-STATUS2DSIZ+4*8,editorcolors[11],-1,tempbuf,0);
|
|
return;
|
|
}
|
|
|
|
t=65;
|
|
begindrawing();
|
|
while (t!=EOF && col<5)
|
|
{
|
|
t = 0;
|
|
if (kread(fp,&t,1)<=0)
|
|
t = EOF;
|
|
while (t!=EOF && t!='\n' && x<250)
|
|
{
|
|
tempbuf[x]=t;
|
|
t = 0;
|
|
if (kread(fp,&t,1)<=0) t = EOF;
|
|
x++;
|
|
if (x>xmax) xmax=x;
|
|
}
|
|
tempbuf[x]=0;
|
|
|
|
if (in3dmode)
|
|
printext256(xx*4,(y*6)+2,whitecol,-1,tempbuf,1);
|
|
else
|
|
printext16(xx*4,ydim-STATUS2DSIZ+(y*6)+2,editorcolors[11],-1,tempbuf,1);
|
|
|
|
x=0;
|
|
y++;
|
|
if (y>18)
|
|
{
|
|
col++;
|
|
y=6;
|
|
xx+=xmax;
|
|
xmax=0;
|
|
}
|
|
}
|
|
enddrawing();
|
|
|
|
kclose(fp);
|
|
|
|
}
|
|
|
|
// PK_ vvvv
|
|
typedef struct helppage_
|
|
{
|
|
int32_t numlines;
|
|
char line[][80]; // C99 flexible array member
|
|
} helppage_t;
|
|
|
|
static helppage_t **helppage=NULL;
|
|
static int32_t numhelppages=0;
|
|
|
|
static int32_t emptyline(const char *start)
|
|
{
|
|
int32_t i;
|
|
for (i=0; i<80; i++)
|
|
{
|
|
if (start[i]=='\n' || !start[i]) break;
|
|
if (start[i]!=' ' && start[i]!='\t' && start[i]!='\r')
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int32_t newpage(const char *start)
|
|
{
|
|
int32_t i;
|
|
for (i=80-1; i>=0; i--)
|
|
{
|
|
if (start[i] == '^' && start[i+1] == 'P')
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
#define IHELP_INITPAGES 32
|
|
#define IHELP_INITLINES 16
|
|
|
|
static void ReadHelpFile(const char *name)
|
|
{
|
|
BFILE *fp;
|
|
int32_t i, j, k, numallocpages;
|
|
int32_t pos, charsread=0;
|
|
helppage_t *hp;
|
|
char skip=0;
|
|
|
|
initprintf("Loading \"%s\"\n",name);
|
|
|
|
if ((fp=fopenfrompath(name,"rb")) == NULL)
|
|
{
|
|
initprintf("Error initializing integrated help: file \"%s\" not found.\n", name);
|
|
return;
|
|
}
|
|
|
|
helppage=Bmalloc(IHELP_INITPAGES * sizeof(helppage_t *));
|
|
numallocpages=IHELP_INITPAGES;
|
|
if (!helppage) goto HELPFILE_ERROR;
|
|
|
|
i=0;
|
|
while (!Bfeof(fp) && !ferror(fp))
|
|
{
|
|
while (!Bfeof(fp)) // skip empty lines
|
|
{
|
|
pos = ftell(fp);
|
|
if (Bfgets(tempbuf, 80, fp) == NULL) break;
|
|
charsread = ftell(fp)-pos;
|
|
if (!newpage(tempbuf))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (Bfeof(fp) || charsread<=0) break;
|
|
|
|
hp=Bcalloc(1,sizeof(helppage_t) + IHELP_INITLINES*80);
|
|
if (!hp) goto HELPFILE_ERROR;
|
|
hp->numlines = IHELP_INITLINES;
|
|
|
|
if (charsread == 79 && tempbuf[78]!='\n') skip=1;
|
|
j=0;
|
|
|
|
do
|
|
{
|
|
if (j >= hp->numlines)
|
|
{
|
|
hp=Brealloc(hp, sizeof(helppage_t) + 2*hp->numlines*80);
|
|
if (!hp) goto HELPFILE_ERROR;
|
|
hp->numlines *= 2;
|
|
}
|
|
|
|
// limit the line length to 78 chars and probably get rid of the CR
|
|
if (charsread>0)
|
|
{
|
|
tempbuf[charsread-1]=0;
|
|
if (charsread>=2 && tempbuf[charsread-2]==0x0d)
|
|
tempbuf[charsread-2]=0;
|
|
}
|
|
|
|
Bmemcpy(hp->line[j], tempbuf, 80);
|
|
|
|
for (k=charsread; k<80; k++) hp->line[j][k]=0;
|
|
|
|
if (skip)
|
|
{
|
|
while (fgetc(fp)!='\n' && !Bfeof(fp)) /*skip rest of line*/;
|
|
skip=0;
|
|
}
|
|
|
|
pos = ftell(fp);
|
|
if (Bfgets(tempbuf, 80, fp) == NULL) break;
|
|
charsread = ftell(fp)-pos;
|
|
if (charsread == 79 && tempbuf[78]!='\n') skip=1;
|
|
|
|
j++;
|
|
|
|
}
|
|
while (!newpage(tempbuf) && !Bfeof(fp) && charsread>0);
|
|
|
|
hp=Brealloc(hp, sizeof(helppage_t) + j*80);
|
|
if (!hp) goto HELPFILE_ERROR;
|
|
hp->numlines=j;
|
|
|
|
if (i >= numallocpages)
|
|
{
|
|
helppage = Brealloc(helppage, 2*numallocpages*sizeof(helppage_t *));
|
|
numallocpages *= 2;
|
|
if (!helppage) goto HELPFILE_ERROR;
|
|
}
|
|
helppage[i] = hp;
|
|
i++;
|
|
}
|
|
|
|
helppage = Brealloc(helppage, i*sizeof(helppage_t *));
|
|
if (!helppage) goto HELPFILE_ERROR;
|
|
numhelppages = i;
|
|
|
|
Bfclose(fp);
|
|
return;
|
|
|
|
HELPFILE_ERROR:
|
|
Bfclose(fp);
|
|
initprintf("ReadHelpFile(): ERROR allocating memory.\n");
|
|
return;
|
|
}
|
|
|
|
// why can't MSVC allocate an array of variable size?!
|
|
#define IHELP_NUMDISPLINES 110 // ((overridepm16y>>4)+(overridepm16y>>5)+(overridepm16y>>7)-2)
|
|
#define IHELP_PATLEN 45
|
|
extern int32_t overridepm16y; // influences clearmidstatbar16()
|
|
|
|
static void IntegratedHelp(void)
|
|
{
|
|
if (!helppage) return;
|
|
|
|
overridepm16y = ydim;//3*STATUS2DSIZ;
|
|
|
|
{
|
|
int32_t i, j;
|
|
static int32_t curhp=0, curline=0;
|
|
int32_t highlighthp=-1, highlightline=-1, lasthighlighttime=0;
|
|
char disptext[IHELP_NUMDISPLINES][80];
|
|
char oldpattern[IHELP_PATLEN+1];
|
|
|
|
Bmemset(oldpattern, 0, sizeof(char));
|
|
// clearmidstatbar16();
|
|
|
|
begindrawing();
|
|
CLEARLINES2D(0, ydim, 0);
|
|
enddrawing();
|
|
|
|
while (keystatus[KEYSC_ESC]==0 && keystatus[KEYSC_Q]==0 && keystatus[KEYSC_F1]==0)
|
|
{
|
|
idle_waitevent();
|
|
if (handleevents())
|
|
quitevent = 0;
|
|
|
|
// printmessage16("Help mode, press <Esc> to exit");
|
|
|
|
if (keystatus[KEYSC_S])
|
|
{
|
|
fade_editor_screen(-1);
|
|
}
|
|
else
|
|
{
|
|
begindrawing();
|
|
CLEARLINES2D(0, ydim, 0);
|
|
enddrawing();
|
|
}
|
|
|
|
// based on 'save as' dialog in overheadeditor()
|
|
if (keystatus[KEYSC_S]) // text search
|
|
{
|
|
char ch, bad=0, pattern[IHELP_PATLEN+1];
|
|
|
|
for (i=0; i<IHELP_PATLEN+1; i++) pattern[i]=0;
|
|
|
|
i=0;
|
|
bflushchars();
|
|
while (bad == 0)
|
|
{
|
|
_printmessage16("Search: %s_", pattern);
|
|
showframe(1);
|
|
|
|
idle_waitevent();
|
|
|
|
if (handleevents())
|
|
quitevent = 0;
|
|
|
|
ch = bgetchar();
|
|
|
|
if (keystatus[1]) bad = 1;
|
|
else if (ch == 13) bad = 2;
|
|
else if (ch > 0)
|
|
{
|
|
if (i > 0 && (ch == 8 || ch == 127))
|
|
{
|
|
i--;
|
|
pattern[i] = 0;
|
|
}
|
|
else if (i < IHELP_PATLEN && ch >= 32 && ch < 128)
|
|
{
|
|
pattern[i++] = ch;
|
|
pattern[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bad==1)
|
|
{
|
|
keystatus[KEYSC_ESC] = keystatus[KEYSC_Q] = keystatus[KEYSC_F1] = 0;
|
|
}
|
|
|
|
if (bad==2)
|
|
{
|
|
keystatus[KEYSC_ENTER] = 0;
|
|
|
|
for (i=curhp; i<numhelppages; i++)
|
|
{
|
|
for (j = (i==curhp)?(curline+1):0; j<helppage[i]->numlines; j++)
|
|
{
|
|
// entering an empty pattern will search with the last used pattern
|
|
if (Bstrstr(helppage[i]->line[j], pattern[0]?pattern:oldpattern))
|
|
{
|
|
curhp = i;
|
|
|
|
if ((curline=j) <= helppage[i]->numlines - 32 /*-IHELP_NUMDISPLINES*/) /**/;
|
|
else if ((curline=helppage[i]->numlines- 32 /*-IHELP_NUMDISPLINES*/) >= 0) /**/;
|
|
else curline=0;
|
|
|
|
highlighthp = i;
|
|
highlightline = j;
|
|
lasthighlighttime = totalclock;
|
|
goto ENDFOR1;
|
|
}
|
|
}
|
|
}
|
|
ENDFOR1:
|
|
if (pattern[0])
|
|
Bmemcpy(oldpattern, pattern, IHELP_PATLEN+1);
|
|
}
|
|
}
|
|
else if (PRESSED_KEYSC(T)) // goto table of contents
|
|
{
|
|
curhp=0;
|
|
curline=0;
|
|
}
|
|
else if (PRESSED_KEYSC(G)) // goto arbitrary page
|
|
{
|
|
curhp=getnumber16("Goto page: ", 0, numhelppages-1, 0);
|
|
curline=0;
|
|
}
|
|
else if (PRESSED_KEYSC(UP)) // scroll up
|
|
{
|
|
if (curline>0) curline--;
|
|
}
|
|
else if (PRESSED_KEYSC(DOWN)) // scroll down
|
|
{
|
|
if (curline + 32/*+IHELP_NUMDISPLINES*/ < helppage[curhp]->numlines) curline++;
|
|
}
|
|
else if (PRESSED_KEYSC(PGUP)) // scroll one page up
|
|
{
|
|
i=IHELP_NUMDISPLINES;
|
|
while (i>0 && curline>0) i--, curline--;
|
|
}
|
|
else if (PRESSED_KEYSC(PGDN)) // scroll one page down
|
|
{
|
|
i=IHELP_NUMDISPLINES;
|
|
while (i>0 && curline + 32/*+IHELP_NUMDISPLINES*/ < helppage[curhp]->numlines) i--, curline++;
|
|
}
|
|
else if (PRESSED_KEYSC(SPACE)) // goto next paragraph
|
|
{
|
|
for (i=curline, j=0; i < helppage[curhp]->numlines; i++)
|
|
{
|
|
if (emptyline(helppage[curhp]->line[i])) { j=1; continue; }
|
|
if (j==1 && !emptyline(helppage[curhp]->line[i])) { j=2; break; }
|
|
}
|
|
if (j==2)
|
|
{
|
|
if (i + 32 /*+IHELP_NUMDISPLINES*/ < helppage[curhp]->numlines)
|
|
curline=i;
|
|
else if (helppage[curhp]->numlines - 32/*-IHELP_NUMDISPLINES*/ > curline)
|
|
curline = helppage[curhp]->numlines - 32/*-IHELP_NUMDISPLINES*/;
|
|
}
|
|
}
|
|
else if (PRESSED_KEYSC(BS)) // goto prev paragraph
|
|
{
|
|
for (i=curline-1, j=0; i>=0; i--)
|
|
{
|
|
if (!emptyline(helppage[curhp]->line[i])) { j=1; continue; }
|
|
if (j==1 && emptyline(helppage[curhp]->line[i])) { j=2; break; }
|
|
}
|
|
if (j==2 || i==-1) curline=i+1;
|
|
}
|
|
else if (PRESSED_KEYSC(HOME)) // goto beginning of page
|
|
{
|
|
curline=0;
|
|
}
|
|
else if (PRESSED_KEYSC(END)) // goto end of page
|
|
{
|
|
if ((curline=helppage[curhp]->numlines - 32/*-IHELP_NUMDISPLINES*/) >= 0) /**/;
|
|
else curline=0;
|
|
}
|
|
else if (PRESSED_KEYSC(LEFT) || PRESSED_KEYSC(LBRACK)) // prev page
|
|
{
|
|
if (curhp>0)
|
|
{
|
|
curhp--;
|
|
curline=0;
|
|
}
|
|
}
|
|
else if (PRESSED_KEYSC(RIGHT) || PRESSED_KEYSC(RBRACK)) // next page
|
|
{
|
|
if (curhp<numhelppages-1)
|
|
{
|
|
curhp++;
|
|
curline=0;
|
|
}
|
|
}
|
|
else // '1'-'0' on the upper row
|
|
{
|
|
for (i=2; i<=11; i++)
|
|
if (keystatus[i]) break;
|
|
if (i--<12 && i<numhelppages)
|
|
{
|
|
curhp=i;
|
|
curline=0;
|
|
}
|
|
}
|
|
|
|
// drawgradient();
|
|
|
|
begindrawing();
|
|
printext16(9, ydim2d-overridepm16y+9, editorcolors[4], -1, "Help Mode", 0);
|
|
printext16(8, ydim2d-overridepm16y+8, editorcolors[12], -1, "Help Mode", 0);
|
|
printext16(8 + 9*8 + 2*8, ydim2d-overridepm16y+8, editorcolors[15], -1, "(S:search)", 0);
|
|
enddrawing();
|
|
|
|
if (curhp < helppage[0]->numlines)
|
|
_printmessage16("%s", helppage[0]->line[curhp]);
|
|
else
|
|
_printmessage16("%d. (Untitled page)", curhp);
|
|
|
|
for (i=0; j=(curhp==0)?(i+curline+1):(i+curline),
|
|
i<IHELP_NUMDISPLINES && j<helppage[curhp]->numlines; i++)
|
|
{
|
|
if (ydim-overridepm16y+28+i*9+32 >= ydim)
|
|
break;
|
|
Bmemcpy(disptext[i], helppage[curhp]->line[j], 80);
|
|
printext16(8, ydim-overridepm16y+28+i*9, editorcolors[10],
|
|
(j==highlightline && curhp==highlighthp
|
|
&& totalclock-lasthighlighttime<120*5) ?
|
|
editorcolors[1] : -1,
|
|
disptext[i], 0);
|
|
}
|
|
|
|
showframe(1);
|
|
}
|
|
|
|
clearkeys();
|
|
}
|
|
|
|
overridepm16y = -1;
|
|
}
|
|
|
|
#define SOUND_NUMDISPLINES IHELP_NUMDISPLINES
|
|
|
|
static int32_t compare_sounds_s(int16_t k1, int16_t k2)
|
|
{
|
|
return (int32_t)k1 - (int32_t)k2;
|
|
}
|
|
static int32_t compare_sounds_d(int16_t k1, int16_t k2)
|
|
{
|
|
sound_t *s1 = &g_sounds[k1], *s2 = &g_sounds[k2];
|
|
char *n1 = s1->definedname, *n2 = s2->definedname;
|
|
|
|
if (!n1 && !n2) return 0;
|
|
if (!n1) return -1;
|
|
if (!n2) return 1;
|
|
return Bstrcasecmp(n1, n2);
|
|
}
|
|
static int32_t compare_sounds_f(int16_t k1, int16_t k2)
|
|
{
|
|
sound_t *s1 = &g_sounds[k1], *s2 = &g_sounds[k2];
|
|
char *n1 = s1->filename, *n2 = s2->filename;
|
|
|
|
if (!n1 && !n2) return 0;
|
|
if (!n1) return -1;
|
|
if (!n2) return 1;
|
|
return Bstrcasecmp(n1, n2);
|
|
}
|
|
static int32_t compare_sounds_1(int16_t k1, int16_t k2)
|
|
{
|
|
return (g_sounds[k2].m&1) - (g_sounds[k1].m&1);
|
|
}
|
|
static int32_t compare_sounds_2(int16_t k1, int16_t k2)
|
|
{
|
|
return (g_sounds[k2].m&2) - (g_sounds[k1].m&2);
|
|
}
|
|
static int32_t compare_sounds_3(int16_t k1, int16_t k2)
|
|
{
|
|
return (g_sounds[k2].m&4) - (g_sounds[k1].m&4);
|
|
}
|
|
static int32_t compare_sounds_4(int16_t k1, int16_t k2)
|
|
{
|
|
return (g_sounds[k2].m&8) - (g_sounds[k1].m&8);
|
|
}
|
|
static int32_t compare_sounds_5(int16_t k1, int16_t k2)
|
|
{
|
|
return (g_sounds[k2].m&16) - (g_sounds[k1].m&16);
|
|
}
|
|
|
|
|
|
static int32_t sort_sounds(int32_t how)
|
|
{
|
|
int32_t (*compare_sounds)(int16_t, int16_t) = NULL;
|
|
|
|
int32_t ms, ofs, l, lb, r, rb, d, n, k1, k2;
|
|
int16_t *src, *dst, *source, *dest, *tmp;
|
|
|
|
n = g_numsounds;
|
|
src = source = g_sndnum;
|
|
dest = Bmalloc(sizeof(int16_t) * n);
|
|
dst = dest;
|
|
if (!dest) return -1;
|
|
|
|
switch (how)
|
|
{
|
|
case 'g': // restore original order
|
|
Bmemcpy(g_sndnum, g_definedsndnum, sizeof(int16_t)*n);
|
|
return 0;
|
|
case 's':
|
|
compare_sounds = compare_sounds_s;
|
|
break;
|
|
case 'd':
|
|
compare_sounds = compare_sounds_d;
|
|
break;
|
|
case 'f':
|
|
compare_sounds = compare_sounds_f;
|
|
break;
|
|
case '1':
|
|
compare_sounds = compare_sounds_1;
|
|
break;
|
|
case '2':
|
|
compare_sounds = compare_sounds_2;
|
|
break;
|
|
case '3':
|
|
compare_sounds = compare_sounds_3;
|
|
break;
|
|
case '4':
|
|
compare_sounds = compare_sounds_4;
|
|
break;
|
|
case '5':
|
|
compare_sounds = compare_sounds_5;
|
|
break;
|
|
default:
|
|
return -2;
|
|
}
|
|
|
|
for (ms=1; ms<n; ms*=2)
|
|
{
|
|
for (ofs=0; ofs<n; ofs+=2*ms)
|
|
{
|
|
l = ofs;
|
|
r = ofs+ms;
|
|
d = ofs;
|
|
lb = min((l+ms), n);
|
|
rb = min((r+ms), n);
|
|
while (l < lb || r < rb)
|
|
{
|
|
if (l >= lb)
|
|
{
|
|
dst[d++] = src[r++];
|
|
continue;
|
|
}
|
|
if (r >= rb)
|
|
{
|
|
dst[d++] = src[l++];
|
|
continue;
|
|
}
|
|
k1 = src[l];
|
|
k2 = src[r];
|
|
if (compare_sounds(k1, k2) <= 0)
|
|
{
|
|
dst[d++] = src[l++];
|
|
continue;
|
|
}
|
|
dst[d++] = src[r++];
|
|
}
|
|
}
|
|
tmp = src;
|
|
src = dst;
|
|
dst = tmp;
|
|
}
|
|
if (src != source)
|
|
Bmemcpy(source, src, sizeof(int16_t) * n);
|
|
|
|
Bfree(dest);
|
|
return 0;
|
|
}
|
|
|
|
static void SoundDisplay(void)
|
|
{
|
|
if (g_numsounds <= 0) return;
|
|
|
|
overridepm16y = ydim;//3*STATUS2DSIZ;
|
|
|
|
{
|
|
// cursnd is the first displayed line, cursnd+curofs is where the cursor is
|
|
static int32_t cursnd=0, curofs=0;
|
|
char disptext[80];
|
|
|
|
int32_t i, j;
|
|
const int32_t halfpage = (ydim-64)/(2*9);
|
|
|
|
while (keystatus[KEYSC_ESC]==0 && keystatus[KEYSC_Q]==0 && keystatus[KEYSC_F2]==0
|
|
&& keystatus[buildkeys[BK_MODE2D_3D]]==0) // quickjump to 3d mode
|
|
{
|
|
begindrawing();
|
|
CLEARLINES2D(0, ydim16, 0);
|
|
enddrawing();
|
|
|
|
idle_waitevent();
|
|
if (handleevents())
|
|
quitevent = 0;
|
|
|
|
// drawgradient();
|
|
|
|
begindrawing();
|
|
printext16(9, ydim2d-overridepm16y+9, editorcolors[4], -1, "Sound Index", 0);
|
|
printext16(8, ydim2d-overridepm16y+8, editorcolors[12], -1, "Sound Index", 0);
|
|
printext16(8 + 11*8 + 2*8, ydim2d-overridepm16y+8, editorcolors[15], -1, "(SPACE:play, S:sort)", 0);
|
|
enddrawing();
|
|
|
|
if (PRESSED_KEYSC(G)) // goto specified sound#
|
|
{
|
|
_printmessage16(" ");
|
|
j = getnumber16("Goto sound#: ", 0, g_numsounds-1, 0);
|
|
for (i=0; i<g_numsounds; i++)
|
|
if (g_sndnum[i]==j)
|
|
break;
|
|
if (i != g_numsounds)
|
|
{
|
|
if (i<SOUND_NUMDISPLINES)
|
|
cursnd = 0, curofs = i;
|
|
else if (i>=g_numsounds-halfpage)
|
|
cursnd = g_numsounds-halfpage, curofs = i-cursnd;
|
|
else
|
|
curofs = halfpage/2, cursnd = i-curofs;
|
|
}
|
|
}
|
|
else if (PRESSED_KEYSC(UP)) // scroll up
|
|
{
|
|
if (curofs>0) curofs--;
|
|
else if (cursnd>0) cursnd--;
|
|
}
|
|
else if (PRESSED_KEYSC(DOWN)) // scroll down
|
|
{
|
|
if (curofs < halfpage-1 && cursnd+curofs<g_numsounds-1)
|
|
curofs++;
|
|
else if (cursnd + halfpage < g_numsounds)
|
|
cursnd++;
|
|
}
|
|
else if (PRESSED_KEYSC(PGUP)) // scroll one page up
|
|
{
|
|
i = halfpage/2;
|
|
|
|
while (i>0 && curofs>0)
|
|
i--, curofs--;
|
|
while (i>0 && cursnd>0)
|
|
i--, cursnd--;
|
|
}
|
|
else if (PRESSED_KEYSC(PGDN)) // scroll one page down
|
|
{
|
|
i = halfpage/2;
|
|
|
|
while (i>0 && curofs < halfpage-1 && cursnd+curofs<g_numsounds-1)
|
|
i--, curofs++;
|
|
while (i>0 && cursnd + halfpage < g_numsounds)
|
|
i--, cursnd++;
|
|
}
|
|
else if (PRESSED_KEYSC(SPACE) || PRESSED_KEYSC(ENTER)) // play/stop sound
|
|
{
|
|
int32_t j = cursnd+curofs;
|
|
int32_t k = g_sndnum[j];
|
|
|
|
if (S_CheckSoundPlaying(0, k) > 0)
|
|
S_StopSound(k);
|
|
else
|
|
S_PlaySound(k);
|
|
}
|
|
else if (PRESSED_KEYSC(HOME)) // goto first sound#
|
|
{
|
|
cursnd = curofs = 0;
|
|
}
|
|
else if (PRESSED_KEYSC(END)) // goto last sound#
|
|
{
|
|
if ((cursnd = g_numsounds - halfpage) >= 0)
|
|
curofs = halfpage-1;
|
|
else
|
|
{
|
|
cursnd = 0;
|
|
curofs = g_numsounds-1;
|
|
}
|
|
}
|
|
|
|
_printmessage16(" FILE NAME PITCH RANGE PRI FLAGS VOLUME");
|
|
for (i=0; j=cursnd+i, i<SOUND_NUMDISPLINES && j<g_numsounds; i++)
|
|
{
|
|
int32_t l, m, k=g_sndnum[j];
|
|
sound_t *snd=&g_sounds[k];
|
|
char *cp;
|
|
|
|
if (ydim-overridepm16y+28+i*9+32 >= ydim) break;
|
|
|
|
Bsprintf(disptext,
|
|
"%4d .................... ................ %6d:%-6d %3d %c%c%c%c%c %6d",
|
|
// 5678901234567890X23456789012345678901234567
|
|
k, snd->ps, snd->pe, snd->pr,
|
|
snd->m&1 ? 'R':'-', snd->m&2 ? 'M':'-', snd->m&4 ? 'D':'-',
|
|
snd->m&8 ? 'P':'-', snd->m&16 ? 'G':'-', snd->vo);
|
|
for (l = Bsnprintf(disptext+5, 20, "%s", snd->definedname); l<20; l++)
|
|
disptext[5+l] = ' ';
|
|
if (snd->filename)
|
|
{
|
|
l = Bstrlen(snd->filename);
|
|
if (l<=16)
|
|
cp = snd->filename;
|
|
else
|
|
cp = snd->filename + l-15;
|
|
for (m = Bsnprintf(disptext+26, 16, "%s", cp); m<16; m++)
|
|
disptext[26+m] = ' ';
|
|
if (l>16)
|
|
disptext[26] = disptext[27] = disptext[28] = '.';
|
|
}
|
|
|
|
printext16(8, ydim-overridepm16y+28+i*9,
|
|
keystatus[KEYSC_S]?editorcolors[8] : (S_CheckSoundPlaying(-1, k) ? editorcolors[2] : editorcolors[10]),
|
|
j==cursnd+curofs ? editorcolors[1] : -1,
|
|
disptext, 0);
|
|
}
|
|
|
|
if (keystatus[KEYSC_S]) // sorting
|
|
{
|
|
|
|
char ch, bad=0;
|
|
|
|
_printmessage16("Sort by: (S)oundnum (D)ef (F)ile ori(g) or flags (12345)");
|
|
showframe(1);
|
|
|
|
i=0;
|
|
bflushchars();
|
|
while (bad == 0)
|
|
{
|
|
idle_waitevent();
|
|
if (handleevents())
|
|
quitevent = 0;
|
|
|
|
ch = bgetchar();
|
|
|
|
if (keystatus[1]) bad = 1;
|
|
|
|
else if (ch == 's' || ch == 'd' || ch == 'f' || ch == 'g' ||
|
|
ch == '1' || ch == '2' || ch == '3' || ch == '4' || ch == '5')
|
|
{
|
|
bad = 2;
|
|
sort_sounds(ch);
|
|
}
|
|
}
|
|
|
|
clearkeys();
|
|
}
|
|
else
|
|
showframe(1);
|
|
}
|
|
|
|
overridepm16y = -1;
|
|
|
|
FX_StopAllSounds();
|
|
S_ClearSoundLocks();
|
|
|
|
clearkeys();
|
|
}
|
|
}
|
|
// PK_ ^^^^
|
|
|
|
// from sector.c
|
|
static int32_t dist(spritetype *s1,spritetype *s2)
|
|
{
|
|
int32_t x = klabs(s1->x-s2->x);
|
|
int32_t y = klabs(s1->y-s2->y);
|
|
int32_t z = klabs((s1->z-s2->z)>>4);
|
|
|
|
if (x<y) swaplong(&x,&y);
|
|
if (x<z) swaplong(&x,&z);
|
|
|
|
{
|
|
int32_t t = y + z;
|
|
return (x - (x>>4) + (t>>2) + (t>>3));
|
|
}
|
|
}
|
|
|
|
int32_t AmbienceToggle = 1;
|
|
int32_t ParentalLock = 0;
|
|
#undef T1
|
|
#define T1 (s->filler)
|
|
|
|
// adapted from actors.c
|
|
static void M32_MoveFX(void)
|
|
{
|
|
int32_t i, j;
|
|
int32_t x, ht;
|
|
spritetype *s;
|
|
|
|
for (i=headspritestat[0]; i>=0; i=nextspritestat[i])
|
|
{
|
|
s = &sprite[i];
|
|
|
|
if (s->picnum != MUSICANDSFX)
|
|
{
|
|
if (T1&1)
|
|
{
|
|
T1 &= (~1);
|
|
S_StopEnvSound(s->lotag, i);
|
|
}
|
|
}
|
|
else if (s->sectnum>=0)
|
|
{
|
|
ht = s->hitag;
|
|
|
|
if (s->lotag < 999 && (unsigned)sector[s->sectnum].lotag < 9 &&
|
|
AmbienceToggle && sector[s->sectnum].floorz != sector[s->sectnum].ceilingz)
|
|
{
|
|
if ((g_sounds[s->lotag].m&2))
|
|
{
|
|
x = dist((spritetype *)&pos,s);
|
|
if (x < ht && (T1&1) == 0 && FX_VoiceAvailable(g_sounds[s->lotag].pr-1))
|
|
{
|
|
if (g_numEnvSoundsPlaying == NumVoices)
|
|
{
|
|
for (j = headspritestat[0]; j >= 0; j = nextspritestat[j])
|
|
{
|
|
if (s->picnum == MUSICANDSFX && j != i && sprite[j].lotag < 999 &&
|
|
(sprite[j].filler&1) == 1 && dist(&sprite[j],(spritetype *)&pos) > x)
|
|
{
|
|
S_StopEnvSound(sprite[j].lotag,j);
|
|
break;
|
|
}
|
|
|
|
}
|
|
if (j == -1) continue;
|
|
}
|
|
A_PlaySound(s->lotag,i);
|
|
T1 |= 1;
|
|
}
|
|
if (x >= ht && (T1&1) == 1)
|
|
{
|
|
T1 &= (~1);
|
|
S_StopEnvSound(s->lotag,i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#undef T1
|
|
|
|
|
|
///__ShowHelpText__
|
|
|
|
void ExtShowSpriteData(int16_t spritenum) //F6
|
|
{
|
|
UNREFERENCED_PARAMETER(spritenum);
|
|
if (qsetmode != 200)
|
|
ShowFileText("sehelp.hlp");
|
|
}
|
|
|
|
// Floor Over Floor (duke3d)
|
|
|
|
// If standing in sector with SE42 or SE44
|
|
// then draw viewing to SE41 and raise all =hi SE43 cielings.
|
|
|
|
// If standing in sector with SE43 or SE45
|
|
// then draw viewing to SE40 and lower all =hi SE42 floors.
|
|
|
|
static int32_t fofsizex = -1;
|
|
static int32_t fofsizey = -1;
|
|
#if 0
|
|
static void ResetFOFSize(void)
|
|
{
|
|
if (fofsizex != -1) tilesizx[FOF] = fofsizex;
|
|
if (fofsizey != -1) tilesizy[FOF] = fofsizey;
|
|
}
|
|
#endif
|
|
static void ExtSE40Draw(int32_t spnum,int32_t x,int32_t y,int32_t z,int16_t a,int16_t h)
|
|
{
|
|
static int32_t tempsectorz[MAXSECTORS];
|
|
static int32_t tempsectorpicnum[MAXSECTORS];
|
|
|
|
int32_t j=0,k=0;
|
|
int32_t floor1=0,floor2=0,ok=0,fofmode=0,draw_both=0;
|
|
int32_t offx,offy,offz;
|
|
|
|
if (sprite[spnum].ang!=512) return;
|
|
|
|
// Things are a little different now, as we allow for masked transparent
|
|
// floors and ceilings. So the FOF textures is no longer required
|
|
// if (!(gotpic[FOF>>3]&(1<<(FOF&7))))
|
|
// return;
|
|
// gotpic[FOF>>3] &= ~(1<<(FOF&7));
|
|
|
|
if (tilesizx[562])
|
|
{
|
|
fofsizex = tilesizx[562];
|
|
tilesizx[562] = 0;
|
|
}
|
|
if (tilesizy[562])
|
|
{
|
|
fofsizey = tilesizy[562];
|
|
tilesizy[562] = 0;
|
|
}
|
|
|
|
floor1=spnum;
|
|
|
|
if (sprite[spnum].lotag==42) fofmode=40;
|
|
if (sprite[spnum].lotag==43) fofmode=41;
|
|
if (sprite[spnum].lotag==44) fofmode=40;
|
|
if (sprite[spnum].lotag==45) fofmode=41;
|
|
|
|
// fofmode=sprite[spnum].lotag-2;
|
|
|
|
// sectnum=sprite[j].sectnum;
|
|
// sectnum=cursectnum;
|
|
ok++;
|
|
|
|
/* recursive?
|
|
for(j=0;j<MAXSPRITES;j++)
|
|
{
|
|
if(
|
|
sprite[j].sectnum==sectnum &&
|
|
sprite[j].picnum==1 &&
|
|
sprite[j].lotag==110
|
|
) { DrawFloorOverFloor(j); break;}
|
|
}
|
|
*/
|
|
|
|
// if(ok==0) { Message("no fof",RED); return; }
|
|
|
|
for (j=0; j<MAXSPRITES; j++)
|
|
{
|
|
if (sprite[j].picnum==1 && sprite[j].lotag==fofmode && sprite[j].hitag==sprite[floor1].hitag)
|
|
{
|
|
floor1=j;
|
|
fofmode=sprite[j].lotag;
|
|
ok++;
|
|
break;
|
|
}
|
|
}
|
|
// if(ok==1) { Message("no floor1",RED); return; }
|
|
|
|
if (fofmode==40) k=41;
|
|
else k=40;
|
|
|
|
for (j=0; j<MAXSPRITES; j++)
|
|
{
|
|
if (sprite[j].picnum==1 && sprite[j].lotag==k && sprite[j].hitag==sprite[floor1].hitag)
|
|
{
|
|
floor2=j;
|
|
ok++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// i=floor1;
|
|
offx=sprite[floor2].x-sprite[floor1].x;
|
|
offy=sprite[floor2].y-sprite[floor1].y;
|
|
offz=0;
|
|
|
|
if (sprite[floor2].ang >= 1024)
|
|
offz = sprite[floor2].z;
|
|
else if (fofmode==41)
|
|
offz = SPRITESEC(floor2).floorz;
|
|
else
|
|
offz = SPRITESEC(floor2).ceilingz;
|
|
|
|
if (sprite[floor1].ang >= 1024)
|
|
offz -= sprite[floor1].z;
|
|
else if (fofmode==40)
|
|
offz -= SPRITESEC(floor1).floorz;
|
|
else
|
|
offz -= SPRITESEC(floor1).ceilingz;
|
|
|
|
// if(ok==2) { Message("no floor2",RED); return; }
|
|
|
|
for (j=0; j<MAXSPRITES; j++) // raise ceiling or floor
|
|
{
|
|
if (sprite[j].picnum==1 && sprite[j].lotag==k+2 && sprite[j].hitag==sprite[floor1].hitag)
|
|
{
|
|
if (k==40)
|
|
{
|
|
tempsectorz[sprite[j].sectnum] = SPRITESEC(j).floorz;
|
|
SPRITESEC(j).floorz += (((z-SPRITESEC(j).floorz)/32768)+1)*32768;
|
|
tempsectorpicnum[sprite[j].sectnum] = SPRITESEC(j).floorpicnum;
|
|
SPRITESEC(j).floorpicnum = 562;
|
|
}
|
|
else
|
|
{
|
|
tempsectorz[sprite[j].sectnum] = SPRITESEC(j).ceilingz;
|
|
SPRITESEC(j).ceilingz += (((z-SPRITESEC(j).ceilingz)/32768)-1)*32768;
|
|
tempsectorpicnum[sprite[j].sectnum] = SPRITESEC(j).ceilingpicnum;
|
|
SPRITESEC(j).ceilingpicnum = 562;
|
|
}
|
|
draw_both = 1;
|
|
}
|
|
}
|
|
|
|
drawrooms(x+offx,y+offy,z+offz,a,h,sprite[floor2].sectnum);
|
|
ExtAnalyzeSprites();
|
|
drawmasks();
|
|
M32_ResetFakeRORTiles();
|
|
|
|
if (draw_both)
|
|
{
|
|
for (j=0; j<MAXSPRITES; j++) // restore ceiling or floor for the draw both sectors
|
|
{
|
|
if (sprite[j].picnum==SECTOREFFECTOR &&
|
|
sprite[j].lotag==k+2 && sprite[j].hitag==sprite[floor1].hitag)
|
|
{
|
|
if (k==40)
|
|
{
|
|
SPRITESEC(j).floorz = tempsectorz[sprite[j].sectnum];
|
|
SPRITESEC(j).floorpicnum = tempsectorpicnum[sprite[j].sectnum];
|
|
}
|
|
else
|
|
{
|
|
SPRITESEC(j).ceilingz = tempsectorz[sprite[j].sectnum];
|
|
SPRITESEC(j).ceilingpicnum = tempsectorpicnum[sprite[j].sectnum];
|
|
}
|
|
}// end if
|
|
}// end for
|
|
|
|
// Now re-draw
|
|
drawrooms(x+offx,y+offy,z+offz,a,h,sprite[floor2].sectnum);
|
|
ExtAnalyzeSprites();
|
|
drawmasks();
|
|
M32_ResetFakeRORTiles();
|
|
}
|
|
|
|
} // end SE40
|
|
|
|
static void SE40Code(int32_t x,int32_t y,int32_t z,int32_t a,int32_t h)
|
|
{
|
|
int32_t i;
|
|
|
|
i = 0;
|
|
while (i<MAXSPRITES)
|
|
{
|
|
int32_t t = sprite[i].lotag;
|
|
switch (t)
|
|
{
|
|
// case 40:
|
|
// case 41:
|
|
// ExtSE40Draw(i,x,y,z,a,h);
|
|
// break;
|
|
case 42:
|
|
case 43:
|
|
case 44:
|
|
case 45:
|
|
if (cursectnum == sprite[i].sectnum)
|
|
ExtSE40Draw(i,x,y,z,a,h);
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
void ExtEditSectorData(int16_t sectnum) //F7
|
|
{
|
|
if (qsetmode == 200)
|
|
return;
|
|
|
|
if (eitherALT) //ALT
|
|
{
|
|
keystatus[KEYSC_F7] = 0;
|
|
wallsprite=0;
|
|
curwall = 0;
|
|
curwallnum = 0;
|
|
cursearchspritenum = 0;
|
|
cursectornum=0;
|
|
cursector_lotag = sector[sectnum].lotag;
|
|
cursector_lotag = getnumber16("Enter search sector lotag : ", cursector_lotag, BTAG_MAX,0);
|
|
_printmessage16("Search sector lotag %d",cursector_lotag);
|
|
}
|
|
else EditSectorData(sectnum);
|
|
}// end ExtEditSectorData
|
|
|
|
void ExtEditWallData(int16_t wallnum) //F8
|
|
{
|
|
if (qsetmode==200)
|
|
return;
|
|
|
|
if (eitherALT) //ALT
|
|
{
|
|
wallsprite=1;
|
|
curwall = wallnum;
|
|
curwallnum = 0;
|
|
cursearchspritenum = 0;
|
|
cursectornum = 0;
|
|
search_lotag = wall[curwall].lotag;
|
|
search_hitag = wall[curwall].hitag;
|
|
search_lotag = getnumber16("Enter wall search lotag : ", search_lotag, BTAG_MAX,0);
|
|
search_hitag = getnumber16("Enter wall search hitag : ", search_hitag, BTAG_MAX,0);
|
|
// Bsprintf(tempbuf,"Current wall %d lo=%d hi=%d",
|
|
// curwall,wall[curwall].lotag,wall[curwall].hitag);
|
|
_printmessage16("Search wall lo=%d hi=%d",search_lotag,search_hitag);
|
|
}
|
|
else EditWallData(wallnum);
|
|
}
|
|
|
|
static void GenericSpriteSearch(void);
|
|
|
|
void ExtEditSpriteData(int16_t spritenum) //F8
|
|
{
|
|
if (qsetmode==200)
|
|
return;
|
|
|
|
if (eitherALT) //ALT
|
|
GenericSpriteSearch();
|
|
#if 0
|
|
{
|
|
wallsprite=2;
|
|
cursearchsprite = spritenum;
|
|
curwallnum = 0;
|
|
cursearchspritenum = 0;
|
|
cursectornum = 0;
|
|
search_lotag = sprite[cursearchsprite].lotag;
|
|
search_hitag = sprite[cursearchsprite].hitag;
|
|
search_lotag = getnumber16("Enter sprite search lotag : ", search_lotag, BTAG_MAX,0);
|
|
search_hitag = getnumber16("Enter sprite search hitag : ", search_hitag, BTAG_MAX,0);
|
|
printmessage16("Search sprite lo=%d hi=%d",search_lotag,search_hitag);
|
|
}
|
|
#endif
|
|
else EditSpriteData(spritenum);
|
|
}
|
|
|
|
static inline void SpriteName(int16_t spritenum, char *lo2)
|
|
{
|
|
Bstrcpy(lo2, names[sprite[spritenum].picnum]);
|
|
}// end SpriteName
|
|
|
|
static void ReadPaletteTable(void)
|
|
{
|
|
int32_t i,j,fp;
|
|
char lookup_num;
|
|
|
|
for (j = 0; j < 256; j++)
|
|
tempbuf[j] = j;
|
|
|
|
for (i=1; i<MAXPALOOKUPS; i++)
|
|
makepalookup(i,tempbuf,0,0,0,1);
|
|
|
|
if ((fp=kopen4load("lookup.dat",0)) == -1)
|
|
{
|
|
if ((fp=kopen4load("lookup.dat",1)) == -1)
|
|
{
|
|
initprintf("LOOKUP.DAT not found\n");
|
|
return;
|
|
}
|
|
}
|
|
// initprintf("Loading palette lookups... ");
|
|
kread(fp,&num_tables,1);
|
|
for (j=0; j<num_tables; j++)
|
|
{
|
|
kread(fp,&lookup_num,1);
|
|
kread(fp,tempbuf,256);
|
|
makepalookup(lookup_num,tempbuf,0,0,0,1);
|
|
}
|
|
for (j = 0; j < 256; j++)
|
|
tempbuf[j] = j;
|
|
|
|
num_tables++;
|
|
makepalookup(num_tables, tempbuf, 15, 15, 15, 1);
|
|
makepalookup(num_tables + 1, tempbuf, 15, 0, 0, 1);
|
|
makepalookup(num_tables + 2, tempbuf, 0, 15, 0, 1);
|
|
makepalookup(num_tables + 3, tempbuf, 0, 0, 15, 1);
|
|
|
|
kread(fp,WATERpalette,768);
|
|
kread(fp,SLIMEpalette,768);
|
|
kread(fp,TITLEpalette,768);
|
|
kread(fp,REALMSpalette,768);
|
|
kread(fp,BOSS1palette,768);
|
|
kclose(fp);
|
|
// initprintf("success.\n");
|
|
}// end ReadPaletteTable
|
|
|
|
|
|
static void m32_showmouse(void)
|
|
{
|
|
int32_t i, col;
|
|
|
|
if (totalclock > lastupdate)
|
|
{
|
|
mousecol += mouseadd;
|
|
if (mousecol >= 30 || mousecol <= 0)
|
|
{
|
|
mouseadd = -mouseadd;
|
|
mousecol += mouseadd;
|
|
}
|
|
lastupdate = totalclock + 3;
|
|
}
|
|
|
|
switch (whitecol)
|
|
{
|
|
case 1: // Shadow Warrior
|
|
col = whitecol+mousecol;
|
|
break;
|
|
case 31: // Duke Nukem 3D
|
|
col = whitecol-mousecol;
|
|
break;
|
|
default:
|
|
col = whitecol;
|
|
break;
|
|
}
|
|
|
|
if (col != whitecol)
|
|
{
|
|
for (i=((xdim > 640)?3:2); i<=((xdim > 640)?7:3); i++)
|
|
{
|
|
plotpixel(searchx+i,searchy,col);
|
|
plotpixel(searchx-i,searchy,col);
|
|
plotpixel(searchx,searchy-i,col);
|
|
plotpixel(searchx,searchy+i,col);
|
|
}
|
|
|
|
for (i=1; i<=((xdim > 640)?2:1); i++)
|
|
{
|
|
plotpixel(searchx+i,searchy,whitecol);
|
|
plotpixel(searchx-i,searchy,whitecol);
|
|
plotpixel(searchx,searchy-i,whitecol);
|
|
plotpixel(searchx,searchy+i,whitecol);
|
|
}
|
|
|
|
i = (xdim > 640)?8:4;
|
|
|
|
plotpixel(searchx+i,searchy,0);
|
|
plotpixel(searchx-i,searchy,0);
|
|
plotpixel(searchx,searchy-i,0);
|
|
plotpixel(searchx,searchy+i,0);
|
|
}
|
|
|
|
if (xdim > 640)
|
|
{
|
|
for (i=1; i<=4; i++)
|
|
{
|
|
plotpixel(searchx+i,searchy,whitecol);
|
|
plotpixel(searchx-i,searchy,whitecol);
|
|
plotpixel(searchx,searchy-i,whitecol);
|
|
plotpixel(searchx,searchy+i,whitecol);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int32_t AskIfSure(const char *text)
|
|
{
|
|
int32_t retval=1;
|
|
|
|
if (qsetmode == 200)
|
|
{
|
|
begindrawing(); //{{{
|
|
printext256(0,0,whitecol,0,text?text:"Are you sure you want to proceed?",0);
|
|
enddrawing(); //}}}
|
|
}
|
|
else
|
|
{
|
|
_printmessage16("%s", text?text:"Are you sure you want to proceed?");
|
|
}
|
|
|
|
showframe(1);
|
|
|
|
while ((keystatus[KEYSC_ESC]|keystatus[KEYSC_ENTER]|keystatus[KEYSC_SPACE]|keystatus[KEYSC_N]) == 0)
|
|
{
|
|
idle_waitevent();
|
|
|
|
if (handleevents())
|
|
{
|
|
if (quitevent)
|
|
{
|
|
retval = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(Y) || PRESSED_KEYSC(ENTER))
|
|
{
|
|
retval = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(ESC))
|
|
retval = 1;
|
|
|
|
return(retval);
|
|
}
|
|
|
|
static int32_t IsValidTile(int32_t idTile)
|
|
{
|
|
return (idTile>=0 && idTile<MAXTILES) && (tilesizx[idTile] && tilesizy[idTile]);
|
|
}
|
|
|
|
static int32_t SelectAllTiles(int32_t iCurrentTile)
|
|
{
|
|
int32_t i;
|
|
|
|
if (iCurrentTile < localartlookupnum)
|
|
iCurrentTile = localartlookup[iCurrentTile];
|
|
else
|
|
iCurrentTile = 0;
|
|
|
|
localartlookupnum = MAXTILES;
|
|
|
|
for (i = 0; i < MAXTILES; i++)
|
|
{
|
|
localartlookup[i] = i;
|
|
localartfreq[i] = 0;
|
|
}
|
|
|
|
return iCurrentTile;
|
|
}
|
|
|
|
static int32_t OnGotoTile(int32_t iTile);
|
|
static int32_t OnSelectTile(int32_t iTile);
|
|
static int32_t OnSaveTileGroup();
|
|
static int32_t loadtilegroups(const char *fn);
|
|
static int32_t s_Zoom = INITIAL_ZOOM;
|
|
static int32_t s_TileZoom = 1;
|
|
static char tilesel_errmsg[128], tilesel_showerr=0;
|
|
|
|
static int32_t DrawTiles(int32_t iTopLeft, int32_t iSelected, int32_t nXTiles, int32_t nYTiles,
|
|
int32_t TileDim, int32_t offset, int32_t showmsg);
|
|
|
|
#define TMPERRMSG_SHOW(alsoOSD) do { \
|
|
printext256(0, 0, whitecol, 0, tilesel_errmsg, 0); \
|
|
if (alsoOSD) OSD_Printf("%s\n", tilesel_errmsg); \
|
|
} while (0)
|
|
|
|
#define TMPERRMSG_PRINT(Msg, ...) do { \
|
|
Bsprintf(tilesel_errmsg, Msg, ## __VA_ARGS__); \
|
|
TMPERRMSG_SHOW(1); \
|
|
showframe(1); \
|
|
tilesel_showerr = 1; \
|
|
} while (0)
|
|
|
|
#define TMPERRMSG_RETURN(Msg, ...) do \
|
|
{ \
|
|
TMPERRMSG_PRINT(Msg, ## __VA_ARGS__); \
|
|
return 1; \
|
|
} while (0)
|
|
|
|
|
|
static int32_t m32gettile(int32_t idInitialTile)
|
|
{
|
|
int32_t gap, temp, zoomsz;
|
|
int32_t nXTiles, nYTiles, nDisplayedTiles;
|
|
int32_t i;
|
|
int32_t iTile, iTopLeftTile, iLastTile;
|
|
int32_t idSelectedTile;
|
|
int32_t scrollmode;
|
|
int32_t mousedx, mousedy, mtile, omousex=searchx, omousey=searchy, moffset=0;
|
|
|
|
int32_t noTilesMarked=1;
|
|
int32_t mark_lastk = -1;
|
|
|
|
// Enable following line for testing. I couldn't work out how to change vidmode on the fly
|
|
// s_Zoom = NUM_ZOOMS - 1;
|
|
|
|
idInitialTile = clamp(idInitialTile, 0, MAXTILES-1);
|
|
|
|
// Ensure zoom not to big (which can happen if display size
|
|
// changes whilst Mapster is running)
|
|
do
|
|
{
|
|
nXTiles = xdim / ZoomToThumbSize[s_Zoom];
|
|
nYTiles = ydim / ZoomToThumbSize[s_Zoom];
|
|
// Refuse to draw less than half of a row.
|
|
if (ZoomToThumbSize[s_Zoom]/2 < 12) nYTiles--;
|
|
nDisplayedTiles = nXTiles * nYTiles;
|
|
|
|
if (!nDisplayedTiles)
|
|
{
|
|
// Eh-up, resolution changed since we were last displaying tiles.
|
|
s_Zoom--;
|
|
}
|
|
}
|
|
while (!nDisplayedTiles);
|
|
|
|
keystatus[KEYSC_V] = 0;
|
|
|
|
for (i = 0; i < MAXTILES; i++)
|
|
{
|
|
localartfreq[i] = 0;
|
|
localartlookup[i] = i;
|
|
}
|
|
|
|
iLastTile = iTile = idSelectedTile = idInitialTile;
|
|
|
|
switch (searchstat)
|
|
{
|
|
case SEARCH_WALL:
|
|
for (i = 0; i < numwalls; i++)
|
|
localartfreq[ wall[i].picnum ]++;
|
|
break;
|
|
|
|
case SEARCH_CEILING:
|
|
case SEARCH_FLOOR:
|
|
for (i = 0; i < numsectors; i++)
|
|
{
|
|
localartfreq[ sector[i].ceilingpicnum ]++;
|
|
localartfreq[ sector[i].floorpicnum ]++;
|
|
}
|
|
break;
|
|
|
|
case SEARCH_SPRITE:
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
localartfreq[ sprite[i].picnum ] += (sprite[i].statnum < MAXSTATUS);
|
|
break;
|
|
|
|
case SEARCH_MASKWALL:
|
|
for (i = 0; i < numwalls; i++)
|
|
localartfreq[ wall[i].overpicnum ]++;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// Sort tiles into frequency order
|
|
//
|
|
|
|
gap = MAXTILES / 2;
|
|
|
|
do
|
|
{
|
|
for (i = 0; i < MAXTILES-gap; i++)
|
|
{
|
|
temp = i;
|
|
|
|
while (temp >= 0 && localartfreq[temp]<localartfreq[temp+gap])
|
|
{
|
|
int32_t tempint;
|
|
|
|
tempint = localartfreq[temp];
|
|
localartfreq[temp] = localartfreq[temp+gap];
|
|
localartfreq[temp+gap] = tempint;
|
|
|
|
tempint = localartlookup[temp];
|
|
localartlookup[temp] = localartlookup[temp+gap];
|
|
localartlookup[temp+gap] = tempint;
|
|
|
|
if (iTile == temp)
|
|
iTile = temp + gap;
|
|
else if (iTile == temp + gap)
|
|
iTile = temp;
|
|
|
|
temp -= gap;
|
|
}
|
|
}
|
|
gap >>= 1;
|
|
}
|
|
while (gap > 0);
|
|
|
|
//
|
|
// Set up count of number of used tiles
|
|
//
|
|
|
|
localartlookupnum = 0;
|
|
while (localartfreq[localartlookupnum] > 0)
|
|
localartlookupnum++;
|
|
|
|
//
|
|
// Check : If no tiles used at all then switch to displaying all tiles
|
|
//
|
|
|
|
if (!localartfreq[0])
|
|
{
|
|
localartlookupnum = MAXTILES;
|
|
|
|
for (i = 0; i < MAXTILES; i++)
|
|
{
|
|
localartlookup[i] = i;
|
|
localartfreq[i] = 0; // Terrible bodge : zero tilefreq's not displayed in tile view. Still, when in Rome ... :-)
|
|
}
|
|
|
|
iTile = idInitialTile;
|
|
}
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
iTopLeftTile = iTile - (iTile % nXTiles);
|
|
iTopLeftTile = clamp(iTopLeftTile, 0, MAXTILES-nDisplayedTiles);
|
|
|
|
zoomsz = ZoomToThumbSize[s_Zoom];
|
|
|
|
searchx = ((iTile-iTopLeftTile)%nXTiles)*zoomsz + zoomsz/2;
|
|
searchy = ((iTile-iTopLeftTile)/nXTiles)*zoomsz + zoomsz/2;
|
|
|
|
////////////////////////////////
|
|
// Start of key handling code //
|
|
////////////////////////////////
|
|
|
|
while ((keystatus[KEYSC_ENTER]|keystatus[KEYSC_ESC]|(bstatus&1)) == 0) // <- Presumably one of these is escape key ??
|
|
{
|
|
int32_t ret;
|
|
zoomsz = ZoomToThumbSize[s_Zoom];
|
|
|
|
ret = DrawTiles(iTopLeftTile, (iTile >= localartlookupnum) ? localartlookupnum-1 : iTile,
|
|
nXTiles, nYTiles, zoomsz, moffset,
|
|
(tilesel_showerr && (iTile==iLastTile || (tilesel_showerr=0))));
|
|
|
|
if (ret==0)
|
|
{
|
|
idle_waitevent_timeout(500);
|
|
// SDL seems to miss mousewheel events when rotated slowly.
|
|
|
|
if (handleevents())
|
|
quitevent = 0;
|
|
}
|
|
getmousevalues(&mousedx,&mousedy,&bstatus);
|
|
|
|
iLastTile = iTile;
|
|
|
|
searchx += mousedx;
|
|
searchy += mousedy;
|
|
|
|
if (bstatus&2)
|
|
{
|
|
moffset += mousedy*2;
|
|
searchy += mousedy;
|
|
searchx -= mousedx;
|
|
|
|
if ((moffset < 0 && iTopLeftTile > localartlookupnum-nDisplayedTiles-1)
|
|
|| (moffset > 0 && iTopLeftTile==0))
|
|
{
|
|
moffset=0;
|
|
searchy -= mousedy*2;
|
|
}
|
|
|
|
while (moffset > zoomsz)
|
|
{
|
|
iTopLeftTile -= nXTiles;
|
|
moffset -= zoomsz;
|
|
}
|
|
while (moffset < -zoomsz)
|
|
{
|
|
iTopLeftTile += nXTiles;
|
|
moffset += zoomsz;
|
|
}
|
|
}
|
|
|
|
// Keep the pointer visible at all times.
|
|
temp = min(zoomsz/2, 12);
|
|
inpclamp(&searchx, temp, xdim-temp);
|
|
inpclamp(&searchy, temp, ydim-temp);
|
|
|
|
scrollmode = !(eitherCTRL^revertCTRL);
|
|
if (bstatus&16 && scrollmode && iTopLeftTile > 0)
|
|
{
|
|
mouseb &= ~16;
|
|
iTopLeftTile -= (nXTiles*scrollamount);
|
|
}
|
|
else if (bstatus&32 && scrollmode && iTopLeftTile < localartlookupnum-nDisplayedTiles-1)
|
|
{
|
|
mouseb &= ~32;
|
|
iTopLeftTile += (nXTiles*scrollamount);
|
|
}
|
|
|
|
mtile = iTile = searchx/zoomsz + ((searchy-moffset)/zoomsz)*nXTiles + iTopLeftTile;
|
|
while (iTile >= iTopLeftTile + nDisplayedTiles)
|
|
{
|
|
iTile -= nXTiles;
|
|
mtile = iTile;
|
|
}
|
|
|
|
// These two lines are so obvious I don't need to comment them ...;-)
|
|
synctics = totalclock-lockclock;
|
|
lockclock += synctics;
|
|
|
|
// Zoom in / out using numeric key pad's / and * keys
|
|
if (((keystatus[KEYSC_gSLASH] || (!scrollmode && bstatus&16)) && s_Zoom<(signed)(NUM_ZOOMS-1))
|
|
|| ((keystatus[KEYSC_gSTAR] || (!scrollmode && bstatus&32)) && s_Zoom>0))
|
|
{
|
|
if (PRESSED_KEYSC(gSLASH) || (!scrollmode && bstatus&16))
|
|
{
|
|
mouseb &= ~16;
|
|
bstatus &= ~16;
|
|
|
|
// Watch out : If editor window is small, then the next zoom level
|
|
// might get so large that even one tile might not fit !
|
|
if (ZoomToThumbSize[s_Zoom+1]<=xdim && ZoomToThumbSize[s_Zoom+1]<=ydim)
|
|
{
|
|
// Phew, plenty of room.
|
|
s_Zoom++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
keystatus[KEYSC_gSTAR] = 0;
|
|
mouseb &= ~32;
|
|
bstatus &= ~32;
|
|
s_Zoom--;
|
|
}
|
|
|
|
zoomsz = ZoomToThumbSize[s_Zoom];
|
|
|
|
if (iTile >= localartlookupnum)
|
|
iTile = localartlookupnum-1;
|
|
|
|
// Calculate new num of tiles to display
|
|
nXTiles = xdim / zoomsz;
|
|
nYTiles = ydim / zoomsz;
|
|
// Refuse to draw less than half of a row.
|
|
if (zoomsz/2 < 12)
|
|
nYTiles--;
|
|
nDisplayedTiles = nXTiles * nYTiles;
|
|
|
|
// Determine if the top-left displayed tile needs to
|
|
// alter in order to display selected tile
|
|
iTopLeftTile = iTile - (iTile % nXTiles);
|
|
iTopLeftTile = clamp(iTopLeftTile, 0, MAXTILES - nDisplayedTiles);
|
|
|
|
// scroll window so mouse points the same tile as it was before zooming
|
|
iTopLeftTile -= searchx/zoomsz + ((searchy-moffset)/zoomsz)*nXTiles + iTopLeftTile-iTile;
|
|
}
|
|
|
|
if (PRESSED_KEYSC(LEFT))
|
|
{
|
|
if (eitherCTRL) // same as HOME, for consistency with CTRL-UP/DOWN
|
|
iTile = (iTile/nXTiles)*nXTiles;
|
|
else
|
|
iTile--;
|
|
}
|
|
|
|
if (PRESSED_KEYSC(RIGHT))
|
|
{
|
|
if (eitherCTRL) // same as END, for consistency with CTRL-UP/DOWN
|
|
iTile = ((iTile+nXTiles)/nXTiles)*nXTiles - 1;
|
|
else
|
|
iTile++;
|
|
}
|
|
|
|
if (PRESSED_KEYSC(UP))
|
|
{
|
|
if (eitherCTRL)
|
|
while (iTile-nXTiles >= iTopLeftTile)
|
|
iTile -= nXTiles;
|
|
else
|
|
iTile -= nXTiles;
|
|
}
|
|
|
|
if (PRESSED_KEYSC(DOWN))
|
|
{
|
|
if (eitherCTRL)
|
|
while (iTile+nXTiles < iTopLeftTile + nDisplayedTiles)
|
|
iTile += nXTiles;
|
|
else
|
|
iTile += nXTiles;
|
|
}
|
|
|
|
if (PRESSED_KEYSC(PGUP))
|
|
{
|
|
if (eitherCTRL)
|
|
iTile = 0;
|
|
else
|
|
iTile -= nDisplayedTiles;
|
|
}
|
|
|
|
if (PRESSED_KEYSC(PGDN))
|
|
{
|
|
if (eitherCTRL)
|
|
iTile = localartlookupnum-1;
|
|
else
|
|
iTile += nDisplayedTiles;
|
|
}
|
|
|
|
if (PRESSED_KEYSC(HOME))
|
|
{
|
|
if (eitherCTRL)
|
|
iTile = iTopLeftTile;
|
|
else
|
|
iTile = (iTile/nXTiles)*nXTiles;
|
|
}
|
|
|
|
if (PRESSED_KEYSC(END))
|
|
{
|
|
if (eitherCTRL)
|
|
iTile = iTopLeftTile + nDisplayedTiles - 1;
|
|
else
|
|
iTile = ((iTile+nXTiles)/nXTiles)*nXTiles - 1;
|
|
}
|
|
|
|
// 'V' KEYPRESS
|
|
if (PRESSED_KEYSC(V))
|
|
iTile = SelectAllTiles(iTile);
|
|
|
|
// 'G' KEYPRESS - Goto frame
|
|
if (PRESSED_KEYSC(G))
|
|
{
|
|
if (eitherCTRL)
|
|
{
|
|
if (OnSaveTileGroup() == 0)
|
|
{
|
|
// iTile = SelectAllTiles(iTile);
|
|
Bmemset(tilemarked, 0, sizeof(tilemarked));
|
|
mark_lastk = -1;
|
|
noTilesMarked = 1;
|
|
}
|
|
}
|
|
else
|
|
iTile = OnGotoTile(iTile);
|
|
}
|
|
|
|
// 'U' KEYPRESS : go straight to user defined art
|
|
if (PRESSED_KEYSC(U))
|
|
{
|
|
SelectAllTiles(iTile);
|
|
iTile = FIRST_USER_ART_TILE;
|
|
}
|
|
|
|
// 'A' KEYPRESS : Go straight to start of Atomic edition's art
|
|
if (PRESSED_KEYSC(A))
|
|
{
|
|
SelectAllTiles(iTile);
|
|
iTile = FIRST_ATOMIC_TILE;
|
|
}
|
|
|
|
// 'E' KEYPRESS : Go straight to start of extended art
|
|
if (PRESSED_KEYSC(E))
|
|
{
|
|
SelectAllTiles(iTile);
|
|
|
|
if (iTile == FIRST_EXTENDED_TILE)
|
|
iTile = SECOND_EXTENDED_TILE;
|
|
else iTile = FIRST_EXTENDED_TILE;
|
|
}
|
|
|
|
// 'T' KEYPRESS = Select from pre-defined tileset
|
|
if (PRESSED_KEYSC(T))
|
|
iTile = OnSelectTile(iTile);
|
|
|
|
if (PRESSED_KEYSC(Z))
|
|
s_TileZoom = !s_TileZoom;
|
|
|
|
//
|
|
// Ensure tilenum is within valid range
|
|
//
|
|
iTile = clamp(iTile, 0, min(MAXTILES-1, localartlookupnum+nDisplayedTiles-1));
|
|
|
|
// 'S' KEYPRESS: search for named tile
|
|
if (PRESSED_KEYSC(S))
|
|
{
|
|
static char laststr[25] = "";
|
|
const char *searchstr = getstring_simple("Search for tile name: ", laststr, sizeof(names[0])-1, 1);
|
|
static char buf[2][25];
|
|
|
|
if (searchstr && searchstr[0])
|
|
{
|
|
int32_t i, i0, slen=Bstrlen(searchstr)-1;
|
|
|
|
Bstrncpy(laststr, searchstr, 25);
|
|
laststr[24] = 0;
|
|
i0 = localartlookup[iTile];
|
|
|
|
Bmemcpy(buf[0], laststr, 25);
|
|
Bstrupr(buf[0]);
|
|
|
|
for (i=(i0+1)%MAXTILES; i!=i0; i=(i+1)%MAXTILES)
|
|
{
|
|
Bmemcpy(buf[1], names[i], 25);
|
|
buf[1][24]=0;
|
|
Bstrupr(buf[1]);
|
|
|
|
if ((searchstr[0]=='^' && !Bstrncmp(buf[1], buf[0]+1, slen)) ||
|
|
(searchstr[0]!='^' && Bstrstr(buf[1], buf[0])))
|
|
{
|
|
SelectAllTiles(i);
|
|
iTile = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
mousex = mousey = mouseb = 0;
|
|
}
|
|
|
|
//
|
|
// Adjust top-left to ensure tilenum is within displayed range of tiles
|
|
//
|
|
|
|
while (iTile < iTopLeftTile - (moffset<0)?nXTiles:0)
|
|
iTopLeftTile -= nXTiles;
|
|
|
|
while (iTile >= iTopLeftTile + nDisplayedTiles)
|
|
iTopLeftTile += nXTiles;
|
|
|
|
iTopLeftTile = clamp(iTopLeftTile, 0, MAXTILES - nDisplayedTiles);
|
|
|
|
|
|
// SPACE keypress: mark/unmark selected tile
|
|
if (PRESSED_KEYSC(SPACE))
|
|
{
|
|
if (iTile < localartlookupnum && IsValidTile(localartlookup[iTile]))
|
|
{
|
|
if (keystatus[KEYSC_LCTRL] && keystatus[KEYSC_RSHIFT])
|
|
{
|
|
Bmemset(tilemarked, 0, sizeof(tilemarked));
|
|
mark_lastk = -1;
|
|
noTilesMarked = 1;
|
|
}
|
|
else
|
|
{
|
|
int32_t k=iTile, kend, dir;
|
|
|
|
if (noTilesMarked)
|
|
{
|
|
noTilesMarked = 0;
|
|
TMPERRMSG_PRINT("Beginning marking tiles. To group, press Ctrl-G."
|
|
" To reset, press LCtrl-RShift-SPACE.");
|
|
}
|
|
|
|
if (mark_lastk>=0 && eitherCTRL)
|
|
{
|
|
kend = mark_lastk;
|
|
dir = ksgn(mark_lastk-k);
|
|
}
|
|
else
|
|
{
|
|
kend = k;
|
|
dir = 0;
|
|
}
|
|
|
|
mark_lastk = k;
|
|
|
|
for (; dir==0 || dir*(kend-k)>=1; k+=dir)
|
|
{
|
|
tilemarked[localartlookup[k]>>3] ^= (1<<(localartlookup[k]&7));
|
|
if (dir==0)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((keystatus[KEYSC_ENTER] || (bstatus&1)) == 0) // uh ? Not escape key ?
|
|
{
|
|
idSelectedTile = idInitialTile;
|
|
}
|
|
else
|
|
{
|
|
if (iTile < localartlookupnum)
|
|
{
|
|
// Convert tile num from index to actual tile num
|
|
idSelectedTile = localartlookup[iTile];
|
|
|
|
// Check : if invalid tile selected, return original tile num
|
|
if (!IsValidTile(idSelectedTile))
|
|
idSelectedTile = idInitialTile;
|
|
}
|
|
else
|
|
{
|
|
idSelectedTile = idInitialTile;
|
|
}
|
|
}
|
|
if (mtile!=iTile) // if changed by keyboard, update mouse cursor
|
|
{
|
|
searchx = ((iTile-iTopLeftTile)%nXTiles) * zoomsz + zoomsz/2;
|
|
searchy = ((iTile-iTopLeftTile)/nXTiles) * zoomsz + zoomsz/2 + moffset;
|
|
}
|
|
}
|
|
|
|
searchx=omousex;
|
|
searchy=omousey;
|
|
|
|
keystatus[KEYSC_ESC] = 0;
|
|
keystatus[KEYSC_ENTER] = 0;
|
|
|
|
return idSelectedTile;
|
|
}
|
|
|
|
// Dir = 0 (zoom out) or 1 (zoom in)
|
|
//void OnZoomInOut( int32_t *pZoom, int32_t Dir /*0*/ )
|
|
//{
|
|
//}
|
|
|
|
static int32_t OnSaveTileGroup(void)
|
|
{
|
|
int32_t i, n=0;
|
|
char hotkey;
|
|
const char *cp, *name;
|
|
|
|
if (tile_groups==MAX_TILE_GROUPS)
|
|
TMPERRMSG_RETURN("Cannot save tile group: maximum number of groups (%d) exceeded.", MAX_TILE_GROUPS);
|
|
|
|
for (i=0; i<MAXTILES; i++)
|
|
n += !!(tilemarked[i>>3]&(1<<(i&7)));
|
|
|
|
if (n==0)
|
|
TMPERRMSG_RETURN("Cannot save tile group: no tiles marked.");
|
|
else if (n > MAX_TILE_GROUP_ENTRIES)
|
|
TMPERRMSG_RETURN("Cannot save tile group: too many tiles in group. Have %d, max is %d.",
|
|
n, MAX_TILE_GROUP_ENTRIES);
|
|
|
|
cp = getstring_simple("Hotkey for new group: ", "", 1, 0);
|
|
if (!cp || !*cp)
|
|
return 1;
|
|
|
|
hotkey = Btoupper(cp[0]);
|
|
if (!isalpha(hotkey))
|
|
TMPERRMSG_RETURN("Hotkey must be alphabetic.");
|
|
|
|
for (i=0; i<tile_groups; i++)
|
|
if (s_TileGroups[i].key1==hotkey || s_TileGroups[i].key2==Btolower(hotkey))
|
|
TMPERRMSG_RETURN("Hotkey '%c' already in use by tile group `%s'.", hotkey, s_TileGroups[i].szText);
|
|
|
|
name = getstring_simple("Name for new tile group: ", "", 63, 0);
|
|
if (!name || !*name)
|
|
return 1;
|
|
|
|
for (i=0; name[i]; i++)
|
|
if (!(isalnum(name[i]) || name[i]==' ' || name[i]==','))
|
|
TMPERRMSG_RETURN("Name may only consist of alphabetic, numeric and space characters.");
|
|
|
|
{
|
|
int32_t lasti=-1, col=0, j, k, opathsearchmode=pathsearchmode;
|
|
BFILE *fp;
|
|
|
|
pathsearchmode = pathsearchmode_oninit; // use the same pathsearchmode as on init
|
|
fp = fopenfrompath(default_tiles_cfg, "a");
|
|
pathsearchmode = opathsearchmode;
|
|
if (!fp)
|
|
TMPERRMSG_RETURN("Could not open `%s' for writing: %s.", default_tiles_cfg, strerror(errno));
|
|
if (fseek(fp, 0, BSEEK_END)) // seems to be necessary even though we fopen with "a"
|
|
TMPERRMSG_RETURN("Could not seek to end of file `%s'.", default_tiles_cfg);
|
|
|
|
#define TTAB "\t"
|
|
#define TBITCHK(i) ((i)<MAXTILES && (tilemarked[(i)>>3]&(1<<((i)&7))))
|
|
Bfprintf(fp, OURNEWL);
|
|
Bfprintf(fp, "tilegroup \"%s\""OURNEWL"{"OURNEWL, name);
|
|
Bfprintf(fp, TTAB "hotkey \"%c\""OURNEWL OURNEWL, hotkey);
|
|
|
|
if (!(s_TileGroups[tile_groups].pIds = Bmalloc(n * sizeof(s_TileGroups[tile_groups].pIds[0]))))
|
|
TMPERRMSG_RETURN("Out of memory.");
|
|
|
|
j = 0;
|
|
// tileranges for consecutive runs of 3 or more tiles
|
|
for (i=0; i<MAXTILES; i++)
|
|
{
|
|
if (lasti>=0 && !TBITCHK(i))
|
|
{
|
|
if (names[lasti][0] && names[i-1][0])
|
|
Bfprintf(fp, TTAB "tilerange %s %s"OURNEWL, names[lasti], names[i-1]);
|
|
else
|
|
Bfprintf(fp, TTAB "tilerange %d %d"OURNEWL, lasti, i-1);
|
|
|
|
for (k=lasti; k<i; k++)
|
|
{
|
|
s_TileGroups[tile_groups].pIds[j++] = k;
|
|
tilemarked[k>>3] &= ~(1<<(k&7));
|
|
}
|
|
|
|
lasti = -1;
|
|
}
|
|
else if (lasti==-1 && TBITCHK(i))
|
|
{
|
|
if (TBITCHK(i+1) && TBITCHK(i+2))
|
|
{
|
|
lasti = i;
|
|
i += 2;
|
|
}
|
|
}
|
|
}
|
|
if (lasti>=0 && lasti<=MAXTILES-3)
|
|
{
|
|
for (k=lasti; k<MAXTILES; k++)
|
|
{
|
|
s_TileGroups[tile_groups].pIds[j++] = k;
|
|
tilemarked[k>>3] &= ~(1<<(k&7));
|
|
}
|
|
Bfprintf(fp, TTAB "tilerange %d %d"OURNEWL, lasti, MAXTILES-1);
|
|
}
|
|
Bfprintf(fp, OURNEWL);
|
|
|
|
k = 0;
|
|
for (i=0; i<MAXTILES; i++)
|
|
if (tilemarked[i>>3]&(1<<(i&7)))
|
|
{
|
|
k = 1;
|
|
break;
|
|
}
|
|
|
|
if (k)
|
|
{
|
|
// throw them all in a tiles{...} group else
|
|
Bfprintf(fp, TTAB "tiles\n" TTAB "{"OURNEWL);
|
|
for (i=0; i<MAXTILES; i++)
|
|
{
|
|
if (TBITCHK(i))
|
|
{
|
|
s_TileGroups[tile_groups].pIds[j++] = i;
|
|
|
|
if (col==0)
|
|
Bfprintf(fp, TTAB TTAB), col+=8;
|
|
|
|
if (names[i][0])
|
|
col+=Bfprintf(fp, "%s ", names[i]);
|
|
else
|
|
col+=Bfprintf(fp, "%d ", i);
|
|
|
|
if (col>80)
|
|
{
|
|
Bfprintf(fp, OURNEWL);
|
|
col = 0;
|
|
}
|
|
}
|
|
}
|
|
if (col>0)
|
|
Bfprintf(fp, OURNEWL);
|
|
Bfprintf(fp, TTAB "}"OURNEWL);
|
|
}
|
|
#undef TBITCHK
|
|
#undef TTAB
|
|
Bfprintf(fp, "}"OURNEWL);
|
|
|
|
Bfclose(fp);
|
|
|
|
if (!(s_TileGroups[tile_groups].szText = Bstrdup(name)))
|
|
{
|
|
Bfree(s_TileGroups[tile_groups].pIds);
|
|
TMPERRMSG_RETURN("Out of memory.");
|
|
}
|
|
|
|
s_TileGroups[tile_groups].nIds = n;
|
|
s_TileGroups[tile_groups].key1 = Btoupper(hotkey);
|
|
s_TileGroups[tile_groups].key2 = Btolower(hotkey);
|
|
s_TileGroups[tile_groups].color1 = s_TileGroups[tile_groups].color2 = 0;
|
|
tile_groups++;
|
|
|
|
TMPERRMSG_PRINT("Wrote and installed new tile group.");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int32_t OnGotoTile(int32_t iTile)
|
|
{
|
|
//Automatically press 'V'
|
|
iTile = SelectAllTiles(iTile);
|
|
|
|
return getnumber256("Goto tile: ", 0, MAXTILES-1, 0+2+16);
|
|
}
|
|
|
|
|
|
static int32_t LoadTileSet(const int32_t idCurrentTile, const int32_t *pIds, const int32_t nIds)
|
|
{
|
|
int32_t iNewTile = 0;
|
|
int32_t i;
|
|
|
|
localartlookupnum = nIds;
|
|
|
|
for (i = 0; i < localartlookupnum; i++)
|
|
{
|
|
localartlookup[i] = pIds[i];
|
|
// REM : Could we still utilise localartfreq[] to mark
|
|
// which tiles are currently used in the map ? Set to 0xFFFF perhaps ?
|
|
localartfreq[i] = 0;
|
|
|
|
if (idCurrentTile == pIds[i])
|
|
iNewTile = i;
|
|
}
|
|
|
|
return iNewTile;
|
|
}
|
|
|
|
static int32_t OnSelectTile(int32_t iTile)
|
|
{
|
|
int32_t bDone = 0;
|
|
int32_t i;
|
|
char ch;
|
|
|
|
if (tile_groups <= 0)
|
|
{
|
|
TMPERRMSG_PRINT("No tile groups loaded. Check for existence of `%s'.", default_tiles_cfg);
|
|
return iTile;
|
|
}
|
|
|
|
SelectAllTiles(iTile);
|
|
|
|
bflushchars();
|
|
|
|
setpolymost2dview();
|
|
#ifdef USE_OPENGL
|
|
bglEnable(GL_TEXTURE_2D);
|
|
#endif
|
|
clearview(0);
|
|
|
|
//
|
|
// Await appropriate selection keypress.
|
|
//
|
|
|
|
bDone = 0;
|
|
|
|
while (keystatus[KEYSC_ESC] == 0 && !bDone)
|
|
{
|
|
if (handleevents())
|
|
quitevent = 0;
|
|
|
|
idle_waitevent();
|
|
|
|
//
|
|
// Display the description strings for each available tile group
|
|
//
|
|
for (i = 0; i < tile_groups; i++)
|
|
{
|
|
if (s_TileGroups[i].szText != NULL)
|
|
{
|
|
if ((i+2)*16 > ydimgame) break;
|
|
Bsprintf(tempbuf,"(%c) %s",s_TileGroups[i].key1,s_TileGroups[i].szText);
|
|
printext256(10L, (i+1)*16, whitecol, -1, tempbuf, 0);
|
|
}
|
|
}
|
|
showframe(1);
|
|
|
|
ch = bgetchar();
|
|
|
|
for (i = 0; i < tile_groups; i++)
|
|
{
|
|
if (s_TileGroups[i].pIds != NULL && s_TileGroups[i].key1)
|
|
if ((ch == s_TileGroups[i].key1) || (ch == s_TileGroups[i].key2))
|
|
{
|
|
iTile = LoadTileSet(iTile, s_TileGroups[i].pIds, s_TileGroups[i].nIds);
|
|
bDone = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
showframe(1);
|
|
|
|
clearkeys();
|
|
|
|
return iTile;
|
|
}
|
|
|
|
static const char *GetTilePixels(int32_t idTile)
|
|
{
|
|
char *pPixelData = 0;
|
|
|
|
if (idTile >= 0 && idTile < MAXTILES)
|
|
{
|
|
if (!waloff[idTile])
|
|
loadtile(idTile);
|
|
|
|
if (IsValidTile(idTile))
|
|
pPixelData = (char *)waloff[idTile];
|
|
}
|
|
|
|
return pPixelData;
|
|
}
|
|
|
|
static void classic_drawtilescreen(int32_t x, int32_t y, int32_t idTile, int32_t TileDim,
|
|
const char *pRawPixels)
|
|
{
|
|
int32_t dispxsz = tilesizx[idTile], dispysz = tilesizy[idTile];
|
|
int32_t divinc = 1, mulinc = 1;
|
|
|
|
int32_t xofs, yofs;
|
|
char *pScreen;
|
|
|
|
while ((dispxsz/divinc > TileDim) || (dispysz/divinc) > TileDim)
|
|
{
|
|
divinc++;
|
|
}
|
|
|
|
if (divinc == 1 && s_TileZoom)
|
|
{
|
|
while ((dispxsz*(mulinc+1)) <= TileDim && (dispysz*(mulinc+1)) <= TileDim)
|
|
{
|
|
mulinc++;
|
|
}
|
|
}
|
|
|
|
dispxsz = (dispxsz / divinc) * mulinc;
|
|
dispysz = (dispysz / divinc) * mulinc;
|
|
|
|
for (yofs = 0; yofs < dispysz; yofs++)
|
|
{
|
|
y += yofs;
|
|
if (y>=0 && y<ydim)
|
|
{
|
|
pScreen = (char *)ylookup[y]+x+frameplace;
|
|
for (xofs = 0; xofs < dispxsz; xofs++)
|
|
{
|
|
pScreen[xofs] = pRawPixels[((yofs*divinc)/mulinc) + (((xofs*divinc)/mulinc)*tilesizy[idTile])];
|
|
}
|
|
}
|
|
y -= yofs;
|
|
}
|
|
}
|
|
|
|
static void tilescreen_drawbox(int32_t iTopLeft, int32_t iSelected, int32_t nXTiles,
|
|
int32_t TileDim, int32_t offset,
|
|
int32_t iTile, int32_t idTile)
|
|
{
|
|
int32_t marked = (IsValidTile(idTile) && tilemarked[idTile>>3]&(1<<(idTile&7)));
|
|
|
|
//
|
|
// Draw white box around currently selected tile or marked tile
|
|
// p1=(x1, y1), p2=(x1+TileDim-1, y1+TileDim-1)
|
|
//
|
|
if (iTile == iSelected || marked)
|
|
{
|
|
int32_t x1 = ((iTile-iTopLeft) % nXTiles)*TileDim;
|
|
int32_t y1 = ((iTile - ((iTile-iTopLeft) % nXTiles) - iTopLeft)/nXTiles)*TileDim + offset;
|
|
int32_t x2 = x1+TileDim-1;
|
|
int32_t y2 = y1+TileDim-1, oydim16=ydim16;
|
|
|
|
char markedcol = editorcolors[14];
|
|
|
|
setpolymost2dview();
|
|
|
|
y1=max(y1, 0);
|
|
y2=min(y2, ydim-1);
|
|
|
|
// plotlines2d uses drawline16, which clips against ydim16...
|
|
ydim16 = ydim;
|
|
|
|
{
|
|
// box
|
|
int32_t xx[] = {x1, x1, x2, x2, x1};
|
|
int32_t yy[] = {y1, y2, y2, y1, y1};
|
|
plotlines2d(xx, yy, 5, iTile==iSelected ? whitecol : markedcol);
|
|
}
|
|
|
|
// cross
|
|
if (marked)
|
|
{
|
|
int32_t xx[] = {x1, x2};
|
|
int32_t yy[] = {y1, y2};
|
|
|
|
plotlines2d(xx, yy, 2, markedcol);
|
|
swaplong(&yy[0], &yy[1]);
|
|
plotlines2d(xx, yy, 2, markedcol);
|
|
}
|
|
|
|
ydim16 = oydim16;
|
|
}
|
|
}
|
|
|
|
static void tilescreen_drawrest(int32_t iSelected, int32_t showmsg)
|
|
{
|
|
if (iSelected>=0 && iSelected<MAXTILES)
|
|
{
|
|
int32_t idTile = localartlookup[iSelected];
|
|
int32_t i;
|
|
char szT[128];
|
|
|
|
// Draw info bar at bottom.
|
|
|
|
// Clear out behind the text for improved visibility.
|
|
//drawline256(0, (ydim-12)<<12, xdim<<12, (ydim-12)<<12, whitecol);
|
|
for (i=ydim-12; i<ydim; i++)
|
|
drawline256(0, i<<12, xdim<<12, i<<12, (ydim-i));
|
|
|
|
// Tile number on left.
|
|
Bsprintf(szT, "%d" , idTile);
|
|
printext256(1, ydim-10, whitecol, -1, szT, 0);
|
|
|
|
// Tile name on right.
|
|
printext256(xdim-(Bstrlen(names[idTile])<<3)-1,ydim-10,whitecol,-1,names[idTile],0);
|
|
|
|
// Tile dimensions.
|
|
Bsprintf(szT,"%dx%d",tilesizx[idTile],tilesizy[idTile]);
|
|
printext256(xdim>>2,ydim-10,whitecol,-1,szT,0);
|
|
|
|
// EditArt offset flags.
|
|
Bsprintf(szT,"%d, %d", (int8_t)((picanm[idTile]>>8)&0xFF), (int8_t)((picanm[idTile]>>16)&0xFF));
|
|
printext256((xdim>>2)+100,ydim-10,whitecol,-1,szT,0);
|
|
|
|
// EditArt animation flags.
|
|
if (picanm[idTile]&0xc0)
|
|
{
|
|
static const char *anmtype[] = {"", "Osc", "Fwd", "Bck"};
|
|
|
|
Bsprintf(szT,"%s %d", anmtype[(picanm[idTile]&0xc0)>>6], picanm[idTile]&0x3f);
|
|
printext256((xdim>>2)+100+14*8,ydim-10,whitecol,-1,szT,0);
|
|
}
|
|
}
|
|
|
|
if (showmsg)
|
|
TMPERRMSG_SHOW(0);
|
|
|
|
m32_showmouse();
|
|
}
|
|
|
|
////////// main tile drawing function //////////
|
|
static int32_t DrawTiles(int32_t iTopLeft, int32_t iSelected, int32_t nXTiles, int32_t nYTiles,
|
|
int32_t TileDim, int32_t offset, int32_t showmsg)
|
|
{
|
|
int32_t XTile, YTile;
|
|
int32_t iTile, idTile;
|
|
int32_t i, x, y;
|
|
const char *pRawPixels;
|
|
char szT[128];
|
|
#ifdef USE_OPENGL
|
|
int32_t lazyselector = g_lazy_tileselector && usehightile;
|
|
#else
|
|
int32_t lazyselector = g_lazy_tileselector;
|
|
#endif
|
|
int32_t runi=0, usehitile;
|
|
static uint8_t loadedhitile[(MAXTILES+7)>>3];
|
|
|
|
#ifdef USE_OPENGL
|
|
setpolymost2dview();
|
|
|
|
if (rendmode >= 3)
|
|
{
|
|
bglEnable(GL_TEXTURE_2D);
|
|
|
|
if (lazyselector)
|
|
bglDrawBuffer(GL_FRONT_AND_BACK);
|
|
}
|
|
#endif
|
|
clearview(0);
|
|
|
|
begindrawing();
|
|
|
|
restart:
|
|
for (YTile = 0-(offset>0); YTile < nYTiles+(offset<0)+1; YTile++)
|
|
{
|
|
for (XTile = 0; XTile < nXTiles; XTile++)
|
|
{
|
|
iTile = iTopLeft + XTile + (YTile * nXTiles);
|
|
|
|
if (iTile < 0 || iTile >= localartlookupnum)
|
|
continue;
|
|
usehitile = (runi || !lazyselector);
|
|
|
|
idTile = localartlookup[ iTile ];
|
|
if (loadedhitile[idTile>>3]&(1<<(idTile&7)))
|
|
{
|
|
if (runi==1)
|
|
continue;
|
|
|
|
usehitile = 1;
|
|
}
|
|
|
|
// Get pointer to tile's raw pixel data
|
|
pRawPixels = GetTilePixels(idTile);
|
|
|
|
if (pRawPixels != NULL)
|
|
{
|
|
x = XTile * TileDim;
|
|
y = YTile * TileDim+offset;
|
|
|
|
if (polymost_drawtilescreen(x, y, idTile, TileDim, s_TileZoom,
|
|
usehitile, loadedhitile))
|
|
classic_drawtilescreen(x, y, idTile, TileDim, pRawPixels);
|
|
|
|
if (localartfreq[iTile] != 0 && y >= 0 && y <= ydim-20)
|
|
{
|
|
Bsprintf(szT, "%d", localartfreq[iTile]);
|
|
printext256(x, y, whitecol, -1, szT, 1);
|
|
}
|
|
}
|
|
|
|
tilescreen_drawbox(iTopLeft, iSelected, nXTiles, TileDim, offset, iTile, idTile);
|
|
|
|
if (runi==1 && lazyselector)
|
|
{
|
|
int32_t k;
|
|
|
|
if (handleevents())
|
|
quitevent=0;
|
|
|
|
tilescreen_drawrest(iSelected, showmsg);
|
|
|
|
k = (mousex || mousey || mouseb);
|
|
if (!k)
|
|
for (i=0; i<(signed)(sizeof(keystatus)/sizeof(keystatus[0])); i++)
|
|
if (keystatus[i])
|
|
{
|
|
k = 1;
|
|
break;
|
|
}
|
|
if (k)
|
|
{
|
|
enddrawing();
|
|
showframe(1);
|
|
#ifdef USE_OPENGL
|
|
if (rendmode >= 3 && lazyselector)
|
|
bglDrawBuffer(GL_BACK);
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
enddrawing();
|
|
showframe(1);
|
|
begindrawing();
|
|
}
|
|
}
|
|
}
|
|
|
|
tilescreen_drawrest(iSelected, showmsg);
|
|
|
|
if (getrendermode()>=3 && qsetmode==200 && lazyselector)
|
|
{
|
|
if (runi==0)
|
|
{
|
|
enddrawing();
|
|
showframe(1);
|
|
begindrawing();
|
|
|
|
runi = 1;
|
|
goto restart;
|
|
}
|
|
}
|
|
|
|
enddrawing();
|
|
showframe(1);
|
|
|
|
#ifdef USE_OPENGL
|
|
if (rendmode >= 3 && lazyselector)
|
|
bglDrawBuffer(GL_BACK);
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#undef TMPERRMSG_SHOW
|
|
#undef TMPERRMSG_PRINT
|
|
#undef TMPERRMSG_RETURN
|
|
|
|
#define WIND1X 3
|
|
#define WIND1Y 150
|
|
|
|
static void tileinfo_doprint(int32_t x, int32_t y, char *buf, const char *label, int32_t value, int32_t pos)
|
|
{
|
|
int32_t small = (xdimgame<=640), i = ydimgame>>6;
|
|
Bsprintf(buf,"%s:%4d",label,value);
|
|
printext256(x+2, y+2+i*pos, 0, -1, buf, small);
|
|
printext256(x, y+i*pos, whitecol, -1, buf, small);
|
|
}
|
|
|
|
// flags: 1:draw asterisk for lotag
|
|
// 2:draw asterisk for extra
|
|
static void drawtileinfo(const char *title,int32_t x,int32_t y,int32_t picnum,int32_t shade,int32_t pal,int32_t cstat,
|
|
int32_t lotag,int32_t hitag,int32_t extra, uint32_t flags)
|
|
{
|
|
char buf[64];
|
|
int32_t small = (xdimgame<=640);
|
|
int32_t scale=65536;
|
|
int32_t x1;
|
|
int32_t oviewingrange=viewingrange, oyxaspect=yxaspect;
|
|
|
|
x1 = x+80;
|
|
if (small)
|
|
x1 /= 2;
|
|
|
|
x1 *= 320.0/xdimgame;
|
|
scale /= (max(tilesizx[picnum],tilesizy[picnum])/24.0);
|
|
|
|
setaspect(65536L, (int32_t)divscale16(ydim*320L,xdim*200L));
|
|
// +1024: prevents rotatesprite from setting aspect itself
|
|
rotatesprite_fs((x1+13)<<16,(y+11)<<16,scale,0, picnum,shade,pal, 2+1024);
|
|
setaspect(oviewingrange, oyxaspect);
|
|
|
|
x *= xdimgame/320.0;
|
|
y *= ydimgame/200.0;
|
|
|
|
begindrawing();
|
|
printext256(x+2,y+2,0,-1,title,small);
|
|
printext256(x,y,255-13,-1,title,small);
|
|
|
|
tileinfo_doprint(x, y, buf, "Pic", picnum, 1);
|
|
tileinfo_doprint(x, y, buf, "Shd", shade, 2);
|
|
tileinfo_doprint(x, y, buf, "Pal", pal, 3);
|
|
tileinfo_doprint(x, y, buf, "Cst", cstat, 4);
|
|
tileinfo_doprint(x, y, buf, (flags&1)?"Lo*":"Lot", lotag, 5);
|
|
tileinfo_doprint(x, y, buf, "Hit", hitag, 6);
|
|
tileinfo_doprint(x, y, buf, (flags&2)?"Ex*":"Ext", extra, 7);
|
|
|
|
enddrawing();
|
|
}
|
|
//int32_t snap=0;
|
|
//int32_t saveval1,saveval2,saveval3;
|
|
|
|
static inline void getnumber_dochar(char *ptr, int32_t num)
|
|
{
|
|
*ptr = (char) num;
|
|
}
|
|
|
|
static inline void getnumber_doint16_t(int16_t *ptr, int32_t num)
|
|
{
|
|
*ptr = (int16_t) num;
|
|
}
|
|
|
|
static inline void getnumber_doint32(int32_t *ptr, int32_t num)
|
|
{
|
|
*ptr = (int32_t) num;
|
|
}
|
|
|
|
static inline void getnumber_doint64(int64_t *ptr, int32_t num)
|
|
{
|
|
*ptr = (int64_t) num;
|
|
}
|
|
|
|
static void getnumberptr256(const char *namestart, void *num, int32_t bytes, int32_t maxnumber, char sign, void *(func)(int32_t))
|
|
{
|
|
char buffer[80], ch;
|
|
int32_t danum = 0, oldnum;
|
|
uint8_t flags = (sign>>1)&3;
|
|
sign &= 1;
|
|
|
|
switch (bytes)
|
|
{
|
|
case 1:
|
|
danum = sign ? *(int8_t *)num : *(uint8_t *)num;
|
|
break;
|
|
case 2:
|
|
danum = sign ? *(int16_t *)num : *(uint16_t *)num;
|
|
break;
|
|
case 4:
|
|
danum = *(int32_t *)num;
|
|
break;
|
|
case 8:
|
|
danum = *(int64_t *)num;
|
|
break;
|
|
}
|
|
|
|
oldnum = danum;
|
|
bflushchars();
|
|
while (keystatus[0x1] == 0)
|
|
{
|
|
if (handleevents())
|
|
quitevent = 0;
|
|
|
|
M32_DrawRoomsAndMasks();
|
|
|
|
ch = bgetchar();
|
|
|
|
if (keystatus[0x1]) break;
|
|
|
|
clearkeys();
|
|
|
|
mouseb = 0;
|
|
searchx = osearchx;
|
|
searchy = osearchy;
|
|
|
|
ExtCheckKeys();
|
|
|
|
Bsprintf(buffer,"%s%d",namestart,danum);
|
|
if (totalclock & 32) Bstrcat(buffer,"_ ");
|
|
printmessage256(0, 0, buffer);
|
|
if (func != NULL)
|
|
{
|
|
Bsprintf(buffer,"%s",(char *)func((int32_t)danum));
|
|
printmessage256(0, 9, buffer);
|
|
}
|
|
showframe(1);
|
|
|
|
if (getnumber_internal1(ch, &danum, maxnumber, sign) ||
|
|
getnumber_autocomplete(namestart, ch, &danum, flags))
|
|
{
|
|
if (danum != oldnum)
|
|
asksave = 1;
|
|
oldnum = danum;
|
|
break;
|
|
}
|
|
|
|
switch (bytes)
|
|
{
|
|
case 1:
|
|
getnumber_dochar(num, danum);
|
|
break;
|
|
case 2:
|
|
getnumber_doint16_t(num, danum);
|
|
break;
|
|
case 4:
|
|
getnumber_doint32(num, danum);
|
|
break;
|
|
case 8:
|
|
getnumber_doint64(num, danum);
|
|
break;
|
|
}
|
|
}
|
|
|
|
clearkeys();
|
|
|
|
lockclock = totalclock; //Reset timing
|
|
|
|
switch (bytes)
|
|
{
|
|
case 1:
|
|
getnumber_dochar(num, oldnum);
|
|
break;
|
|
case 2:
|
|
getnumber_doint16_t(num, oldnum);
|
|
break;
|
|
case 4:
|
|
getnumber_doint32(num, oldnum);
|
|
break;
|
|
case 8:
|
|
getnumber_doint64(num, oldnum);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
int64_t ldistsqr(spritetype *s1,spritetype *s2)
|
|
{
|
|
return (((int64_t)(s2->x - s1->x))*((int64_t)(s2->x - s1->x)) +
|
|
((int64_t)(s2->y - s1->y))*((int64_t)(s2->y - s1->y)));
|
|
}
|
|
#endif
|
|
|
|
static void TextEntryMode(int16_t startspr)
|
|
{
|
|
char ch, buffer[80], doingspace=0;
|
|
int16_t daang = 0, t, alphidx, basetile, linebegspr, curspr, cursor;
|
|
int32_t i, j, k, dax = 0, day = 0;
|
|
static uint8_t hgap=0, vgap=4;
|
|
static uint8_t spcgap[MAX_ALPHABETS], firstrun=1;
|
|
spritetype *sp;
|
|
|
|
int16_t *spritenums;
|
|
int32_t stackallocsize=32, numletters=0;
|
|
|
|
if (firstrun)
|
|
{
|
|
firstrun=0;
|
|
for (i=0; i<numalphabets; i++)
|
|
spcgap[i] = 0;
|
|
}
|
|
|
|
if (startspr<0 || startspr>=MAXSPRITES ||
|
|
sprite[startspr].statnum == MAXSTATUS)
|
|
return;
|
|
|
|
if (numalphabets == 0)
|
|
{
|
|
message("Alphabet configuration not read.");
|
|
return;
|
|
}
|
|
|
|
if ((sprite[startspr].cstat&16) == 0)
|
|
{
|
|
message("Must point at a wall-aligned text sprite.");
|
|
return;
|
|
}
|
|
|
|
t = sprite[startspr].picnum;
|
|
alphidx = -1;
|
|
for (i=0; i<numalphabets; i++)
|
|
{
|
|
for (j=0; j<NUMPRINTABLES; j++)
|
|
if (alphabets[i].pic[j] == t)
|
|
{
|
|
alphidx = i;
|
|
basetile = t;
|
|
if (spcgap[i] == 0)
|
|
spcgap[i] = 3*tilesizx[t]/2;
|
|
goto ENDFOR1;
|
|
}
|
|
}
|
|
ENDFOR1:
|
|
if (alphidx==-1)
|
|
{
|
|
message("Must point at a text sprite.");
|
|
return;
|
|
}
|
|
|
|
curspr = linebegspr = startspr;
|
|
|
|
t = sprite[startspr].picnum;
|
|
sprite[startspr].xoffset = -(((picanm[t])>>8)&255);
|
|
sprite[startspr].yoffset = -(((picanm[t])>>16)&255);
|
|
|
|
spritenums = Bmalloc(stackallocsize * sizeof(int16_t));
|
|
if (!spritenums) goto ERROR_NOMEMORY;
|
|
|
|
cursor = insertsprite(sprite[startspr].sectnum,0);
|
|
if (cursor < 0) goto ERROR_TOOMANYSPRITES;
|
|
|
|
sp = &sprite[cursor];
|
|
Bmemcpy(sp, &sprite[startspr], sizeof(spritetype));
|
|
sp->yoffset = 0;
|
|
sp->picnum = SMALLFNTCURSOR;
|
|
sp->xrepeat = clamp(sp->xrepeat/tilesizx[sp->picnum], 2, 255);
|
|
sp->yrepeat = clamp((sp->yrepeat*tilesizy[sprite[startspr].picnum])/tilesizy[sp->picnum], 4, 255);
|
|
sp->pal = 0;
|
|
sp->cstat = 18;
|
|
|
|
bflushchars();
|
|
while (keystatus[0x1] == 0)
|
|
{
|
|
if (handleevents())
|
|
quitevent = 0;
|
|
|
|
|
|
if (PRESSED_KEYSC(UP)) // vertical gap in pixels (32 x-units)
|
|
vgap += (vgap<255);
|
|
|
|
if (PRESSED_KEYSC(DOWN))
|
|
vgap -= (vgap>0);
|
|
|
|
if (PRESSED_KEYSC(RIGHT)) // horizontal gap in half pixels
|
|
hgap += (hgap<255);
|
|
|
|
if (PRESSED_KEYSC(LEFT))
|
|
hgap -= (hgap>0);
|
|
|
|
if (PRESSED_KEYSC(INSERT)) // space gap in half pixels
|
|
spcgap[alphidx] += (spcgap[alphidx]<255);
|
|
|
|
if (PRESSED_KEYSC(DELETE))
|
|
spcgap[alphidx] -= (spcgap[alphidx]>1);
|
|
|
|
if (PRESSED_KEYSC(HOME)) // shade
|
|
sprite[linebegspr].shade += (sprite[linebegspr].shade<127);
|
|
|
|
if (PRESSED_KEYSC(END))
|
|
sprite[linebegspr].shade -= (sprite[linebegspr].shade>-128);
|
|
|
|
if (PRESSED_KEYSC(PGUP)) // pal
|
|
sprite[linebegspr].pal += (sprite[linebegspr].pal<255);
|
|
|
|
if (PRESSED_KEYSC(PGDN))
|
|
sprite[linebegspr].pal -= (sprite[linebegspr].pal>0);
|
|
|
|
M32_DrawRoomsAndMasks();
|
|
|
|
ch = bgetchar();
|
|
|
|
if (keystatus[0x1]) break;
|
|
|
|
clearkeys();
|
|
|
|
mouseb = 0;
|
|
searchx = osearchx;
|
|
searchy = osearchy;
|
|
|
|
ExtCheckKeys();
|
|
|
|
printmessage256(0,0,"^251Text entry mode.^31 Navigation keys change vars.");
|
|
Bsprintf(buffer, "Hgap=%d, Vgap=%d, SPCgap=%d, Shd=%d, Pal=%d",
|
|
hgap, vgap, spcgap[alphidx], sprite[linebegspr].shade, sprite[linebegspr].pal);
|
|
printmessage256(0, 9, buffer);
|
|
showframe(1);
|
|
|
|
// ---
|
|
sp = &sprite[curspr];
|
|
if (!doingspace)
|
|
{
|
|
dax = sp->x; day = sp->y;
|
|
daang = sp->ang;
|
|
}
|
|
|
|
j = sp->xrepeat*(hgap+tilesizx[sp->picnum]+2);
|
|
{
|
|
vec3_t vect;
|
|
vect.x = dax + ((j*sintable[daang])>>17);
|
|
vect.y = day - ((j*sintable[(daang+512)&2047])>>17);
|
|
vect.z = sp->z;
|
|
setsprite(cursor,&vect);
|
|
}
|
|
|
|
if (ch>=33 && ch<=126 && alphabets[alphidx].pic[ch-33] >= 0)
|
|
{
|
|
int16_t sect;
|
|
|
|
// mapping char->tilenum
|
|
t = alphabets[alphidx].pic[ch-33];
|
|
j = sp->xrepeat*(hgap+tilesizx[sp->picnum]+tilesizx[t]);
|
|
|
|
dax += (j*sintable[daang])>>17;
|
|
day -= (j*sintable[(daang+512)&2047])>>17;
|
|
dax += (j*sintable[(sprite[curspr].ang+2560)&2047])>>17;
|
|
day += (j*sintable[(sprite[curspr].ang+2048)&2047])>>17;
|
|
|
|
sect = sprite[curspr].sectnum;
|
|
updatesector(dax,day,§);
|
|
if (Numsprites < MAXSPRITES && sect >= 0)
|
|
{
|
|
i = insertsprite(sect,0);
|
|
Bmemcpy(&sprite[i], &sprite[linebegspr], sizeof(spritetype));
|
|
sprite[i].sectnum = sect;
|
|
|
|
sprite[i].x = dax, sprite[i].y = day;
|
|
sprite[i].picnum = t;
|
|
sprite[i].ang = daang;
|
|
|
|
sprite[i].xoffset = -(((picanm[sprite[i].picnum])>>8)&255);
|
|
sprite[i].yoffset = -(((picanm[sprite[i].picnum])>>16)&255);
|
|
sprite[i].xoffset += alphabets[alphidx].xofs[(int32_t)ch-33];
|
|
sprite[i].yoffset += alphabets[alphidx].yofs[(int32_t)ch-33];
|
|
|
|
DoSpriteOrnament(i);
|
|
|
|
for (k=0; k<MAXTILES; k++)
|
|
localartfreq[k] = 0;
|
|
for (k=0; k<MAXSPRITES; k++)
|
|
if (sprite[k].statnum < MAXSTATUS)
|
|
localartfreq[sprite[k].picnum]++;
|
|
|
|
curspr = i;
|
|
doingspace = 0;
|
|
|
|
asksave = 1;
|
|
|
|
if (numletters >= stackallocsize)
|
|
{
|
|
stackallocsize *= 2;
|
|
spritenums = Brealloc(spritenums, stackallocsize*sizeof(int16_t));
|
|
if (!spritenums) goto ERROR_NOMEMORY;
|
|
}
|
|
spritenums[numletters++] = i;
|
|
}
|
|
}
|
|
else if (ch == 32)
|
|
{
|
|
dax += ((sp->xrepeat*spcgap[alphidx]*sintable[daang])>>17);
|
|
day -= ((sp->xrepeat*spcgap[alphidx]*sintable[(daang+512)&2047])>>17);
|
|
doingspace = 1;
|
|
}
|
|
else if (ch == 8) // backspace
|
|
{
|
|
if (doingspace)
|
|
doingspace = 0;
|
|
else if (numletters > 0)
|
|
{
|
|
int16_t last = spritenums[numletters-1];
|
|
|
|
if (sprite[last].z != sprite[linebegspr].z) // only "delete" line break
|
|
{
|
|
sprite[linebegspr].z = sprite[last].z;
|
|
curspr = last;
|
|
}
|
|
else if (numletters > 1)
|
|
{
|
|
int16_t sectolast = spritenums[numletters-2];
|
|
|
|
if (sprite[last].z == sprite[sectolast].z)
|
|
curspr = sectolast;
|
|
else // if we delete the first letter on the line
|
|
curspr = linebegspr;
|
|
|
|
numletters--;
|
|
deletesprite(last);
|
|
|
|
asksave = 1;
|
|
}
|
|
else
|
|
{
|
|
numletters--;
|
|
deletesprite(last);
|
|
|
|
curspr = linebegspr;
|
|
asksave = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sprite[linebegspr].z -= ((sprite[linebegspr].yrepeat*(vgap+tilesizy[basetile]))<<2);
|
|
asksave = 1;
|
|
}
|
|
}
|
|
else if (ch == 13) // enter
|
|
{
|
|
sprite[linebegspr].z += ((sprite[linebegspr].yrepeat*(vgap+tilesizy[basetile]))<<2);
|
|
curspr = linebegspr;
|
|
doingspace = 0;
|
|
asksave = 1;
|
|
}
|
|
}
|
|
|
|
ERROR_TOOMANYSPRITES:
|
|
if (cursor < 0) message("Too many sprites in map!");
|
|
else deletesprite(cursor);
|
|
|
|
ERROR_NOMEMORY:
|
|
if (spritenums) Bfree(spritenums);
|
|
else message("Out of memory!");
|
|
|
|
clearkeys();
|
|
|
|
lockclock = totalclock; //Reset timing
|
|
}
|
|
|
|
static void mouseaction_movesprites(int32_t *sumxvect, int32_t *sumyvect, int32_t yangofs, int32_t mousexory)
|
|
{
|
|
int32_t xvect,yvect, daxvect,dayvect, ii, spi;
|
|
int32_t units, gridlock = (eitherCTRL && grid > 0 && grid < 9);
|
|
spritetype *sp = &sprite[searchwall];
|
|
int16_t tsect = sp->sectnum;
|
|
vec3_t tvec = { sp->x, sp->y, sp->z };
|
|
|
|
xvect = -((mousexory*(int32_t)sintable[(ang+yangofs+512)&2047])<<3);
|
|
yvect = -((mousexory*(int32_t)sintable[(ang+yangofs)&2047])<<3);
|
|
|
|
if (gridlock)
|
|
{
|
|
units = 1<<(11-grid);
|
|
|
|
if ((tvec.x & (units-1)) || (tvec.y & (units-1)))
|
|
{
|
|
daxvect = ((tvec.x & ~(units-1)) - tvec.x)<<14;
|
|
dayvect = ((tvec.y & ~(units-1)) - tvec.y)<<14;
|
|
}
|
|
else
|
|
{
|
|
units <<= 14;
|
|
|
|
*sumxvect += xvect;
|
|
*sumyvect += yvect;
|
|
|
|
if (klabs(*sumxvect) >= units)
|
|
{
|
|
daxvect = ((*sumxvect)/units)*units;
|
|
*sumxvect %= units;
|
|
}
|
|
else
|
|
daxvect = 0;
|
|
|
|
if (klabs(*sumyvect) >= units)
|
|
{
|
|
dayvect = ((*sumyvect)/units)*units;
|
|
*sumyvect %= units;
|
|
}
|
|
else
|
|
dayvect = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
daxvect = xvect;
|
|
dayvect = yvect;
|
|
}
|
|
|
|
if (highlightcnt<=0 || (show2dsprite[searchwall>>3] & (1<<(searchwall&7)))==0)
|
|
{
|
|
clipmove(&tvec, &tsect, daxvect,dayvect, sp->clipdist,64<<4,64<<4, spnoclip?1:CLIPMASK0);
|
|
setsprite(searchwall, &tvec);
|
|
}
|
|
else
|
|
{
|
|
xvect = daxvect;
|
|
yvect = dayvect;
|
|
|
|
// test run
|
|
for (ii=0; ii<highlightcnt; ii++)
|
|
if (highlight[ii]&16384)
|
|
{
|
|
spi = highlight[ii]&16383;
|
|
Bmemcpy(&tvec, &sprite[spi], sizeof(vec3_t));
|
|
tsect = sprite[spi].sectnum;
|
|
clipmove(&tvec, &tsect, xvect,yvect, 128,64<<4,64<<4, spnoclip?1:CLIPMASK0);
|
|
|
|
xvect = (tvec.x - sprite[spi].x)<<14;
|
|
yvect = (tvec.y - sprite[spi].y)<<14;
|
|
}
|
|
// the real thing
|
|
for (ii=0; ii<highlightcnt; ii++)
|
|
if (highlight[ii]&16384)
|
|
{
|
|
spi = highlight[ii]&16383;
|
|
Bmemcpy(&tvec, &sprite[spi], sizeof(vec3_t));
|
|
tsect = sprite[spi].sectnum;
|
|
clipmove(&tvec, &tsect, xvect,yvect, 128,64<<4,64<<4, spnoclip?1:CLIPMASK0);
|
|
setsprite(spi, &tvec);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int32_t addtobyte(int8_t *byte, int32_t num)
|
|
{
|
|
int32_t onum = *byte, clamped=0;
|
|
if (onum + num != (int8_t)(onum + num))
|
|
clamped = 1;
|
|
if (!clamped)
|
|
*byte = (onum + num);
|
|
return clamped;
|
|
}
|
|
|
|
static void Keys3d(void)
|
|
{
|
|
int32_t i = 0, changedir,tsign; // ,count,nexti
|
|
int32_t j, k, tempint = 0, hiz, loz;
|
|
int32_t hihit, lohit;
|
|
char smooshyalign=0, repeatpanalign=0; //, buffer[80];
|
|
int16_t startwall, endwall, dasector; //, statnum=0;
|
|
char tempbuf[128];
|
|
|
|
/* start Mapster32 */
|
|
|
|
if (g_numsounds > 0 && AmbienceToggle)
|
|
{
|
|
M32_MoveFX();
|
|
S_Update();
|
|
}
|
|
|
|
if (usedcount && !helpon)
|
|
{
|
|
#if 0
|
|
if (!AIMING_AT_SPRITE)
|
|
{
|
|
count=0;
|
|
for (i=0; i<numwalls; i++)
|
|
{
|
|
if (wall[i].picnum == temppicnum) count++;
|
|
if (wall[i].overpicnum == temppicnum) count++;
|
|
}
|
|
for (i=0; i<numsectors; i++)
|
|
{
|
|
if (sector[i].ceilingpicnum == temppicnum) count++;
|
|
if (sector[i].floorpicnum == temppicnum) count++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
count=0;
|
|
statnum=0;
|
|
|
|
i = headspritestat[statnum];
|
|
while (i != -1)
|
|
{
|
|
nexti = nextspritestat[i];
|
|
if (sprite[i].picnum == temppicnum) count++;
|
|
i = nexti;
|
|
}
|
|
}
|
|
#endif
|
|
drawtileinfo("Clipboard",3,124,temppicnum,tempshade,temppal,tempcstat,templotag,temphitag,tempextra,0);
|
|
}// end if usedcount
|
|
|
|
if (searchsector > -1 && searchsector < numsectors)
|
|
{
|
|
char lines[8][64];
|
|
int32_t dist, height1=0,height2=0,height3=0, num=0;
|
|
int32_t x,y,flags=0;
|
|
int16_t w;
|
|
|
|
if (infobox&1)
|
|
{
|
|
height2 = sector[searchsector].floorz - sector[searchsector].ceilingz;
|
|
|
|
switch (searchstat)
|
|
{
|
|
case SEARCH_WALL:
|
|
case SEARCH_MASKWALL:
|
|
w = SELECT_WALL();
|
|
#ifdef YAX_ENABLE
|
|
flags |= (yax_getnextwall(searchwall, YAX_CEILING)>=0) + 2*(yax_getnextwall(searchwall, YAX_FLOOR)>=0);
|
|
#endif
|
|
drawtileinfo("Current", WIND1X,WIND1Y,
|
|
AIMING_AT_WALL ? wall[w].picnum : wall[w].overpicnum,
|
|
wall[w].shade, wall[w].pal, wall[searchwall].cstat,
|
|
wall[searchwall].lotag, wall[searchwall].hitag, wall[searchwall].extra,flags);
|
|
|
|
dist = wallength(searchwall);
|
|
|
|
if (wall[searchwall].nextsector >= 0 && wall[searchwall].nextsector < numsectors)
|
|
{
|
|
int32_t nextsect = wall[searchwall].nextsector;
|
|
height1 = sector[searchsector].floorz - sector[nextsect].floorz;
|
|
height2 = sector[nextsect].floorz - sector[nextsect].ceilingz;
|
|
height3 = sector[nextsect].ceilingz - sector[searchsector].ceilingz;
|
|
}
|
|
|
|
Bsprintf(lines[num++],"Panning: %d, %d", wall[w].xpanning, wall[w].ypanning);
|
|
Bsprintf(lines[num++],"Repeat: %d, %d", wall[searchwall].xrepeat, wall[searchwall].yrepeat);
|
|
Bsprintf(lines[num++],"Overpic: %d", wall[searchwall].overpicnum);
|
|
lines[num++][0]=0;
|
|
|
|
if (getmessageleng)
|
|
break;
|
|
|
|
Bsprintf(lines[num++],"^251Wall %d^31", searchwall);
|
|
|
|
if (wall[searchwall].nextsector!=-1)
|
|
Bsprintf(lines[num++],"LoHeight:%d, HiHeight:%d, Length:%d",height1,height3,dist);
|
|
else
|
|
Bsprintf(lines[num++],"Height:%d, Length:%d",height2,dist);
|
|
break;
|
|
|
|
case SEARCH_CEILING:
|
|
case SEARCH_FLOOR:
|
|
drawtileinfo("Current", WIND1X, WIND1Y, AIMED_CEILINGFLOOR(picnum), AIMED_CEILINGFLOOR(shade),
|
|
AIMED_CEILINGFLOOR(pal), AIMED_CEILINGFLOOR(stat),
|
|
sector[searchsector].lotag, sector[searchsector].hitag, sector[searchsector].extra,0);
|
|
|
|
{
|
|
int32_t xp=AIMED_CEILINGFLOOR(xpanning), yp=AIMED_CEILINGFLOOR(ypanning);
|
|
#ifdef YAX_ENABLE
|
|
int32_t notextended = 1;
|
|
if (yax_getbunch(searchsector, AIMING_AT_FLOOR) >= 0)
|
|
notextended = 0;
|
|
Bsprintf(lines[num++],"Panning: %d%s, %d", xp, notextended?"":"*", yp);
|
|
#else
|
|
Bsprintf(lines[num++],"Panning: %d, %d", xp, yp);
|
|
#endif
|
|
}
|
|
Bsprintf(lines[num++],"%sZ: %d", Typestr[searchstat], AIMED_CEILINGFLOOR(z));
|
|
Bsprintf(lines[num++],"Slope: %d", AIMED_CEILINGFLOOR(heinum));
|
|
lines[num++][0]=0;
|
|
|
|
if (getmessageleng)
|
|
break;
|
|
|
|
Bsprintf(lines[num++],"^251Sector %d^31 %s, Lotag:%s", searchsector, typestr[searchstat], ExtGetSectorCaption(searchsector));
|
|
Bsprintf(lines[num++],"Height: %d, Visibility:%d", height2, sector[searchsector].visibility);
|
|
break;
|
|
|
|
case SEARCH_SPRITE:
|
|
drawtileinfo("Current", WIND1X, WIND1Y, sprite[searchwall].picnum, sprite[searchwall].shade,
|
|
sprite[searchwall].pal, sprite[searchwall].cstat, sprite[searchwall].lotag,
|
|
sprite[searchwall].hitag, sprite[searchwall].extra,0);
|
|
|
|
Bsprintf(lines[num++], "Repeat: %d,%d", sprite[searchwall].xrepeat, sprite[searchwall].yrepeat);
|
|
Bsprintf(lines[num++], "PosXY: %d,%d%s", sprite[searchwall].x, sprite[searchwall].y,
|
|
sprite[searchwall].xoffset|sprite[searchwall].yoffset ? " ^251*":"");
|
|
Bsprintf(lines[num++], "PosZ: "" %d", sprite[searchwall].z);// prevents tab character
|
|
lines[num++][0]=0;
|
|
|
|
if (getmessageleng)
|
|
break;
|
|
|
|
if (sprite[searchwall].picnum<0 || sprite[searchwall].picnum>=MAXTILES)
|
|
break;
|
|
|
|
if (names[sprite[searchwall].picnum][0])
|
|
{
|
|
if (sprite[searchwall].picnum==SECTOREFFECTOR)
|
|
Bsprintf(lines[num++],"^251Sprite %d^31 %s", searchwall, SectorEffectorText(searchwall));
|
|
else
|
|
Bsprintf(lines[num++],"^251Sprite %d^31 %s", searchwall, names[sprite[searchwall].picnum]);
|
|
}
|
|
else Bsprintf(lines[num++],"^251Sprite %d^31, picnum %d", searchwall, sprite[searchwall].picnum);
|
|
|
|
Bsprintf(lines[num++], "Elevation:%d",
|
|
getflorzofslope(searchsector, sprite[searchwall].x, sprite[searchwall].y) - sprite[searchwall].z);
|
|
break;
|
|
}
|
|
}
|
|
|
|
x = WIND1X*(xdimgame/320.);
|
|
y = WIND1Y*(ydimgame/200.);
|
|
y += (ydimgame>>6)*8;
|
|
|
|
if (getmessageleng)
|
|
{
|
|
while (num < 4)
|
|
lines[num++][0] = 0;
|
|
Bsprintf(lines[num++],"^251%s",getmessage);
|
|
}
|
|
|
|
begindrawing();
|
|
for (i=0; i<num; i++)
|
|
{
|
|
printext256(x+2, y+2, 0, -1, lines[i], xdimgame<=640);
|
|
printext256(x, y, whitecol, -1, lines[i], xdimgame<=640);
|
|
y += ydimgame>>6;
|
|
}
|
|
enddrawing();
|
|
}
|
|
|
|
VM_OnEvent(EVENT_PREKEYS3D, -1);
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(V)) // ' V
|
|
{
|
|
if (AIMING_AT_CEILING_OR_FLOOR)
|
|
getnumberptr256("Sector visibility: ", §or[searchsector].visibility, sizeof(sector[0].visibility), 255, 0, NULL);
|
|
}
|
|
|
|
if (keystatus[KEYSC_SEMI] && PRESSED_KEYSC(V)) // ; V
|
|
{
|
|
int16_t currsector;
|
|
uint8_t visval;
|
|
|
|
if (highlightsectorcnt == -1)
|
|
{
|
|
message("You didn't select any sectors!");
|
|
return;
|
|
}
|
|
|
|
visval = getnumber256("Visibility of selected sectors: ", sector[searchsector].visibility, 255, 0);
|
|
|
|
if (AskIfSure("Are you sure to change the visibility of all selected sectors?"))
|
|
return;
|
|
|
|
for (i=0; i<highlightsectorcnt; i++)
|
|
{
|
|
currsector = highlightsector[i];
|
|
sector[currsector].visibility = visval;
|
|
}
|
|
|
|
message("Visibility changed on all selected sectors");
|
|
}
|
|
|
|
if (PRESSED_KEYSC(V)) //V
|
|
{
|
|
if (ASSERT_AIMING)
|
|
{
|
|
int32_t oldtile = AIMED_SELOVR_PICNUM;
|
|
|
|
tempint = m32gettile(oldtile);
|
|
AIMED_SELOVR_PICNUM = tempint;
|
|
|
|
if (AIMING_AT_MASKWALL && wall[searchwall].nextwall >= 0)
|
|
NEXTWALL(searchwall).overpicnum = tempint;
|
|
|
|
if (AIMING_AT_SPRITE)
|
|
correct_sprite_yoffset(searchwall);
|
|
|
|
if (oldtile != tempint)
|
|
asksave = 1;
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(3)) /* 3 (toggle floor-over-floor (cduke3d only) */
|
|
{
|
|
floor_over_floor = !floor_over_floor;
|
|
// if (!floor_over_floor) ResetFOFSize();
|
|
message("Floor-over-floor display %s",floor_over_floor?"enabled":"disabled");
|
|
}
|
|
|
|
if (PRESSED_KEYSC(F3))
|
|
{
|
|
mlook = !mlook;
|
|
message("Mouselook: %s",mlook?"enabled":"disabled");
|
|
}
|
|
|
|
if (PRESSED_KEYSC(F4))
|
|
{
|
|
AmbienceToggle = !AmbienceToggle;
|
|
message("Ambience sounds: %s",AmbienceToggle?"enabled":"disabled");
|
|
if (!AmbienceToggle)
|
|
{
|
|
FX_StopAllSounds();
|
|
S_ClearSoundLocks();
|
|
}
|
|
}
|
|
|
|
// PK
|
|
if (PRESSED_KEYSC(F5))
|
|
{
|
|
unrealedlook = !unrealedlook;
|
|
message("UnrealEd mouse navigation: %s",unrealedlook?"enabled":"disabled");
|
|
}
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(DELETE)) // ' del
|
|
{
|
|
if (AIMING_AT_WALL_OR_MASK)
|
|
{
|
|
wall[searchwall].cstat &= YAX_NEXTWALLBITS;
|
|
message("Wall %d cstat = %d", searchwall, wall[searchwall].cstat);
|
|
}
|
|
else if (AIMING_AT_SPRITE)
|
|
{
|
|
sprite[searchwall].cstat = 0;
|
|
message("Sprite %d cstat = 0", searchwall);
|
|
}
|
|
}
|
|
|
|
// 'P and ;P - Will copy palette to all sectors/walls/sprites highlighted with R-Alt key
|
|
if ((keystatus[KEYSC_QUOTE] || keystatus[KEYSC_SEMI]) && PRESSED_KEYSC(P)) // ' P ; P
|
|
{
|
|
int16_t w, start_wall, end_wall, currsector;
|
|
int8_t pal[4];
|
|
|
|
if (highlightsectorcnt == -1)
|
|
{
|
|
message("You didn't select any sectors!");
|
|
return;
|
|
}
|
|
|
|
if (keystatus[KEYSC_QUOTE])
|
|
{
|
|
pal[0] = getnumber256("Ceiling palette: ", -1, M32_MAXPALOOKUPS, 1);
|
|
pal[1] = getnumber256("Floor palette: ", -1, M32_MAXPALOOKUPS, 1);
|
|
pal[2] = getnumber256("Wall palette: ", -1, M32_MAXPALOOKUPS, 1);
|
|
pal[3] = getnumber256("Sprite palette: ", -1, M32_MAXPALOOKUPS, 1);
|
|
}
|
|
else
|
|
{
|
|
pal[0] = getnumber256("Global palette: ", 0, M32_MAXPALOOKUPS, 0);
|
|
pal[1] = pal[2] = pal[3] = pal[0];
|
|
}
|
|
|
|
if (AskIfSure(0)) return;
|
|
|
|
for (i = 0; i < highlightsectorcnt; i++)
|
|
{
|
|
currsector = highlightsector[i];
|
|
|
|
if (pal[0] > -1)
|
|
sector[currsector].ceilingpal = pal[0];
|
|
if (pal[1] > -1)
|
|
sector[currsector].floorpal = pal[1];
|
|
|
|
// Do all the walls in the sector
|
|
start_wall = sector[currsector].wallptr;
|
|
end_wall = start_wall + sector[currsector].wallnum;
|
|
|
|
if (pal[2] > -1)
|
|
for (w = start_wall; w < end_wall; w++)
|
|
wall[w].pal = pal[2];
|
|
|
|
if (pal[3] > -1)
|
|
{
|
|
for (k=0; k<highlightsectorcnt; k++)
|
|
for (w=headspritesect[highlightsector[k]]; w >= 0; w=nextspritesect[w])
|
|
sprite[w].pal = pal[3];
|
|
}
|
|
}
|
|
|
|
message("Palettes changed");
|
|
}
|
|
|
|
if (PRESSED_KEYSC(DELETE))
|
|
{
|
|
if (AIMING_AT_SPRITE)
|
|
{
|
|
deletesprite(searchwall);
|
|
|
|
message("Sprite %d deleted",searchwall);
|
|
if (AmbienceToggle)
|
|
{
|
|
sprite[searchwall].filler &= (~1);
|
|
S_StopEnvSound(sprite[searchwall].lotag, searchwall);
|
|
}
|
|
asksave = 1;
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(BS)) // backspace
|
|
{
|
|
if (AIMING_AT_WALL_OR_MASK)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
int16_t ynw, cf=-1;
|
|
|
|
if (m32_script_expertmode)
|
|
{
|
|
if (eitherSHIFT && !eitherCTRL)
|
|
cf = 0;
|
|
else if (!eitherSHIFT && eitherCTRL)
|
|
cf = 1;
|
|
}
|
|
|
|
if (cf >= 0)
|
|
{
|
|
// clear TROR uplink/downlink
|
|
ynw = yax_getnextwall(searchwall, cf);
|
|
if (ynw >= 0)
|
|
{
|
|
yax_setnextwall(ynw, !cf, -1);
|
|
yax_setnextwall(searchwall, cf, -1);
|
|
}
|
|
|
|
message("Cleared wall %d's %s link to wall %d", searchwall, yupdownwall[cf], ynw);
|
|
}
|
|
else
|
|
#endif
|
|
if (!eitherSHIFT && !eitherCTRL)
|
|
{
|
|
int32_t nw = wall[searchwall].nextwall;
|
|
|
|
if ((unsigned)nw < (unsigned)numwalls)
|
|
{
|
|
wall[nw].nextsector = wall[nw].nextwall = -1;
|
|
wall[searchwall].nextsector = wall[searchwall].nextwall = -1;
|
|
|
|
message("Cleared connection between wall %d and %d", searchwall, nw);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(F6)) //F6
|
|
{
|
|
autospritehelp = !autospritehelp;
|
|
message("Automatic SECTOREFFECTOR help %s", autospritehelp?"enabled":"disabled");
|
|
}
|
|
if (PRESSED_KEYSC(F7)) //F7
|
|
{
|
|
autosecthelp = !autosecthelp;
|
|
message("Automatic sector tag help %s", autosecthelp?"enabled":"disabled");
|
|
}
|
|
|
|
if (autospritehelp && helpon==0)
|
|
{
|
|
if (AIMING_AT_SPRITE && sprite[searchwall].picnum==SECTOREFFECTOR)
|
|
ShowFileText("sehelp.hlp");
|
|
else if (AIMING_AT_CEILING_OR_FLOOR)
|
|
ShowFileText("sthelp.hlp");
|
|
}
|
|
|
|
// . Search & fix panning to the right (3D)
|
|
if (AIMING_AT_WALL_OR_MASK && PRESSED_KEYSC(PERIOD))
|
|
{
|
|
int32_t naligned=AutoAlignWalls(searchwall, eitherCTRL|((!eitherSHIFT)<<1)|
|
|
(eitherALT<<2)|((!!keystatus[KEYSC_QUOTE])<<3), 0);
|
|
message("Aligned %d wall%s based on wall %d%s%s%s%s", naligned,
|
|
naligned==1?"":"s", searchwall,
|
|
eitherCTRL?", recursing nextwalls":"",
|
|
!eitherSHIFT?", iterating point2s":"",
|
|
eitherALT?", aligning xrepeats":"",
|
|
keystatus[KEYSC_QUOTE]?", aligning TROR-nextwalls":"");
|
|
}
|
|
|
|
tsign = 0;
|
|
tsign -= PRESSED_KEYSC(COMMA);
|
|
tsign += PRESSED_KEYSC(PERIOD);
|
|
|
|
if (tsign)
|
|
{
|
|
if (AIMING_AT_SPRITE)
|
|
{
|
|
sprite[searchwall].ang += tsign<<(!eitherSHIFT*7);
|
|
sprite[searchwall].ang &= 2047;
|
|
message("Sprite %d angle: %d", searchwall, sprite[searchwall].ang);
|
|
}
|
|
}
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(L)) // ' L
|
|
#ifdef YAX_ENABLE
|
|
if (YAXCHK(!AIMING_AT_CEILING_OR_FLOOR || yax_getbunch(searchsector, AIMING_AT_FLOOR) < 0))
|
|
#endif
|
|
{
|
|
i = m32_clipping;
|
|
m32_clipping = 0;
|
|
|
|
switch (searchstat)
|
|
{
|
|
case SEARCH_CEILING:
|
|
getnumberptr256("Sector ceilingz: ", §or[searchsector].ceilingz,
|
|
sizeof(sector[0].ceilingz), BZ_MAX, 1, NULL);
|
|
if (!(sector[searchsector].ceilingstat&2))
|
|
{
|
|
sector[searchsector].ceilingstat |= 2;
|
|
sector[searchsector].ceilingheinum = 0;
|
|
}
|
|
getnumberptr256("Sector ceiling slope: ", §or[searchsector].ceilingheinum,
|
|
sizeof(sector[0].ceilingheinum), BHEINUM_MAX, 1, NULL);
|
|
break;
|
|
case SEARCH_FLOOR:
|
|
getnumberptr256("Sector floorz: ", §or[searchsector].floorz,
|
|
sizeof(sector[0].floorz), BZ_MAX, 1, NULL);
|
|
if (!(sector[searchsector].floorstat&2))
|
|
{
|
|
sector[searchsector].floorheinum = 0;
|
|
sector[searchsector].floorstat |= 2;
|
|
}
|
|
getnumberptr256("Sector floor slope: ", §or[searchsector].floorheinum,
|
|
sizeof(sector[0].floorheinum), BHEINUM_MAX, 1, NULL);
|
|
break;
|
|
|
|
case SEARCH_SPRITE:
|
|
getnumberptr256("Sprite x: ", &sprite[searchwall].x, sizeof(sprite[0].x), editorgridextent-1, 1, NULL);
|
|
getnumberptr256("Sprite y: ", &sprite[searchwall].y, sizeof(sprite[0].y), editorgridextent-1, 1, NULL);
|
|
getnumberptr256("Sprite z: ", &sprite[searchwall].z, sizeof(sprite[0].z), BZ_MAX, 1, NULL);
|
|
getnumberptr256("Sprite angle: ", &sprite[searchwall].ang, sizeof(sprite[0].ang), 2047, 1, NULL);
|
|
sprite[searchwall].ang &= 2047;
|
|
break;
|
|
}
|
|
|
|
setslope(searchsector, YAX_CEILING, sector[searchsector].ceilingheinum);
|
|
setslope(searchsector, YAX_FLOOR, sector[searchsector].floorheinum);
|
|
|
|
asksave = 1;
|
|
m32_clipping = i;
|
|
}
|
|
|
|
|
|
getzrange(&pos, cursectnum, &hiz, &hihit, &loz, &lohit, 128, CLIPMASK0);
|
|
|
|
if (PRESSED_KEYSC(CAPS) || (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(Z))) // CAPS LOCK
|
|
{
|
|
zmode = (zmode+1)%3;
|
|
if (zmode == 1)
|
|
zlock = (loz-pos.z)&0xfffffc00;
|
|
switch (zmode)
|
|
{
|
|
case 0: message("Zmode = Gravity"); break;
|
|
case 1: message("Zmode = Locked/Sector"); break;
|
|
case 2: message("Zmode = Locked/Free"); break;
|
|
}
|
|
}
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(M)) // 'M
|
|
{
|
|
if (ASSERT_AIMING)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if (AIMING_AT_WALL_OR_MASK && yax_getnextwall(searchwall, YAX_FLOOR)>=0)
|
|
message("Can't change extra in protected wall");
|
|
else
|
|
#endif
|
|
{
|
|
Bsprintf(tempbuf, "%s extra: ", Typestr_wss[searchstat]);
|
|
getnumberptr256(tempbuf, &AIMED(extra), sizeof(int16_t), BTAG_MAX, 1, NULL);
|
|
asksave = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(1) && ASSERT_AIMING) // 1 (make 1-way wall)
|
|
{
|
|
if (!AIMING_AT_SPRITE)
|
|
{
|
|
wall[searchwall].cstat ^= 32;
|
|
message("Wall %d one side masking bit %s", searchwall, ONOFF(wall[searchwall].cstat&32));
|
|
}
|
|
else
|
|
{
|
|
i = sprite[searchwall].cstat;
|
|
i ^= 64;
|
|
if ((i&48) == 32)
|
|
{
|
|
i &= ~8;
|
|
if ((i&64) && pos.z>sprite[searchwall].z)
|
|
i |= 8;
|
|
}
|
|
message("Sprite %d one sided bit %s", searchwall, ONOFF(i&64));
|
|
sprite[searchwall].cstat = i;
|
|
}
|
|
asksave = 1;
|
|
}
|
|
|
|
if (PRESSED_KEYSC(2)) // 2 (bottom wall swapping)
|
|
{
|
|
if (searchstat != SEARCH_SPRITE)
|
|
{
|
|
wall[searchwall].cstat ^= 2;
|
|
message("Wall %d bottom texture swap bit %s", searchwall, ONOFF(wall[searchwall].cstat&2));
|
|
asksave = 1;
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(O)) // O (top/bottom orientation - for doors)
|
|
{
|
|
if (AIMING_AT_WALL_OR_MASK)
|
|
{
|
|
int16_t w = SELECT_WALL();
|
|
wall[w].cstat ^= 4;
|
|
message("Wall %d %s orientation", w, wall[w].cstat&4?"bottom":"top");
|
|
asksave = 1;
|
|
}
|
|
else if (AIMING_AT_SPRITE) // O (ornament onto wall) (2D)
|
|
{
|
|
DoSpriteOrnament(searchwall);
|
|
message("Sprite %d ornament onto wall", searchwall);
|
|
asksave = 1;
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(M)) // M (masking walls)
|
|
{
|
|
if (!AIMING_AT_SPRITE && ASSERT_AIMING)
|
|
{
|
|
int16_t next = wall[searchwall].nextwall;
|
|
|
|
if (next >= 0)
|
|
{
|
|
wall[searchwall].cstat ^= 16;
|
|
message("Wall %d masking bit %s", searchwall, ONOFF(wall[searchwall].cstat&16));
|
|
|
|
wall[searchwall].cstat &= ~8;
|
|
|
|
if (wall[searchwall].cstat&16)
|
|
{
|
|
if (!eitherSHIFT)
|
|
{
|
|
wall[next].cstat |= 8; //auto other-side flip
|
|
wall[next].cstat |= 16;
|
|
wall[next].overpicnum = wall[searchwall].overpicnum;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!eitherSHIFT)
|
|
{
|
|
wall[next].cstat &= ~8; //auto other-side unflip
|
|
wall[next].cstat &= ~16;
|
|
}
|
|
}
|
|
|
|
wall[searchwall].cstat &= ~32;
|
|
if (!eitherSHIFT)
|
|
wall[next].cstat &= ~32;
|
|
|
|
asksave = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(H)) // H (hitscan sensitivity)
|
|
{
|
|
if (keystatus[KEYSC_QUOTE])
|
|
{
|
|
if (ASSERT_AIMING)
|
|
{
|
|
j = 0;
|
|
if (AIMING_AT_WALL || AIMING_AT_SPRITE)
|
|
{
|
|
j = taglab_linktags(AIMING_AT_SPRITE, searchwall);
|
|
j = 2*(j&2);
|
|
}
|
|
|
|
Bsprintf(tempbuf, "%s hitag: ", Typestr_wss[searchstat]);
|
|
getnumberptr256(tempbuf, &AIMED(hitag), sizeof(int16_t), BTAG_MAX, 0+j, NULL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (AIMING_AT_SPRITE)
|
|
{
|
|
sprite[searchwall].cstat ^= 256;
|
|
message("Sprite %d hitscan sensitivity bit %s", searchwall, ONOFF(sprite[searchwall].cstat&256));
|
|
asksave = 1;
|
|
}
|
|
else if (AIMING_AT_WALL_OR_MASK || AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if (AIMING_AT_CEILING_OR_FLOOR && yax_getbunch(searchsector, AIMING_AT_FLOOR)>=0)
|
|
{
|
|
SECTORFLD(searchsector,stat, AIMING_AT_FLOOR) ^= 2048;
|
|
message("Sector %d's %s hitscan sensitivity bit %s", searchsector, typestr[searchstat],
|
|
ONOFF(SECTORFLD(searchsector,stat, AIMING_AT_FLOOR)&2048));
|
|
asksave = 1;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
wall[searchwall].cstat ^= 64;
|
|
|
|
if (wall[searchwall].nextwall >= 0 && !eitherSHIFT)
|
|
{
|
|
NEXTWALL(searchwall).cstat &= ~64;
|
|
NEXTWALL(searchwall).cstat |= (wall[searchwall].cstat&64);
|
|
}
|
|
|
|
message("Wall %d hitscan sensitivity bit %s%s", searchwall,
|
|
ONOFF(wall[searchwall].cstat&64), eitherSHIFT?" (one-sided)":"");
|
|
asksave = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
smooshyalign = keystatus[KEYSC_gKP5];
|
|
repeatpanalign = eitherSHIFT || eitherALT || (bstatus&2);
|
|
|
|
{
|
|
static int32_t omlook;
|
|
|
|
if (mlook == 2)
|
|
{
|
|
mlook = omlook;
|
|
}
|
|
else if (!unrealedlook && (bstatus&4))
|
|
{
|
|
omlook = mlook;
|
|
mlook = 2;
|
|
}
|
|
}
|
|
|
|
// PK: no btn: wheel changes shade
|
|
if ((bstatus&(16|32) && !(bstatus&(1|2|4))) || keystatus[KEYSC_gMINUS] || keystatus[KEYSC_gPLUS])
|
|
{
|
|
// if (bstatus&1)
|
|
// mlook = 2;
|
|
tsign = 0;
|
|
if (bstatus&32 || PRESSED_KEYSC(gMINUS)) // -
|
|
tsign = 1;
|
|
if (bstatus&16 || PRESSED_KEYSC(gPLUS)) // +
|
|
tsign = -1;
|
|
|
|
if (tsign)
|
|
{
|
|
mouseb &= ~(16|32);
|
|
bstatus &= ~(16|32);
|
|
|
|
if (eitherALT) //ALT
|
|
{
|
|
if (eitherCTRL) //CTRL
|
|
{
|
|
if (tsign==1)
|
|
visibility <<= (visibility < 16384);
|
|
else
|
|
visibility >>= (visibility > 32);
|
|
silentmessage("Global visibility %d", visibility);
|
|
}
|
|
else
|
|
{
|
|
k=eitherSHIFT?1:16;
|
|
|
|
if (highlightsectorcnt > 0 && (hlsectorbitmap[searchsector>>3]&(1<<(searchsector&7))))
|
|
{
|
|
while (k-- > 0)
|
|
{
|
|
for (i=0; i<highlightsectorcnt; i++)
|
|
{
|
|
j = highlightsector[i];
|
|
sector[j].visibility += tsign;
|
|
|
|
if (tsign==1 && sector[j].visibility == 240)
|
|
sector[j].visibility = 239;
|
|
else if (tsign==-1 && sector[j].visibility == 239)
|
|
sector[j].visibility = 240;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (k-- > 0)
|
|
{
|
|
sector[searchsector].visibility += tsign;
|
|
|
|
if (tsign==1 && sector[searchsector].visibility == 240)
|
|
sector[searchsector].visibility = 239;
|
|
else if (tsign==-1 && sector[searchsector].visibility == 239)
|
|
sector[searchsector].visibility = 240;
|
|
}
|
|
}
|
|
|
|
silentmessage("Sector %d visibility %d",searchsector,sector[searchsector].visibility);
|
|
asksave = 1;
|
|
}
|
|
}
|
|
else // if !eitherALT
|
|
{
|
|
int32_t clamped=0;
|
|
|
|
k = (highlightsectorcnt>0 && (hlsectorbitmap[searchsector>>3]&(1<<(searchsector&7))));
|
|
tsign *= (1+3*eitherCTRL);
|
|
|
|
if (k == 0)
|
|
{
|
|
if (ASSERT_AIMING)
|
|
{
|
|
if (AIMING_AT_SPRITE && (show2dsprite[searchwall>>3]&(1<<(searchwall&7))))
|
|
{
|
|
for (i=0; i<highlightcnt; i++)
|
|
if (highlight[i]&16384)
|
|
clamped = addtobyte(&sprite[highlight[i]&16383].shade, tsign);
|
|
(clamped ? message : silentmessage)
|
|
("Highlighted sprite shade changed by %d%s",
|
|
tsign, clamped?" (some sprites' shade clamped)":"");
|
|
}
|
|
else
|
|
{
|
|
clamped = addtobyte(&AIMED_CF_SEL(shade), tsign);
|
|
(clamped ? message : silentmessage)
|
|
("%s %d shade %d%s", Typestr[searchstat], i,
|
|
AIMED_CF_SEL(shade), clamped ? " (clamped)":"");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i=0; i<highlightsectorcnt; i++)
|
|
{
|
|
dasector = highlightsector[i];
|
|
|
|
// sector shade
|
|
clamped |= addtobyte(§or[dasector].ceilingshade, tsign);
|
|
clamped |= addtobyte(§or[dasector].floorshade, tsign);
|
|
|
|
// wall shade
|
|
for (WALLS_OF_SECTOR(dasector, j))
|
|
clamped |= addtobyte(&wall[j].shade, tsign);
|
|
|
|
// sprite shade
|
|
for (j=headspritesect[dasector]; j!=-1; j=nextspritesect[j])
|
|
clamped |= addtobyte(&sprite[j].shade, tsign);
|
|
}
|
|
(clamped ? message : silentmessage)("Highlighted sector shade changed by %d%s", tsign,
|
|
clamped?" (some objects' shade clamped)":"");
|
|
}
|
|
asksave = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// PK: lmb only & mousewheel, -, and +, cycle picnum
|
|
if (keystatus[KEYSC_DASH] || keystatus[KEYSC_EQUAL] || (bstatus&(16|32) && (bstatus&1) && !(bstatus&2)))
|
|
{
|
|
if (ASSERT_AIMING)
|
|
{
|
|
j = i = (keystatus[KEYSC_EQUAL] || (bstatus&16)) ? 1 : -1;
|
|
|
|
while (!tilesizx[AIMED_SELOVR_PICNUM] || !tilesizy[AIMED_SELOVR_PICNUM] || j)
|
|
{
|
|
i += AIMED_SELOVR_PICNUM + MAXTILES;
|
|
AIMED_SELOVR_PICNUM = i % MAXTILES;
|
|
j = 0;
|
|
}
|
|
|
|
if (AIMING_AT_SPRITE)
|
|
correct_sprite_yoffset(searchwall);
|
|
|
|
asksave = 1;
|
|
}
|
|
keystatus[KEYSC_DASH] = keystatus[KEYSC_EQUAL] = 0;
|
|
mouseb &= ~(16|32);
|
|
}
|
|
|
|
if (PRESSED_KEYSC(E)) // E (expand)
|
|
{
|
|
if (AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
AIMED_CEILINGFLOOR(stat) ^= 8;
|
|
message("Sector %d %s texture expansion bit %s", searchsector, typestr[searchstat],
|
|
ONOFF(sector[searchsector].ceilingstat&8));
|
|
asksave = 1;
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(R)) // R (relative alignment, rotation)
|
|
{
|
|
if (keystatus[KEYSC_QUOTE]) // FRAMERATE TOGGLE
|
|
{
|
|
framerateon = !framerateon;
|
|
message("Show framerate %s", ONOFF(framerateon));
|
|
}
|
|
else
|
|
{
|
|
if (AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
AIMED_CEILINGFLOOR(stat) ^= 64;
|
|
message("Sector %d %s texture relativity bit %s", searchsector, typestr[searchstat],
|
|
ONOFF(AIMED_CEILINGFLOOR(stat)&64));
|
|
asksave = 1;
|
|
}
|
|
else if (AIMING_AT_SPRITE)
|
|
{
|
|
static const char *aligntype[4] = { "view", "wall", "floor", "???" };
|
|
|
|
i = sprite[searchwall].cstat;
|
|
if ((i&48) < 32) i += 16;
|
|
else i &= ~48;
|
|
sprite[searchwall].cstat = i;
|
|
|
|
message("Sprite %d now %s aligned", searchwall, aligntype[(i&48)/16]);
|
|
asksave = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(F)) //F (Flip)
|
|
{
|
|
if (eitherALT) //ALT-F (relative alignmment flip)
|
|
{
|
|
if (!AIMING_AT_SPRITE && ASSERT_AIMING)
|
|
SetFirstWall(searchsector, searchwall);
|
|
}
|
|
else
|
|
{
|
|
if (AIMING_AT_WALL_OR_MASK)
|
|
{
|
|
static const int32_t next[4] = { 1, 3, 0, 2 }; // 0->1->3->2->0
|
|
|
|
i = wall[searchbottomwall].cstat;
|
|
i = ((i>>3)&1)+((i>>7)&2); //3-x,8-y
|
|
|
|
i = next[i];
|
|
message("Wall %d flip %d",searchwall,i);
|
|
|
|
i = ((i&1)<<3)+((i&2)<<7);
|
|
wall[searchbottomwall].cstat &= ~0x0108;
|
|
wall[searchbottomwall].cstat |= i;
|
|
asksave = 1;
|
|
}
|
|
else if (AIMING_AT_CEILING_OR_FLOOR) //8-way ceiling/floor flipping (bits 2,4,5)
|
|
{
|
|
static const int32_t next[8] = { 6, 7, 4, 5, 0, 1, 3, 2 }; // 0->6->3->5->1->7->2->4->0
|
|
int16_t *stat = &SECTORFLD(searchsector,stat, AIMING_AT_FLOOR);
|
|
|
|
i = *stat;
|
|
i = (i&0x4)+((i>>4)&3);
|
|
i = next[i];
|
|
message("Sector %d %s flip %d", searchsector, typestr[searchstat], i);
|
|
i = (i&0x4)+((i&3)<<4);
|
|
*stat &= ~0x34;
|
|
*stat |= i;
|
|
asksave = 1;
|
|
}
|
|
else if (AIMING_AT_SPRITE)
|
|
{
|
|
i = sprite[searchwall].cstat;
|
|
if (((i&48) == 32) && ((i&64) == 0))
|
|
{
|
|
sprite[searchwall].cstat &= ~0xc;
|
|
sprite[searchwall].cstat |= ((i&4)^4);
|
|
message("Sprite %d flip bit %s",searchwall, ONOFF(sprite[searchwall].cstat&4));
|
|
}
|
|
else
|
|
{
|
|
int32_t next[4] = { 1, 3, 0, 2 }; // 0->1->3->2->0
|
|
i = ((i>>2)&3);
|
|
|
|
i = next[i];
|
|
message("Sprite %d flip %d",searchwall,i);
|
|
|
|
sprite[searchwall].cstat &= ~0xc;
|
|
sprite[searchwall].cstat |= (i<<2);
|
|
}
|
|
asksave = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if (keystatus[KEYSC_HOME])
|
|
updownunits = 256;
|
|
else if (keystatus[KEYSC_END])
|
|
updownunits = 512;
|
|
else
|
|
updownunits = 1024;
|
|
|
|
mouseaction=0;
|
|
if (eitherALT && (bstatus&1))
|
|
{
|
|
mousex=0; mskip=1;
|
|
if (mousey!=0)
|
|
{
|
|
updownunits=klabs(mousey*128);
|
|
mouseaction=1;
|
|
}
|
|
}
|
|
|
|
|
|
tsign = 0;
|
|
if (ASSERT_AIMING)
|
|
{
|
|
// PK: PGUP/PGDN, rmb only & mwheel
|
|
tsign -= (PRESSED_KEYSC(PGUP) || (mouseaction && mousey<0) || ((bstatus&(16|2|1))==(16|2)));
|
|
tsign += (PRESSED_KEYSC(PGDN) || (mouseaction && mousey>0) || ((bstatus&(32|2|1))==(32|2)));
|
|
}
|
|
|
|
if (tsign)
|
|
{
|
|
int16_t sect0, sect, havebtm=0, havetop=0, moveCeilings, moveFloors;
|
|
int32_t cz, fz;
|
|
|
|
k = 0;
|
|
if (highlightsectorcnt > 0 && searchsector>=0 && searchsector<numsectors)
|
|
{
|
|
if (hlsectorbitmap[searchsector>>3]&(1<<(searchsector&7)))
|
|
k = highlightsectorcnt;
|
|
}
|
|
|
|
if (k)
|
|
{
|
|
sect = highlightsector[0];
|
|
havetop = AIMING_AT_WALL_OR_MASK;
|
|
}
|
|
else
|
|
{
|
|
if (AIMING_AT_WALL_OR_MASK && wall[searchwall].nextsector>=0
|
|
&& eitherALT && !(bstatus&1))
|
|
{
|
|
sect = wall[searchwall].nextsector;
|
|
havebtm = !AIMING_AT_MASKWALL && searchisbottom;
|
|
havetop = !havebtm;
|
|
}
|
|
else
|
|
{
|
|
sect = searchsector;
|
|
havetop = AIMING_AT_WALL_OR_MASK;
|
|
}
|
|
}
|
|
|
|
sect0 = sect;
|
|
moveCeilings = (AIMING_AT_CEILING || havetop);
|
|
moveFloors = (AIMING_AT_FLOOR || havebtm);
|
|
|
|
if (moveCeilings || moveFloors)
|
|
{
|
|
int32_t dz = tsign * (updownunits << (eitherCTRL<<1)); // JBF 20031128
|
|
static const char *cfs[2] = { "ceiling", "floor" };
|
|
#ifdef YAX_ENABLE
|
|
int16_t bunchnum=-1, maxbunchnum=-1, cb, fb;
|
|
Bmemset(havebunch, 0, sizeof(havebunch));
|
|
#endif
|
|
for (j=0; j<(k?k:1); j++, sect=highlightsector[j])
|
|
{
|
|
// stage one: see if we don't move beyond the other side
|
|
// (ceiling if floor and vice versa)
|
|
|
|
if (moveCeilings && (dz > 0) && sector[sect].ceilingz+dz > sector[sect].floorz)
|
|
dz = (k > 1) ? 0 : min(sector[sect].floorz - sector[sect].ceilingz, dz);
|
|
else if (moveFloors && (dz < 0) && sector[sect].floorz+dz < sector[sect].ceilingz)
|
|
dz = (k > 1) ? 0 : max(sector[sect].ceilingz - sector[sect].floorz, dz);
|
|
|
|
if (dz == 0)
|
|
break;
|
|
}
|
|
|
|
if (dz)
|
|
{
|
|
// now truly move things if we're clear to go!
|
|
sect = sect0;
|
|
for (j=0; j<(k?k:1); j++, sect=highlightsector[j])
|
|
{
|
|
for (i=headspritesect[sect]; i!=-1; i=nextspritesect[i])
|
|
{
|
|
spriteoncfz(i, &cz, &fz);
|
|
if ((moveCeilings && sprite[i].z == cz) || (moveFloors && sprite[i].z == fz))
|
|
sprite[i].z += dz;
|
|
}
|
|
|
|
SECTORFLD(sect,z, moveFloors) += dz;
|
|
#ifdef YAX_ENABLE
|
|
bunchnum = yax_getbunch(sect, moveFloors);
|
|
if (bunchnum >= 0 && !(havebunch[bunchnum>>3]&(1<<(bunchnum&7))))
|
|
{
|
|
maxbunchnum = max(maxbunchnum, bunchnum);
|
|
havebunch[bunchnum>>3] |= (1<<(bunchnum&7));
|
|
tempzar[bunchnum] = &SECTORFLD(sect,z, moveFloors);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#ifdef YAX_ENABLE
|
|
if (dz)
|
|
{
|
|
// sync z values of extended sectors' ceilings/floors
|
|
for (i=0; i<numsectors; i++)
|
|
{
|
|
yax_getbunches(i, &cb, &fb);
|
|
if (cb >= 0 && (havebunch[cb>>3]&(1<<(cb&7))))
|
|
sector[i].ceilingz = *tempzar[cb];
|
|
if (fb >= 0 && (havebunch[fb>>3]&(1<<(fb&7))))
|
|
sector[i].floorz = *tempzar[fb];
|
|
}
|
|
}
|
|
|
|
if (!dz)
|
|
silentmessage("Didn't move sector %ss", cfs[moveFloors]);
|
|
else if (k<=1 && bunchnum>=0)
|
|
silentmessage("Bunch %d's ceilings and floors = %d", bunchnum, SECTORFLD(sect0,z, moveFloors));
|
|
else
|
|
#endif
|
|
if (k<=1)
|
|
silentmessage("Sector %d %sz = %d", sect0, cfs[moveFloors], SECTORFLD(sect0,z, moveFloors));
|
|
else
|
|
silentmessage("%s %d sector %ss by %d units", tsign<0 ? "Raised" : "Lowered",
|
|
k, cfs[moveFloors], dz*tsign);
|
|
}
|
|
|
|
if (AIMING_AT_SPRITE)
|
|
{
|
|
int32_t cz, fz;
|
|
|
|
if (eitherCTRL && !eitherALT) //CTRL - put sprite on ceiling/floor
|
|
{
|
|
spriteoncfz(searchwall, &cz, &fz);
|
|
sprite[searchwall].z = (tsign==1) ? fz : cz;
|
|
}
|
|
else
|
|
{
|
|
k = !!(show2dsprite[searchwall>>3]&(1<<(searchwall&7)));
|
|
|
|
tsign *= (updownunits << ((eitherCTRL && mouseaction)*3));
|
|
|
|
for (i=0; i<highlightcnt || k==0; i++)
|
|
{
|
|
if (k==0 || (highlight[i]&0xc000) == 16384)
|
|
{
|
|
int16_t sp = k==0 ? searchwall : highlight[i]&16383;
|
|
|
|
sprite[sp].z += tsign;
|
|
|
|
if (!spnoclip)
|
|
{
|
|
spriteoncfz(sp, &cz, &fz);
|
|
inpclamp(&sprite[sp].z, cz, fz);
|
|
}
|
|
#ifdef YAX_ENABLE
|
|
else if (sprite[sp].sectnum >= 0)
|
|
{
|
|
int16_t cb, fb;
|
|
yax_getbunches(sprite[sp].sectnum, &cb, &fb);
|
|
if (cb >= 0 || fb >= 0)
|
|
setspritez(sp, (vec3_t *)&sprite[sp]);
|
|
}
|
|
#endif
|
|
if (k==0)
|
|
{
|
|
silentmessage("Sprite %d z = %d", searchwall, sprite[searchwall].z);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (k==1)
|
|
silentmessage("Sprites %s by %d units", tsign<0 ? "raised" : "lowered", tsign);
|
|
}
|
|
}
|
|
}
|
|
|
|
asksave = 1;
|
|
mouseb &= ~(16|32);
|
|
}
|
|
|
|
/* end Mapster32 */
|
|
|
|
// DoWater(horiz);
|
|
|
|
if (framerateon)
|
|
{
|
|
static int32_t FrameCount = 0;
|
|
static int32_t LastCount = 0;
|
|
static int32_t LastSec = 0;
|
|
static int32_t LastMS = 0;
|
|
|
|
int32_t ms = getticks();
|
|
int32_t howlong = ms - LastMS;
|
|
|
|
if (howlong >= 0)
|
|
{
|
|
int32_t thisSec = ms/1000;
|
|
int32_t x = (xdim <= 640);
|
|
int32_t chars = Bsprintf(tempbuf, "%2u ms (%3u fps)", howlong, LastCount);
|
|
|
|
if (!x)
|
|
{
|
|
printext256(windowx2-(chars<<3)+1,windowy1+2,0,-1,tempbuf,x);
|
|
printext256(windowx2-(chars<<3),windowy1+1,COLOR_WHITE,-1,tempbuf,x);
|
|
}
|
|
else
|
|
{
|
|
printext256(windowx2-(chars<<2)+1,windowy1+2,0,-1,tempbuf,x);
|
|
printext256(windowx2-(chars<<2),windowy1+1,COLOR_WHITE,-1,tempbuf,x);
|
|
}
|
|
|
|
if (LastSec < thisSec)
|
|
{
|
|
LastCount = FrameCount / (thisSec - LastSec);
|
|
LastSec = thisSec;
|
|
FrameCount = 0;
|
|
}
|
|
FrameCount++;
|
|
}
|
|
LastMS = ms;
|
|
}
|
|
|
|
tempbuf[0] = 0;
|
|
|
|
if ((bstatus&(4|2|1))==4 && !unrealedlook) //PK
|
|
Bsprintf(tempbuf,"VIEW");
|
|
else if ((bstatus&(2|1))==2)
|
|
Bsprintf(tempbuf,"Z%s", keystatus[KEYSC_HOME]?" 256":keystatus[KEYSC_END]?" 512":"");
|
|
|
|
if ((bstatus&(2|1))==1 || (keystatus[KEYSC_SPACE]))
|
|
Bsprintf(tempbuf,"LOCK");
|
|
|
|
if (bstatus&1)
|
|
{
|
|
switch (searchstat)
|
|
{
|
|
case SEARCH_WALL:
|
|
case SEARCH_MASKWALL:
|
|
if (eitherALT)
|
|
Bsprintf(tempbuf,"CEILING Z %s", eitherCTRL?"512":"");
|
|
else if (eitherSHIFT)
|
|
Bsprintf(tempbuf,"PAN %s", eitherCTRL?"8":"");
|
|
else if (eitherCTRL)
|
|
Bsprintf(tempbuf,"SCALE");
|
|
break;
|
|
case SEARCH_CEILING:
|
|
case SEARCH_FLOOR:
|
|
if (eitherALT)
|
|
Bsprintf(tempbuf,"%s Z %s", AIMING_AT_CEILING?"CEILING":"FLOOR", eitherCTRL?"512":"");
|
|
else if (eitherSHIFT)
|
|
Bsprintf(tempbuf,"PAN");
|
|
else if (eitherCTRL)
|
|
Bsprintf(tempbuf,"SLOPE");
|
|
break;
|
|
case SEARCH_SPRITE:
|
|
if (eitherALT)
|
|
Bsprintf(tempbuf,"MOVE Z %s", eitherCTRL?"1024":"");
|
|
else if (eitherSHIFT)
|
|
Bsprintf(tempbuf,"MOVE XY %s", eitherCTRL?"GRID":"");
|
|
else if (eitherCTRL)
|
|
Bsprintf(tempbuf,"SIZE");
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (tempbuf[0] != 0)
|
|
{
|
|
i = (Bstrlen(tempbuf)<<3)+6;
|
|
i = max((searchx+i)-(xdim-1), 0);
|
|
|
|
j = max((searchy+16)-(ydim-1), 0);
|
|
|
|
// printext16(searchx+6-i,searchy+6-j,11,-1,tempbuf,0);
|
|
printext256(searchx+4+2-i, searchy+4+2-j, 0,-1,tempbuf,!(xdimgame > 640));
|
|
printext256(searchx+4-i, searchy+4-j, whitecol,-1,tempbuf,!(xdimgame > 640));
|
|
|
|
// printext256(searchx+4+2,searchy+4+2,0,-1,tempbuf,!(xdimgame > 640));
|
|
// printext256(searchx+4,searchy+4,whitecol,-1,tempbuf,!(xdimgame > 640));
|
|
}
|
|
if (helpon==1)
|
|
{
|
|
int32_t small = !(xdimgame > 640);
|
|
for (i=0; i<MAXHELP3D; i++)
|
|
{
|
|
begindrawing();
|
|
printext256(2, 8+(i*(8+!small))+2, 0, -1, Help3d[i], small);
|
|
printext256(0, 8+(i*(8+!small)), whitecol, -1, Help3d[i], small);
|
|
enddrawing();
|
|
|
|
switch (i)
|
|
{
|
|
case 8:
|
|
Bsprintf(tempbuf,"%d",autosave);
|
|
break;
|
|
case 9:
|
|
Bsprintf(tempbuf,"%s",SKILLMODE[skill]);
|
|
break;
|
|
case 10:
|
|
Bsprintf(tempbuf,"%d",framerateon);
|
|
break;
|
|
case 11:
|
|
Bsprintf(tempbuf,"%s",SPRDSPMODE[nosprites]);
|
|
break;
|
|
case 12:
|
|
Bsprintf(tempbuf,"%d",shadepreview);
|
|
break;
|
|
case 13:
|
|
Bsprintf(tempbuf,"%d",showinvisibility);
|
|
break;
|
|
default :
|
|
Bsprintf(tempbuf," ");
|
|
break;
|
|
}
|
|
|
|
begindrawing();
|
|
if (!Bstrcmp(tempbuf,"0"))
|
|
Bsprintf(tempbuf,"OFF");
|
|
else if (!Bstrcmp(tempbuf,"1"))
|
|
Bsprintf(tempbuf,"ON");
|
|
else if (!Bstrcmp(tempbuf,"2"))
|
|
Bsprintf(tempbuf,"ON (2)");
|
|
|
|
printext256((20+(!small * 20))*8+2, 8+(i*(8+!small))+2, 0, -1, tempbuf, small);
|
|
printext256((20+(!small * 20))*8, 8+(i*(8+!small)), whitecol, -1, tempbuf, small);
|
|
enddrawing();
|
|
}
|
|
}
|
|
|
|
if (cursectnum>=0 && sector[cursectnum].lotag==2)
|
|
{
|
|
if (sector[cursectnum].ceilingpicnum==FLOORSLIME)
|
|
SetSLIMEPalette();
|
|
else
|
|
SetWATERPalette();
|
|
}
|
|
else SetGAMEPalette();
|
|
|
|
if (keystatus[buildkeys[BK_MODE2D_3D]]) // Enter
|
|
{
|
|
SetGAMEPalette();
|
|
FX_StopAllSounds();
|
|
S_ClearSoundLocks();
|
|
|
|
#ifdef POLYMER
|
|
DeletePolymerLights();
|
|
#endif
|
|
}
|
|
|
|
//Stick this in 3D part of ExtCheckKeys
|
|
//Also choose your own key scan codes
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(D)) // ' d
|
|
/* { ShowHelpText("SectorEffector"); } */
|
|
{
|
|
skill = (skill+1)%MAXSKILL;
|
|
message("%s", SKILLMODE[skill]);
|
|
// printext256(1*4,1*8,11,-1,tempbuf,0);
|
|
}
|
|
|
|
if (keystatus[KEYSC_I])
|
|
{
|
|
keystatus[KEYSC_I] = 0;
|
|
|
|
if (keystatus[KEYSC_QUOTE])
|
|
{
|
|
if (AIMING_AT_SPRITE)
|
|
{
|
|
sprite[searchwall].cstat ^= 32768;
|
|
message("Sprite %d made %svisible", searchwall, (sprite[searchwall].cstat&32768) ? "in":"");
|
|
}
|
|
}
|
|
else // ' i
|
|
{
|
|
showinvisibility = !showinvisibility;
|
|
#ifndef YAX_ENABLE
|
|
message("Show invisible sprites %s", showinvisibility?"enabled":"disabled");
|
|
#else
|
|
message("Show invisible objects %s", showinvisibility?"enabled":"disabled");
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(X)) // ' x
|
|
{
|
|
shadepreview = !shadepreview;
|
|
message("Map shade preview %s", shadepreview?"enabled":"disabled");
|
|
|
|
#ifdef POLYMER
|
|
DeletePolymerLights();
|
|
#endif
|
|
}
|
|
///___unused_keys___
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(W)) // ' w
|
|
{
|
|
nosprites = (nosprites+1)%MAXNOSPRITES;
|
|
message("%s", SPRDSPMODE[nosprites]);
|
|
}
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(Y)) // ' y
|
|
{
|
|
purpleon = !purpleon;
|
|
if (nosprites>3) nosprites=0;
|
|
message("Purple %s", ONOFF(purpleon));
|
|
}
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(C)) // ' C
|
|
{
|
|
if (AIMING_AT_WALL_OR_MASK)
|
|
{
|
|
for (i=0; i<MAXWALLS; i++)
|
|
if (wall[i].picnum==temppicnum)
|
|
wall[i].shade=tempshade;
|
|
}
|
|
else if (AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
for (i=0; i<MAXSECTORS; i++)
|
|
if (CEILINGFLOOR(i, picnum)==temppicnum)
|
|
CEILINGFLOOR(i, shade)=tempshade;
|
|
}
|
|
else if (AIMING_AT_SPRITE)
|
|
{
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
if (sprite[i].picnum==temppicnum)
|
|
sprite[i].shade=tempshade;
|
|
}
|
|
|
|
if (ASSERT_AIMING)
|
|
{
|
|
message("%ss with picnum %d now have shade of %d", Typestr[searchstat], temppicnum, tempshade);
|
|
asksave = 1;
|
|
}
|
|
}
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(T)) // ' T
|
|
{
|
|
j = 0;
|
|
if (AIMING_AT_WALL || AIMING_AT_SPRITE)
|
|
{
|
|
j = taglab_linktags(AIMING_AT_SPRITE, searchwall);
|
|
j = 4*(j&1);
|
|
}
|
|
|
|
if (AIMING_AT_WALL_OR_MASK)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getnextwall(searchwall, YAX_CEILING)>=0)
|
|
message("Can't change lotag in protected wall");
|
|
else
|
|
#endif
|
|
wall[searchwall].lotag = getnumber256("Wall lotag: ", wall[searchwall].lotag, BTAG_MAX, 0+j);
|
|
}
|
|
else if (AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
sector[searchsector].lotag =
|
|
_getnumber256("Sector lotag: ", sector[searchsector].lotag, BTAG_MAX, 0, (void *)ExtGetSectorType);
|
|
}
|
|
else if (AIMING_AT_SPRITE)
|
|
{
|
|
if (sprite[searchwall].picnum == SECTOREFFECTOR)
|
|
{
|
|
sprite[searchwall].lotag =
|
|
_getnumber256("Sprite lotag: ", sprite[searchwall].lotag, BTAG_MAX, 0+j, (void *)SectorEffectorTagText);
|
|
}
|
|
else if (sprite[searchwall].picnum == MUSICANDSFX)
|
|
{
|
|
int16_t oldtag = sprite[searchwall].lotag;
|
|
|
|
sprite[searchwall].lotag =
|
|
_getnumber256("Sprite lotag: ", sprite[searchwall].lotag, BTAG_MAX, 0+j, (void *)MusicAndSFXTagText);
|
|
|
|
if ((sprite[searchwall].filler&1) && sprite[searchwall].lotag != oldtag)
|
|
{
|
|
sprite[searchwall].filler &= ~1;
|
|
S_StopEnvSound(oldtag, searchwall);
|
|
}
|
|
}
|
|
else
|
|
sprite[searchwall].lotag = getnumber256("Sprite lotag: ", sprite[searchwall].lotag, BTAG_MAX, 0+j);
|
|
}
|
|
}
|
|
#if 0
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(H)) // ' H
|
|
{
|
|
if (ASSERT_AIMING)
|
|
{
|
|
int16_t ohitag = AIMED(hitag);
|
|
Bsprintf(tempbuf, "%s hitag: ", Typestr_wss[searchstat]);
|
|
AIMED(hitag) = getnumber256(tempbuf, ohitag, BTAG_MAX,0);
|
|
if (AIMED(hitag) != ohitag)
|
|
asksave = 1;
|
|
}
|
|
}
|
|
#endif
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(S)) // ' S
|
|
{
|
|
if (ASSERT_AIMING)
|
|
{
|
|
int8_t oshade = AIMED_CF_SEL(shade);
|
|
Bsprintf(tempbuf, "%s shade: ", Typestr[searchstat]);
|
|
getnumberptr256(tempbuf, &AIMED_CF_SEL(shade), sizeof(int8_t), 128, 1, NULL);
|
|
if (AIMED_CF_SEL(shade) != oshade)
|
|
asksave = 1;
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(F2)) // F2
|
|
{
|
|
if (eitherCTRL || eitherSHIFT)
|
|
infobox ^= (eitherSHIFT | ((eitherCTRL)<<1));
|
|
else
|
|
usedcount = !usedcount;
|
|
}
|
|
|
|
#if 0
|
|
if (keystatus[KEYSC_TAB]) // TAB : USED
|
|
{
|
|
// usedcount=!usedcount;
|
|
count=0;
|
|
|
|
for (i=0; i<numwalls; i++)
|
|
{
|
|
if (wall[i].picnum == temppicnum) count++;
|
|
if (wall[i].overpicnum == temppicnum) count++;
|
|
}
|
|
for (i=0; i<numsectors; i++) // JBF 20040307: was numwalls, thanks Semicharm
|
|
{
|
|
if (sector[i].ceilingpicnum == temppicnum) count++;
|
|
if (sector[i].floorpicnum == temppicnum) count++;
|
|
}
|
|
|
|
statnum = 0; //status 1
|
|
i = headspritestat[statnum];
|
|
while (i != -1)
|
|
{
|
|
nexti = nextspritestat[i];
|
|
|
|
//your code goes here
|
|
//ex: printf("Sprite %d has a status of 1 (active)\n",i,statnum);
|
|
|
|
if (sprite[i].picnum == temppicnum) count++;
|
|
i = nexti;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (PRESSED_KEYSC(F1)) // F1
|
|
{
|
|
helpon = !helpon;
|
|
// keystatus[KEYSC_H]=0; // delete this line?
|
|
}
|
|
|
|
if (PRESSED_KEYSC(G)) // G
|
|
{
|
|
if (ASSERT_AIMING)
|
|
{
|
|
int32_t aiming_at_sprite = AIMING_AT_SPRITE, osearchwall=searchwall;
|
|
int16_t *picnumptr = AIMING_AT_WALL_OR_MASK ? &AIMED_SELOVR_PICNUM : &AIMED_CF_SEL(picnum);
|
|
|
|
static const char *Typestr_tmp[5] = { "Wall", "Sector ceiling", "Sector floor", "Sprite", "Masked wall" };
|
|
|
|
Bsprintf(tempbuf, "%s picnum: ", Typestr_tmp[searchstat]);
|
|
getnumberptr256(tempbuf, picnumptr, sizeof(int16_t), MAXTILES-1, 0+2, NULL);
|
|
if (*picnumptr != AIMED_CF_SEL(picnum))
|
|
asksave = 1;
|
|
|
|
// need to use the old value because aiming might have changed in getnumberptr256
|
|
if (aiming_at_sprite)
|
|
correct_sprite_yoffset(osearchwall);
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(B)) // B (clip Blocking xor) (3D)
|
|
{
|
|
if (AIMING_AT_SPRITE)
|
|
{
|
|
sprite[searchwall].cstat ^= 1;
|
|
// sprite[searchwall].cstat &= ~256;
|
|
// sprite[searchwall].cstat |= ((sprite[searchwall].cstat&1)<<8);
|
|
message("Sprite %d blocking bit %s", searchwall, ONOFF(sprite[searchwall].cstat&1));
|
|
asksave = 1;
|
|
}
|
|
else if (AIMING_AT_WALL_OR_MASK || AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if (AIMING_AT_CEILING_OR_FLOOR && yax_getbunch(searchsector, AIMING_AT_FLOOR)>=0)
|
|
{
|
|
SECTORFLD(searchsector,stat, AIMING_AT_FLOOR) ^= 512;
|
|
message("Sector %d's %s blocking bit %s", searchsector, typestr[searchstat],
|
|
ONOFF(SECTORFLD(searchsector,stat, AIMING_AT_FLOOR)&512));
|
|
asksave = 1;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
wall[searchwall].cstat ^= 1;
|
|
// wall[searchwall].cstat &= ~64;
|
|
if ((wall[searchwall].nextwall >= 0) && !eitherSHIFT)
|
|
{
|
|
NEXTWALL(searchwall).cstat &= ~(1+64);
|
|
NEXTWALL(searchwall).cstat |= (wall[searchwall].cstat&1);
|
|
}
|
|
|
|
message("Wall %d blocking bit %s%s", searchwall, ONOFF(wall[searchwall].cstat&1),
|
|
eitherSHIFT ? " (one-sided)":"");
|
|
asksave = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// N (set "spritenoshade" bit)
|
|
if (PRESSED_KEYSC(N) && !eitherCTRL && !keystatus[KEYSC_QUOTE])
|
|
{
|
|
if (AIMING_AT_SPRITE)
|
|
{
|
|
sprite[searchwall].cstat ^= 2048;
|
|
message("Sprite %d spritenoshade bit: %s", searchwall, ONOFF(sprite[searchwall].cstat&2048));
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(T)) // T (transluscence for sprites/masked walls)
|
|
{
|
|
if (AIMING_AT_CEILING_OR_FLOOR) //Set masked/transluscent ceilings/floors
|
|
{
|
|
int32_t nexti[4] = { 128, 256, 384, 0 };
|
|
int16_t *stat = &AIMED_CEILINGFLOOR(stat);
|
|
const char *statmsg[4] = {"normal", "masked", "translucent", "translucent (2)"};
|
|
|
|
i = (*stat&(128+256))>>7;
|
|
i = nexti[i];
|
|
*stat &= ~(128+256);
|
|
*stat |= i;
|
|
|
|
message("Sector %d's %s made %s.", searchsector, typestr[searchstat], statmsg[i>>7]);
|
|
|
|
asksave = 1;
|
|
}
|
|
|
|
if (keystatus[KEYSC_QUOTE])
|
|
{
|
|
if (ASSERT_AIMING)
|
|
{
|
|
int32_t olotag = AIMED(lotag);
|
|
Bsprintf(tempbuf, "%s lotag: ", Typestr_wss[searchstat]);
|
|
AIMED(lotag) = getnumber256(tempbuf, AIMED(lotag), BTAG_MAX, 0);
|
|
if (olotag != AIMED(lotag))
|
|
asksave = 1;
|
|
}
|
|
}
|
|
else if (eitherCTRL)
|
|
{
|
|
if (AIMING_AT_SPRITE)
|
|
TextEntryMode(searchwall);
|
|
}
|
|
else
|
|
{
|
|
if (AIMING_AT_SPRITE)
|
|
{
|
|
if ((sprite[searchwall].cstat&2) == 0)
|
|
sprite[searchwall].cstat |= 2;
|
|
else if ((sprite[searchwall].cstat&512) == 0)
|
|
sprite[searchwall].cstat |= 512;
|
|
else
|
|
sprite[searchwall].cstat &= ~(2+512);
|
|
asksave = 1;
|
|
}
|
|
else if (AIMING_AT_MASKWALL)
|
|
{
|
|
if ((wall[searchwall].cstat&128) == 0)
|
|
wall[searchwall].cstat |= 128;
|
|
else if ((wall[searchwall].cstat&512) == 0)
|
|
wall[searchwall].cstat |= 512;
|
|
else
|
|
wall[searchwall].cstat &= ~(128+512);
|
|
|
|
if (wall[searchwall].nextwall >= 0)
|
|
{
|
|
NEXTWALL(searchwall).cstat &= ~(128+512);
|
|
NEXTWALL(searchwall).cstat |= (wall[searchwall].cstat&(128+512));
|
|
}
|
|
asksave = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------
|
|
i = 512;
|
|
if (keystatus[KEYSC_RSHIFT]) i = 8;
|
|
if (keystatus[KEYSC_LSHIFT]) i = 1;
|
|
mouseaction=0;
|
|
|
|
if (eitherCTRL && !eitherSHIFT && (bstatus&1) && AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
mousex=0; mskip=1;
|
|
if (mousey)
|
|
{
|
|
i=klabs(mousey*2);
|
|
mouseaction=1;
|
|
}
|
|
}
|
|
|
|
tsign = 0;
|
|
if (ASSERT_AIMING)
|
|
{
|
|
tsign -= (PRESSED_KEYSC(LBRACK) || (mouseaction && mousey<0)); // [
|
|
tsign += (PRESSED_KEYSC(RBRACK) || (mouseaction && mousey>0)); // ]
|
|
}
|
|
|
|
if (tsign)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
int16_t bunchnum, othersidesect=0;
|
|
#endif
|
|
if (eitherALT)
|
|
{
|
|
int32_t ns=wall[searchwall].nextsector, sx=wall[searchwall].x, sy=wall[searchwall].y;
|
|
|
|
if (ns >= 0 && !mouseaction)
|
|
{
|
|
if (AIMING_AT_CEILING || (tsign < 0 && AIMING_AT_WALL_OR_MASK))
|
|
#ifdef YAX_ENABLE
|
|
if (YAXCHK((bunchnum=yax_getbunch(searchsector, YAX_CEILING)) < 0 ||
|
|
(othersidesect=yax_is121(bunchnum, 1))>=0) &&
|
|
(bunchnum < 0 || YAXSLOPECHK(searchsector, othersidesect)))
|
|
#endif
|
|
{
|
|
alignceilslope(searchsector, sx, sy, getceilzofslope(ns, sx, sy));
|
|
#ifdef YAX_ENABLE
|
|
if (bunchnum>=0)
|
|
setslope(othersidesect, 1, sector[searchsector].ceilingheinum);
|
|
#endif
|
|
message("Sector %d align ceiling to wall %d", searchsector, searchwall);
|
|
}
|
|
|
|
if (AIMING_AT_FLOOR || (tsign > 0 && AIMING_AT_WALL_OR_MASK))
|
|
#ifdef YAX_ENABLE
|
|
if (YAXCHK((bunchnum=yax_getbunch(searchsector, YAX_FLOOR)) < 0 ||
|
|
(othersidesect=yax_is121(bunchnum, 0))>=0) &&
|
|
(bunchnum < 0 || YAXSLOPECHK(searchsector, othersidesect)))
|
|
#endif
|
|
{
|
|
alignflorslope(searchsector, sx, sy, getflorzofslope(ns, sx, sy));
|
|
#ifdef YAX_ENABLE
|
|
if (bunchnum>=0)
|
|
setslope(othersidesect, 0, sector[searchsector].floorheinum);
|
|
#endif
|
|
message("Sector %d align floor to wall %d", searchsector, searchwall);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (AIMING_AT_CEILING_OR_FLOOR)
|
|
#ifdef YAX_ENABLE
|
|
if (YAXCHK((bunchnum=yax_getbunch(searchsector, AIMING_AT_FLOOR)) < 0 ||
|
|
(othersidesect=yax_is121(bunchnum, AIMING_AT_CEILING))>=0) &&
|
|
(bunchnum < 0 || YAXSLOPECHK(searchsector, othersidesect)))
|
|
#endif
|
|
{
|
|
int32_t oldslope = (AIMED_CEILINGFLOOR(stat)&2) ? AIMED_CEILINGFLOOR(heinum) : 0;
|
|
int32_t newslope = clamp(oldslope + tsign*i, -BHEINUM_MAX, BHEINUM_MAX);
|
|
|
|
setslope(searchsector, AIMING_AT_FLOOR, newslope);
|
|
#ifdef YAX_ENABLE
|
|
if (bunchnum >= 0)
|
|
setslope(othersidesect, !AIMING_AT_FLOOR, newslope);
|
|
#endif
|
|
silentmessage("Sector %d %s slope = %d", searchsector,
|
|
typestr[searchstat], AIMED_CEILINGFLOOR(heinum));
|
|
}
|
|
}
|
|
|
|
asksave = 1;
|
|
}
|
|
|
|
|
|
if ((bstatus&1) && eitherSHIFT)
|
|
mskip=1;
|
|
|
|
if ((bstatus&1) && eitherSHIFT && AIMING_AT_CEILING_OR_FLOOR && (mousex|mousey))
|
|
{
|
|
int32_t fw,x1,y1,x2,y2,stat,ma,a=0;
|
|
|
|
stat = SECTORFLD(searchsector,stat, AIMING_AT_FLOOR);
|
|
if (stat&64) // align to first wall
|
|
{
|
|
fw=sector[searchsector].wallptr;
|
|
x1=wall[fw].x,y1=wall[fw].y;
|
|
x2=POINT2(fw).x,y2=POINT2(fw).y;
|
|
a=getangle(x1-x2,y1-y2);
|
|
}
|
|
mouseax+=mousex; mouseay+=mousey;
|
|
ma = getangle(mouseax,mouseay);
|
|
ma += ang-a;
|
|
|
|
i = stat;
|
|
i = (i&0x4)+((i>>4)&3);
|
|
if (stat&64) // align to first wall
|
|
switch (i)
|
|
{
|
|
case 0:break;
|
|
case 1:ma=-ma; break;
|
|
case 2:ma=1024-ma; break;
|
|
case 3:ma+=1024; break;
|
|
case 4:ma=-512-ma; break;
|
|
case 5:ma+=512; break;
|
|
case 6:ma-=512; break;
|
|
case 7:ma=512-ma; break;
|
|
}
|
|
else
|
|
switch (i)
|
|
{
|
|
case 0:ma=-ma; break;
|
|
case 1:break;
|
|
case 2:ma+=1024; break;
|
|
case 3:ma=1024-ma; break;
|
|
case 4:ma-=512; break;
|
|
case 5:ma=512-ma; break;
|
|
case 6:ma=-512-ma; break;
|
|
case 7:ma+=512; break;
|
|
}
|
|
|
|
a = ksqrt(mouseax*mouseax + mouseay*mouseay);
|
|
if (a)
|
|
{
|
|
int32_t mult = (stat&8) ? 8192 : 8192*2;
|
|
x1 = -a*sintable[(ma+2048)&2047]/mult;
|
|
y1 = -a*sintable[(ma+1536)&2047]/mult;
|
|
|
|
if (x1||y1)
|
|
{
|
|
mouseax=0;
|
|
mouseay=0;
|
|
|
|
if (AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
changedir = 1-2*(x1<0);
|
|
x1 = klabs(x1);
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getbunch(searchsector, AIMING_AT_FLOOR) < 0)
|
|
#endif
|
|
while (x1--)
|
|
AIMED_CEILINGFLOOR(xpanning) = changechar(AIMED_CEILINGFLOOR(xpanning),changedir,0,0);
|
|
|
|
changedir = 1-2*(y1<0);
|
|
y1 = klabs(y1);
|
|
|
|
while (y1--)
|
|
AIMED_CEILINGFLOOR(ypanning) = changechar(AIMED_CEILINGFLOOR(ypanning),changedir,0,0);
|
|
|
|
silentmessage("Sector %d %s panning: %d, %d", searchsector, typestr[searchstat],
|
|
AIMED_CEILINGFLOOR(xpanning), AIMED_CEILINGFLOOR(ypanning));
|
|
asksave=1;
|
|
}
|
|
}
|
|
}
|
|
mousex=0;
|
|
mousey=0;
|
|
}
|
|
|
|
|
|
smooshyalign = keystatus[KEYSC_gKP5];
|
|
repeatpanalign = eitherSHIFT || eitherALT;
|
|
|
|
////////////////////
|
|
updownunits=1;
|
|
mouseaction=0;
|
|
|
|
if (!mouseb)
|
|
{
|
|
mouseax=0;
|
|
mouseay=0;
|
|
}
|
|
|
|
if ((bstatus&1) && !AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
if (eitherSHIFT)
|
|
{
|
|
mskip=1;
|
|
if (mousex)
|
|
{
|
|
mouseaction = 1;
|
|
mouseax += mousex;
|
|
updownunits = klabs(mouseax/2);
|
|
if (updownunits)
|
|
mouseax=0;
|
|
}
|
|
}
|
|
else if (eitherCTRL && !eitherALT)
|
|
{
|
|
mskip=1;
|
|
if (mousex)
|
|
{
|
|
mouseaction = 2;
|
|
repeatpanalign = 0;
|
|
updownunits = klabs(mouseax+=mousex)/(16 - 12*AIMING_AT_SPRITE);
|
|
if (updownunits)
|
|
mouseax=0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (keystatus[KEYSC_gLEFT] || keystatus[KEYSC_gRIGHT] || mouseaction) // 4 & 6 (keypad)
|
|
{
|
|
if (repeatcountx == 0 || repeatcountx > 32 || mouseaction)
|
|
{
|
|
changedir = 0;
|
|
if (keystatus[KEYSC_gLEFT] || mousex>0)
|
|
changedir = -1;
|
|
if (keystatus[KEYSC_gRIGHT] || mousex<0)
|
|
changedir = 1;
|
|
|
|
if (AIMING_AT_WALL_OR_MASK)
|
|
{
|
|
if (repeatpanalign == 0)
|
|
{
|
|
while (updownunits--)
|
|
wall[searchwall].xrepeat = changechar(wall[searchwall].xrepeat, changedir, smooshyalign, 1);
|
|
silentmessage("Wall %d repeat: %d, %d", searchwall,
|
|
wall[searchwall].xrepeat, wall[searchwall].yrepeat);
|
|
}
|
|
else
|
|
{
|
|
int16_t w = SELECT_WALL();
|
|
|
|
if (mouseaction)
|
|
{
|
|
i = wall[w].cstat;
|
|
i &= (8|256);
|
|
|
|
if (i==8 || i==256)
|
|
changedir*=-1;
|
|
|
|
if (eitherCTRL)
|
|
updownunits *= 8;
|
|
}
|
|
|
|
while (updownunits--)
|
|
wall[w].xpanning = changechar(wall[w].xpanning, changedir, smooshyalign, 0);
|
|
silentmessage("Wall %d panning: %d, %d", w, wall[w].xpanning, wall[w].ypanning);
|
|
}
|
|
asksave = 1;
|
|
}
|
|
else if (AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if (YAXCHK(yax_getbunch(searchsector, AIMING_AT_FLOOR) < 0))
|
|
#endif
|
|
{
|
|
while (updownunits--)
|
|
AIMED_CEILINGFLOOR(xpanning) = changechar(AIMED_CEILINGFLOOR(xpanning), changedir, smooshyalign, 0);
|
|
silentmessage("Sector %d %s panning: %d, %d", searchsector, typestr[searchstat],
|
|
AIMED_CEILINGFLOOR(xpanning), AIMED_CEILINGFLOOR(ypanning));
|
|
asksave = 1;
|
|
}
|
|
}
|
|
else if (AIMING_AT_SPRITE)
|
|
{
|
|
static int32_t sumxvect=0, sumyvect=0;
|
|
|
|
if (mouseaction==1)
|
|
mouseaction_movesprites(&sumxvect, &sumyvect, 1536, mousex);
|
|
else
|
|
{
|
|
sumxvect = sumyvect = 0;
|
|
if (mouseaction==2)
|
|
changedir *= -1;
|
|
while (updownunits--)
|
|
sprite[searchwall].xrepeat = changechar(sprite[searchwall].xrepeat, changedir, smooshyalign, 1);
|
|
if (sprite[searchwall].xrepeat < 4)
|
|
sprite[searchwall].xrepeat = 4;
|
|
silentmessage("Sprite %d repeat: %d, %d", searchwall,
|
|
sprite[searchwall].xrepeat, sprite[searchwall].yrepeat);
|
|
}
|
|
}
|
|
asksave = 1;
|
|
repeatcountx = max(1,repeatcountx-2);
|
|
}
|
|
repeatcountx += synctics;
|
|
}
|
|
else
|
|
repeatcountx = 0;
|
|
|
|
|
|
////////////////////
|
|
updownunits=1;
|
|
mouseaction=0;
|
|
|
|
if ((bstatus&1) && !AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
if (eitherSHIFT)
|
|
{
|
|
mskip=1;
|
|
if (mousey)
|
|
{
|
|
mouseaction = 1;
|
|
updownunits = klabs(mousey);
|
|
|
|
if (!AIMING_AT_SPRITE)
|
|
updownunits = klabs((int32_t)(mousey*128./tilesizy[wall[searchwall].picnum]));
|
|
}
|
|
}
|
|
else if (eitherCTRL && !eitherALT)
|
|
{
|
|
mskip=1;
|
|
if (mousey)
|
|
{
|
|
mouseaction = 2;
|
|
repeatpanalign = 0;
|
|
mouseay += mousey;
|
|
updownunits = klabs(mouseay)/(32 - 28*AIMING_AT_SPRITE);
|
|
if (updownunits)
|
|
mouseay=0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!mouseb)
|
|
{
|
|
mouseax=0;
|
|
mouseay=0;
|
|
}
|
|
|
|
if (keystatus[KEYSC_gUP] || keystatus[KEYSC_gDOWN] || mouseaction) // 2 & 8 (keypad)
|
|
{
|
|
if (repeatcounty == 0 || repeatcounty > 32 || mouseaction)
|
|
{
|
|
changedir = 0;
|
|
if (keystatus[KEYSC_gUP] || mousey>0)
|
|
changedir = -1;
|
|
if (keystatus[KEYSC_gDOWN] || mousey<0)
|
|
changedir = 1;
|
|
|
|
if (AIMING_AT_WALL_OR_MASK)
|
|
{
|
|
if (repeatpanalign == 0)
|
|
{
|
|
while (updownunits--)
|
|
wall[searchwall].yrepeat = changechar(wall[searchwall].yrepeat, changedir, smooshyalign, 1);
|
|
silentmessage("Wall %d repeat: %d, %d", searchwall,
|
|
wall[searchwall].xrepeat, wall[searchwall].yrepeat);
|
|
}
|
|
else
|
|
{
|
|
int16_t w = AIMING_AT_WALL?searchbottomwall:searchwall;
|
|
if (mouseaction && eitherCTRL)
|
|
updownunits *= 8;
|
|
while (updownunits--)
|
|
wall[w].ypanning = changechar(wall[w].ypanning, changedir, smooshyalign, 0);
|
|
silentmessage("Wall %d panning: %d, %d", w, wall[w].xpanning, wall[w].ypanning);
|
|
}
|
|
}
|
|
else if (AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
{
|
|
while (updownunits--)
|
|
AIMED_CEILINGFLOOR(ypanning) = changechar(AIMED_CEILINGFLOOR(ypanning), changedir, smooshyalign, 0);
|
|
silentmessage("Sector %d %s panning: %d, %d", searchsector, typestr[searchstat],
|
|
AIMED_CEILINGFLOOR(xpanning), AIMED_CEILINGFLOOR(ypanning));
|
|
asksave = 1;
|
|
}
|
|
}
|
|
else if (AIMING_AT_SPRITE)
|
|
{
|
|
static int32_t sumxvect=0, sumyvect=0;
|
|
|
|
if (mouseaction==1)
|
|
mouseaction_movesprites(&sumxvect, &sumyvect, 2048, mousey);
|
|
else
|
|
{
|
|
sumxvect = sumyvect = 0;
|
|
while (updownunits--)
|
|
sprite[searchwall].yrepeat = changechar(sprite[searchwall].yrepeat, changedir, smooshyalign, 1);
|
|
if (sprite[searchwall].yrepeat < 4)
|
|
sprite[searchwall].yrepeat = 4;
|
|
silentmessage("Sprite %d repeat: %d, %d", searchwall,
|
|
sprite[searchwall].xrepeat, sprite[searchwall].yrepeat);
|
|
}
|
|
}
|
|
asksave = 1;
|
|
repeatcounty = max(1,repeatcounty-2);
|
|
}
|
|
repeatcounty += synctics;
|
|
}
|
|
else
|
|
repeatcounty = 0;
|
|
|
|
////////////////////
|
|
|
|
if (PRESSED_KEYSC(F11)) //F11 - brightness
|
|
{
|
|
static int16_t brightness = -1;
|
|
|
|
if (brightness==-1)
|
|
brightness = ((int16_t)((vid_gamma-1.0)*10.0))&15;
|
|
|
|
brightness = brightness + (1-2*eitherSHIFT);
|
|
brightness &= 15;
|
|
|
|
vid_gamma = 1.0 + ((float)brightness / 10.0);
|
|
setbrightness(brightness, 0, 0);
|
|
message("Brightness: %d/16", brightness+1);
|
|
}
|
|
|
|
if (PRESSED_KEYSC(TAB)) //TAB
|
|
{
|
|
if (ASSERT_AIMING)
|
|
{
|
|
tempshade = AIMED_CF_SEL(shade);
|
|
temppal = AIMED_CF_SEL(pal);
|
|
templotag = AIMED_SEL(lotag);
|
|
temphitag = AIMED_SEL(hitag);
|
|
tempextra = AIMED_SEL(extra);
|
|
|
|
if (AIMING_AT_WALL_OR_MASK)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getnextwall(searchwall, YAX_CEILING) >= 0)
|
|
templotag = 0;
|
|
if (yax_getnextwall(searchwall, YAX_FLOOR) >= 0)
|
|
tempextra = -1;
|
|
#endif
|
|
temppicnum = AIMED_SELOVR_WALL(picnum);
|
|
tempxrepeat = AIMED_SEL_WALL(xrepeat);
|
|
tempxrepeat = max(1, tempxrepeat);
|
|
tempyrepeat = AIMED_SEL_WALL(yrepeat);
|
|
tempxpanning = AIMED_SEL_WALL(xpanning);
|
|
tempypanning = AIMED_SEL_WALL(ypanning);
|
|
tempcstat = AIMED_SEL_WALL(cstat) & ~YAX_NEXTWALLBITS;
|
|
templenrepquot = getlenbyrep(wallength(searchwall), tempxrepeat);
|
|
}
|
|
else if (AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
temppicnum = AIMED_CEILINGFLOOR(picnum);
|
|
tempvis = sector[searchsector].visibility;
|
|
tempxrepeat = AIMED_CEILINGFLOOR(xpanning);
|
|
tempyrepeat = AIMED_CEILINGFLOOR(ypanning);
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getbunch(searchsector, AIMING_AT_FLOOR) >= 0)
|
|
tempxrepeat = 0;
|
|
#endif
|
|
tempcstat = AIMED_CEILINGFLOOR(stat) & ~YAX_BIT;
|
|
}
|
|
else if (AIMING_AT_SPRITE)
|
|
{
|
|
temppicnum = sprite[searchwall].picnum;
|
|
tempxrepeat = sprite[searchwall].xrepeat;
|
|
tempyrepeat = sprite[searchwall].yrepeat;
|
|
tempcstat = sprite[searchwall].cstat;
|
|
tempxvel = sprite[searchwall].xvel;
|
|
tempyvel = sprite[searchwall].yvel;
|
|
tempzvel = sprite[searchwall].zvel;
|
|
}
|
|
|
|
somethingintab = searchstat;
|
|
}
|
|
}
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(ENTER)) // ' ENTER
|
|
{
|
|
if (AIMED_SELOVR_PICNUM != temppicnum)
|
|
{
|
|
AIMED_SELOVR_PICNUM = temppicnum;
|
|
asksave = 1;
|
|
}
|
|
|
|
if (AIMING_AT_SPRITE)
|
|
correct_sprite_yoffset(searchwall);
|
|
|
|
message("Pasted picnum only");
|
|
}
|
|
|
|
if (PRESSED_KEYSC(ENTER)) // ENTER -- paste clipboard contents
|
|
{
|
|
if (eitherSHIFT)
|
|
{
|
|
if (AIMING_AT_WALL_OR_MASK && eitherCTRL) //Ctrl-shift Enter (auto-shade)
|
|
{
|
|
int16_t daang;
|
|
int32_t dashade[2] = { 127, -128 };
|
|
|
|
i = searchwall;
|
|
do
|
|
{
|
|
dashade[0] = min(dashade[0], wall[i].shade);
|
|
dashade[1] = max(dashade[1], wall[i].shade);
|
|
|
|
i = wall[i].point2;
|
|
}
|
|
while (i != searchwall);
|
|
|
|
daang = getangle(POINT2(searchwall).x-wall[searchwall].x, POINT2(searchwall).y-wall[searchwall].y);
|
|
|
|
i = searchwall;
|
|
do
|
|
{
|
|
j = getangle(POINT2(i).x-wall[i].x,POINT2(i).y-wall[i].y);
|
|
k = (j+2048-daang)&2047;
|
|
if (k > 1024)
|
|
k = 2048-k;
|
|
|
|
wall[i].shade = dashade[0]+mulscale10(k, dashade[1]-dashade[0]);
|
|
|
|
i = wall[i].point2;
|
|
}
|
|
while (i != searchwall);
|
|
|
|
message("Auto-shaded wall %d's loop", searchwall);
|
|
asksave = 1;
|
|
}
|
|
else if (somethingintab < 255)
|
|
{
|
|
if (ASSERT_AIMING)
|
|
{
|
|
AIMED_CF_SEL(shade) = tempshade;
|
|
AIMED_CF_SEL(pal) = temppal;
|
|
|
|
k = 0;
|
|
if (AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
if (somethingintab == SEARCH_CEILING || somethingintab == SEARCH_FLOOR)
|
|
k=1, sector[searchsector].visibility = tempvis;
|
|
}
|
|
|
|
message("Pasted shade+pal%s", k?"+visibility":"");
|
|
asksave = 1;
|
|
}
|
|
}
|
|
}
|
|
else if (AIMING_AT_WALL_OR_MASK && eitherCTRL && somethingintab < 255) //Either ctrl key
|
|
{
|
|
int32_t clipboard_has_wall = (somethingintab == SEARCH_WALL || somethingintab == SEARCH_MASKWALL);
|
|
i = searchwall;
|
|
do
|
|
{
|
|
wall[i].picnum = temppicnum;
|
|
wall[i].shade = tempshade;
|
|
wall[i].pal = temppal;
|
|
|
|
if (clipboard_has_wall)
|
|
{
|
|
wall[i].xrepeat = tempxrepeat;
|
|
wall[i].yrepeat = tempyrepeat;
|
|
|
|
wall[i].xpanning = tempxpanning;
|
|
wall[i].ypanning = tempypanning;
|
|
|
|
wall[i].cstat &= ~(4 + 1+64 + 8+256);
|
|
wall[i].cstat |= (tempcstat & (4 + 1+64 + 8+256));
|
|
|
|
fixxrepeat(i, templenrepquot);
|
|
}
|
|
|
|
i = wall[i].point2;
|
|
}
|
|
while (i != searchwall);
|
|
|
|
message("Pasted picnum+shade+pal%s to wall %d's loop",
|
|
clipboard_has_wall?"+pixelwidth":"", searchwall);
|
|
asksave = 1;
|
|
}
|
|
else if (AIMING_AT_CEILING_OR_FLOOR && eitherCTRL && somethingintab < 255) //Either ctrl key
|
|
{
|
|
static const char *addnstr[4] = {"", "+stat+panning", "+stat", "+stat + panning (some)"};
|
|
|
|
static int16_t sectlist[MAXSECTORS];
|
|
static uint8_t sectbitmap[MAXSECTORS>>3];
|
|
int32_t sectcnt, sectnum;
|
|
|
|
i = searchsector;
|
|
if (CEILINGFLOOR(i, stat)&1)
|
|
{
|
|
// collect neighboring parallaxed sectors
|
|
bfirst_search_init(sectlist, sectbitmap, §num, MAXSECTORS, i);
|
|
|
|
for (sectcnt=0; sectcnt<sectnum; sectcnt++)
|
|
for (WALLS_OF_SECTOR(sectlist[sectcnt], j))
|
|
{
|
|
k = wall[j].nextsector;
|
|
if (k>=0 && (CEILINGFLOOR(k, stat)&1))
|
|
bfirst_search_try(sectlist, sectbitmap, §num, wall[j].nextsector);
|
|
}
|
|
|
|
k = 0;
|
|
for (sectcnt=0; sectcnt<sectnum; sectcnt++)
|
|
{
|
|
i = sectlist[sectcnt];
|
|
|
|
CEILINGFLOOR(i, picnum) = temppicnum;
|
|
CEILINGFLOOR(i, shade) = tempshade;
|
|
CEILINGFLOOR(i, pal) = temppal;
|
|
|
|
if (somethingintab == SEARCH_CEILING || somethingintab == SEARCH_FLOOR)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getbunch(i, AIMING_AT_FLOOR) >= 0)
|
|
k |= 2;
|
|
else
|
|
#endif
|
|
{
|
|
CEILINGFLOOR(i, xpanning) = tempxrepeat;
|
|
CEILINGFLOOR(i, ypanning) = tempyrepeat;
|
|
k |= 1;
|
|
}
|
|
|
|
SET_PROTECT_BITS(CEILINGFLOOR(i, stat), tempcstat, YAX_BIT);
|
|
}
|
|
}
|
|
|
|
message("Pasted picnum+shade+pal%s to parallaxed sector %ss",
|
|
addnstr[k], typestr[searchstat]);
|
|
asksave = 1;
|
|
}
|
|
#ifdef YAX_ENABLE
|
|
else
|
|
{
|
|
k = yax_getbunch(searchsector, AIMING_AT_FLOOR);
|
|
if (k < 0)
|
|
goto paste_ceiling_or_floor;
|
|
|
|
j = (somethingintab==SEARCH_CEILING || somethingintab==SEARCH_FLOOR);
|
|
|
|
for (SECTORS_OF_BUNCH(k,AIMING_AT_FLOOR, i))
|
|
{
|
|
SECTORFLD(i,picnum, AIMING_AT_FLOOR) = temppicnum;
|
|
SECTORFLD(i,shade, AIMING_AT_FLOOR) = tempshade;
|
|
SECTORFLD(i,pal, AIMING_AT_FLOOR) = temppal;
|
|
|
|
if (j)
|
|
SET_PROTECT_BITS(SECTORFLD(i,stat, AIMING_AT_FLOOR), tempcstat, YAX_BIT);
|
|
}
|
|
|
|
message("Pasted picnum+shade+pal%s to sector %ss with bunchnum %d",
|
|
j?"+stat":"", typestr[searchstat], k);
|
|
}
|
|
#endif
|
|
}
|
|
else if (somethingintab < 255)
|
|
{
|
|
// wall/overwall common:
|
|
if (AIMING_AT_WALL_OR_MASK && searchstat==somethingintab &&
|
|
(!AIMING_AT_WALL || searchwall==searchbottomwall))
|
|
{
|
|
wall[searchwall].xrepeat = tempxrepeat;
|
|
wall[searchwall].yrepeat = tempyrepeat;
|
|
wall[searchwall].xpanning = tempxpanning;
|
|
wall[searchwall].ypanning = tempypanning;
|
|
|
|
SET_PROTECT_BITS(wall[searchwall].cstat, tempcstat, YAX_NEXTWALLBITS|(4 + 1+64 + 8+256));
|
|
|
|
wall[searchwall].hitag = temphitag;
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getnextwall(searchwall, YAX_CEILING) == -1)
|
|
#endif
|
|
wall[searchwall].lotag = templotag;
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getnextwall(searchwall, YAX_FLOOR) == -1)
|
|
#endif
|
|
wall[searchwall].extra = tempextra;
|
|
|
|
fixxrepeat(searchwall, templenrepquot);
|
|
}
|
|
|
|
|
|
if (AIMING_AT_WALL)
|
|
{
|
|
wall[searchbottomwall].picnum = temppicnum;
|
|
wall[searchbottomwall].shade = tempshade;
|
|
wall[searchbottomwall].pal = temppal;
|
|
|
|
asksave = 1;
|
|
}
|
|
else if (AIMING_AT_MASKWALL)
|
|
{
|
|
wall[searchwall].overpicnum = temppicnum;
|
|
if (wall[searchwall].nextwall >= 0)
|
|
NEXTWALL(searchwall).overpicnum = temppicnum;
|
|
|
|
wall[searchwall].shade = tempshade;
|
|
wall[searchwall].pal = temppal;
|
|
}
|
|
else if (AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
paste_ceiling_or_floor:
|
|
#endif
|
|
AIMED_CEILINGFLOOR(picnum) = temppicnum;
|
|
AIMED_CEILINGFLOOR(shade) = tempshade;
|
|
AIMED_CEILINGFLOOR(pal) = temppal;
|
|
|
|
if (somethingintab == SEARCH_CEILING || somethingintab == SEARCH_FLOOR)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getbunch(searchsector, AIMING_AT_FLOOR) < 0)
|
|
#endif
|
|
AIMED_CEILINGFLOOR(xpanning) = tempxrepeat;
|
|
AIMED_CEILINGFLOOR(ypanning) = tempyrepeat;
|
|
SET_PROTECT_BITS(AIMED_CEILINGFLOOR(stat), tempcstat, YAX_BIT|2);
|
|
|
|
sector[searchsector].visibility = tempvis;
|
|
sector[searchsector].lotag = templotag;
|
|
sector[searchsector].hitag = temphitag;
|
|
sector[searchsector].extra = tempextra;
|
|
}
|
|
}
|
|
else if (AIMING_AT_SPRITE)
|
|
{
|
|
sprite[searchwall].picnum = temppicnum;
|
|
|
|
if (tilesizx[temppicnum] <= 0 || tilesizy[temppicnum] <= 0)
|
|
{
|
|
j = 0;
|
|
for (k=0; k<MAXTILES; k++)
|
|
if (tilesizx[k] > 0 && tilesizy[k] > 0)
|
|
{
|
|
j = k;
|
|
break;
|
|
}
|
|
sprite[searchwall].picnum = j;
|
|
}
|
|
|
|
sprite[searchwall].shade = tempshade;
|
|
sprite[searchwall].pal = temppal;
|
|
|
|
if (somethingintab == SEARCH_SPRITE)
|
|
{
|
|
sprite[searchwall].xrepeat = max(tempxrepeat, 1);
|
|
sprite[searchwall].yrepeat = max(tempyrepeat, 1);
|
|
sprite[searchwall].cstat = tempcstat;
|
|
sprite[searchwall].lotag = templotag;
|
|
sprite[searchwall].hitag = temphitag;
|
|
sprite[searchwall].extra = tempextra;
|
|
sprite[searchwall].xvel = tempxvel;
|
|
sprite[searchwall].yvel = tempyvel;
|
|
sprite[searchwall].zvel = tempzvel;
|
|
}
|
|
else
|
|
correct_sprite_yoffset(searchwall);
|
|
}
|
|
|
|
message("Pasted clipboard");
|
|
asksave = 1;
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(C))
|
|
{
|
|
if (eitherALT) // Alt-C picnum replacer
|
|
{
|
|
if (ASSERT_AIMING && somethingintab < 255)
|
|
{
|
|
switch (searchstat)
|
|
{
|
|
case SEARCH_WALL:
|
|
j = wall[searchbottomwall].picnum;
|
|
for (i=0; i<numwalls; i++)
|
|
if (wall[i].picnum == j)
|
|
wall[i].picnum = temppicnum;
|
|
break;
|
|
case SEARCH_CEILING:
|
|
case SEARCH_FLOOR:
|
|
j = AIMED_CEILINGFLOOR(picnum);
|
|
for (i=0; i<numsectors; i++)
|
|
if (CEILINGFLOOR(i, picnum) == j)
|
|
CEILINGFLOOR(i, picnum) = temppicnum;
|
|
break;
|
|
case SEARCH_SPRITE:
|
|
j = sprite[searchwall].picnum;
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
if (sprite[i].statnum < MAXSTATUS)
|
|
if (sprite[i].picnum == j)
|
|
{
|
|
sprite[i].picnum = temppicnum;
|
|
correct_sprite_yoffset(i);
|
|
}
|
|
break;
|
|
case SEARCH_MASKWALL:
|
|
j = wall[searchwall].overpicnum;
|
|
for (i=0; i<numwalls; i++)
|
|
if (wall[i].overpicnum == j)
|
|
wall[i].overpicnum = temppicnum;
|
|
break;
|
|
default:
|
|
j = -1;
|
|
break;
|
|
}
|
|
|
|
if (j>=0)
|
|
message("Replaced %ss with picnum %d to picnum %d",
|
|
typestr[searchstat], j, temppicnum);
|
|
asksave = 1;
|
|
}
|
|
}
|
|
else //C
|
|
{
|
|
if (AIMING_AT_SPRITE)
|
|
{
|
|
sprite[searchwall].cstat ^= 128;
|
|
message("Sprite %d center bit %s",searchwall, ONOFF((sprite[searchwall].cstat&128)));
|
|
asksave = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(SLASH)) // /? Reset panning&repeat to 0
|
|
{
|
|
if (AIMING_AT_WALL_OR_MASK)
|
|
{
|
|
int16_t w = SELECT_WALL();
|
|
wall[w].xpanning = 0;
|
|
wall[w].ypanning = 0;
|
|
wall[w].xrepeat = 8;
|
|
wall[w].yrepeat = 8;
|
|
wall[w].cstat &= YAX_NEXTWALLBITS;
|
|
fixrepeats(searchwall);
|
|
}
|
|
else if (AIMING_AT_CEILING_OR_FLOOR)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
j = yax_getbunch(searchsector, AIMING_AT_FLOOR);
|
|
if (j < 0)
|
|
#endif
|
|
AIMED_CEILINGFLOOR(xpanning) = 0;
|
|
AIMED_CEILINGFLOOR(ypanning) = 0;
|
|
AIMED_CEILINGFLOOR(stat) &= ~2;
|
|
AIMED_CEILINGFLOOR(heinum) = 0;
|
|
#ifdef YAX_ENABLE
|
|
if (j >= 0)
|
|
for (SECTORS_OF_BUNCH(j,!AIMING_AT_FLOOR, i))
|
|
{
|
|
SECTORFLD(i,stat, !AIMING_AT_FLOOR) &= ~2;
|
|
SECTORFLD(i,heinum, !AIMING_AT_FLOOR) = 0;
|
|
}
|
|
#endif
|
|
}
|
|
else if (AIMING_AT_SPRITE)
|
|
{
|
|
if (eitherSHIFT)
|
|
sprite[searchwall].xrepeat = sprite[searchwall].yrepeat;
|
|
else
|
|
{
|
|
sprite[searchwall].xrepeat = 64;
|
|
sprite[searchwall].yrepeat = 64;
|
|
}
|
|
|
|
correct_sprite_yoffset(searchwall);
|
|
}
|
|
|
|
if (ASSERT_AIMING)
|
|
{
|
|
message("%s's size and panning reset", Typestr[searchstat]);
|
|
asksave = 1;
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(P)) // P (parallaxing sky)
|
|
{
|
|
if (eitherCTRL)
|
|
{
|
|
parallaxtype = (parallaxtype+1)%3;
|
|
sector[searchsector].ceilingstat ^= 1;
|
|
message("Parallax type %d", parallaxtype);
|
|
}
|
|
else if (eitherALT)
|
|
{
|
|
if (ASSERT_AIMING)
|
|
{
|
|
Bsprintf(tempbuf, "%s pal: ", Typestr[searchstat]);
|
|
getnumberptr256(tempbuf, &AIMED_CF_SEL(pal), sizeof(uint8_t), M32_MAXPALOOKUPS, 0, NULL);
|
|
asksave = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (AIMING_AT_WALL_OR_MASK || AIMING_AT_CEILING)
|
|
{
|
|
sector[searchsector].ceilingstat ^= 1;
|
|
message("Sector %d ceiling parallax bit %s",searchsector, ONOFF(sector[searchsector].ceilingstat&1));
|
|
asksave = 1;
|
|
}
|
|
else if (AIMING_AT_FLOOR)
|
|
{
|
|
sector[searchsector].floorstat ^= 1;
|
|
message("Sector %d floor parallax bit %s",searchsector, ONOFF(sector[searchsector].floorstat&1));
|
|
asksave = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(D)) //Alt-D (adjust sprite[].clipdist)
|
|
{
|
|
if (eitherALT && AIMING_AT_SPRITE)
|
|
sprite[searchwall].clipdist = getnumber256("Sprite clipdist: ", sprite[searchwall].clipdist, 255, 0);
|
|
}
|
|
|
|
VM_OnEvent(EVENT_KEYS3D, -1);
|
|
}// end 3d
|
|
|
|
static void DoSpriteSearch(int32_t dir) // <0: backwards, >=0: forwards
|
|
{
|
|
char did_wrap = 0, outofgrid=0;
|
|
int32_t i, j, k = 0;
|
|
|
|
dir = 1-2*(dir<0);
|
|
|
|
for (gs_cursprite += dir;; gs_cursprite += dir)
|
|
{
|
|
if (gs_cursprite < 0 || gs_cursprite >= MAXSPRITES)
|
|
{
|
|
if (did_wrap)
|
|
break;
|
|
|
|
did_wrap = 1;
|
|
gs_cursprite &= (MAXSPRITES-1);
|
|
}
|
|
|
|
if (sprite[gs_cursprite].statnum == MAXSTATUS) continue;
|
|
|
|
for (i=0; i<3; i++)
|
|
for (j=0; i==1 ? j<6 : j<7; j++)
|
|
{
|
|
if (!gs_spriteTagInterested[i][j]) continue;
|
|
|
|
if (i==0)
|
|
{
|
|
switch (j)
|
|
{
|
|
case 0: k = sprite[gs_cursprite].x; break;
|
|
case 1: k = sprite[gs_cursprite].y; break;
|
|
case 2: k = sprite[gs_cursprite].z; break;
|
|
case 3: k = sprite[gs_cursprite].sectnum; break;
|
|
case 4: k = sprite[gs_cursprite].statnum; break;
|
|
case 5: k = (uint16_t)sprite[gs_cursprite].hitag; break;
|
|
case 6: k = (uint16_t)sprite[gs_cursprite].lotag; break;
|
|
}
|
|
}
|
|
else if (i==1)
|
|
{
|
|
switch (j)
|
|
{
|
|
case 0:
|
|
k = sprite[gs_cursprite].cstat;
|
|
k &= gs_spriteTagValue[1][0];
|
|
break;
|
|
case 1: k = sprite[gs_cursprite].shade; break;
|
|
case 2: k = sprite[gs_cursprite].pal; break;
|
|
case 3:
|
|
k = gs_spriteTagValue[1][3];
|
|
if (k != sprite[gs_cursprite].xrepeat &&
|
|
k != sprite[gs_cursprite].yrepeat)
|
|
goto NEXTSPRITE;
|
|
break;
|
|
case 4:
|
|
k = gs_spriteTagValue[1][4];
|
|
if (k != sprite[gs_cursprite].xoffset &&
|
|
k != sprite[gs_cursprite].yoffset)
|
|
goto NEXTSPRITE;
|
|
break;
|
|
case 5: k = sprite[gs_cursprite].picnum; break;
|
|
}
|
|
}
|
|
else if (i==2)
|
|
{
|
|
switch (j)
|
|
{
|
|
case 0: k = sprite[gs_cursprite].ang; break;
|
|
case 1: k = (uint16_t)sprite[gs_cursprite].xvel; break;
|
|
case 2: k = (uint16_t)sprite[gs_cursprite].yvel; break;
|
|
case 3: k = (uint16_t)sprite[gs_cursprite].zvel; break;
|
|
case 4: k = (uint16_t)sprite[gs_cursprite].owner; break;
|
|
case 5: k = sprite[gs_cursprite].clipdist; break;
|
|
case 6: k = sprite[gs_cursprite].extra; break;
|
|
}
|
|
}
|
|
|
|
if (k != gs_spriteTagValue[i][j]) goto NEXTSPRITE;
|
|
}
|
|
|
|
// found matching sprite
|
|
if (pos.x >= -editorgridextent && pos.x <= editorgridextent &&
|
|
pos.y >= -editorgridextent && pos.y <= editorgridextent)
|
|
{
|
|
pos.x = sprite[gs_cursprite].x;
|
|
pos.y = sprite[gs_cursprite].y;
|
|
if (pos.z >= -editorgridextent<<4 && pos.z <= editorgridextent<<4)
|
|
pos.z = sprite[gs_cursprite].z;
|
|
ang = sprite[gs_cursprite].ang;
|
|
}
|
|
else
|
|
outofgrid = 1;
|
|
|
|
printmessage16("%s Sprite seach%s: found sprite %d%s", dir<0 ? "<" : ">",
|
|
did_wrap ? " (wrap)" : "", gs_cursprite, outofgrid?"(outside grid)":"");
|
|
did_wrap = 0;
|
|
return;
|
|
|
|
NEXTSPRITE:
|
|
;
|
|
}
|
|
printmessage16("%s Sprite search: none found", dir<0 ? "<" : ">");
|
|
}
|
|
|
|
|
|
static void Keys2d(void)
|
|
{
|
|
int32_t i=0, j, k;
|
|
int32_t smooshy, changedir;
|
|
static int32_t repeatcnt[2] = {0,0}; // was repeatcountx, repeatcounty
|
|
int32_t tcursectornum;
|
|
|
|
// for(i=0;i<0x50;i++) if(keystatus[i]==1) Bsprintf(tempbuf,"key %d",i); printmessage16(tempbuf);
|
|
|
|
tcursectornum = -1;
|
|
for (i=0; i<numsectors; i++)
|
|
{
|
|
YAX_SKIPSECTOR(i);
|
|
if (inside_editor_curpos(i) == 1)
|
|
{
|
|
tcursectornum = i;
|
|
break;
|
|
}
|
|
}
|
|
searchsector = tcursectornum;
|
|
#if M32_UNDO
|
|
if (eitherCTRL && PRESSED_KEYSC(Z)) // CTRL+Z
|
|
{
|
|
if (eitherSHIFT)
|
|
{
|
|
if (map_undoredo(1)) message("Nothing to redo!");
|
|
else message("Redo: restored revision %d", map_revision-1);
|
|
}
|
|
else
|
|
{
|
|
if (map_undoredo(0)) message("Nothing to undo!");
|
|
else message("Undo: restored revision %d", map_revision-1);
|
|
}
|
|
}
|
|
#endif
|
|
if (keystatus[KEYSC_TAB]) //TAB
|
|
{
|
|
if (eitherCTRL)
|
|
{
|
|
g_fillCurSector = !g_fillCurSector;
|
|
message("Fill currently pointed-at sector: %s", ONOFF(g_fillCurSector));
|
|
keystatus[KEYSC_TAB] = 0;
|
|
}
|
|
else if (eitherSHIFT)
|
|
{
|
|
if (pointhighlight >= 16384)
|
|
{
|
|
drawgradient();
|
|
showspritedata(pointhighlight&16383, 0);
|
|
}
|
|
else if (linehighlight >= 0 /* && ((bstatus&1) || sectorofwall(linehighlight)==tcursectornum)*/)
|
|
{
|
|
drawgradient();
|
|
showwalldata(linehighlight, 0);
|
|
}
|
|
}
|
|
else if (tcursectornum >= 0)
|
|
{
|
|
drawgradient();
|
|
showsectordata(tcursectornum, 0);
|
|
}
|
|
}
|
|
else if (!(keystatus[KEYSC_F5]|keystatus[KEYSC_F6]|keystatus[KEYSC_F7]|keystatus[KEYSC_F8]) && !eitherSHIFT)
|
|
{
|
|
static int32_t counter = 0;
|
|
static int32_t omx = 0, omy = 0;
|
|
/*
|
|
static int32_t opointhighlight, olinehighlight, ocursectornum;
|
|
if (pointhighlight == opointhighlight && linehighlight == olinehighlight && tcursectornum == ocursectornum)
|
|
*/
|
|
if (omx == mousxplc && omy == mousyplc)
|
|
{
|
|
if (counter < 6)
|
|
counter++;
|
|
}
|
|
else if (counter > 0)
|
|
counter--;
|
|
|
|
omx = mousxplc;
|
|
omy = mousyplc;
|
|
|
|
/*
|
|
opointhighlight = pointhighlight;
|
|
olinehighlight = linehighlight;
|
|
ocursectornum = tcursectornum;
|
|
*/
|
|
|
|
if (totalclock < lastpm16time + 120*2)
|
|
_printmessage16("%s", lastpm16buf);
|
|
else if (counter >= 2 && totalclock >= 120*6)
|
|
{
|
|
if (pointhighlight >= 16384)
|
|
{
|
|
i = pointhighlight-16384;
|
|
showspritedata(i, 1);
|
|
|
|
if (sprite[i].picnum==SECTOREFFECTOR)
|
|
_printmessage16("^10%s", SectorEffectorText(i));
|
|
}
|
|
else if (linehighlight >= 0 && ((bstatus&1) || sectorofwall(linehighlight)==tcursectornum))
|
|
showwalldata(linehighlight, 1);
|
|
else if (tcursectornum >= 0)
|
|
showsectordata(tcursectornum, 1);
|
|
}
|
|
}
|
|
|
|
///__bigcomment__
|
|
|
|
if ((i=tcursectornum)>=0 && g_fillCurSector && (hlsectorbitmap[i>>3]&(1<<(i&7)))==0)
|
|
{
|
|
int32_t col = editorcolors[4];
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getbunch(tcursectornum, YAX_FLOOR)>=0)
|
|
col = editorcolors[12];
|
|
#endif
|
|
fillsector(tcursectornum, col);
|
|
}
|
|
|
|
#ifdef YAX_ENABLE
|
|
if (eitherCTRL && PRESSED_KEYSC(U) && tcursectornum>=0) // Ctrl-U: unlink bunch sectors
|
|
{
|
|
int16_t cf, fb = yax_getbunch(tcursectornum, YAX_FLOOR);
|
|
if (fb >= 0)
|
|
{
|
|
for (SECTORS_OF_BUNCH(fb,YAX_FLOOR, i))
|
|
fillsector(i, editorcolors[11]);
|
|
fade_editor_screen(editorcolors[11]);
|
|
|
|
if (ask_if_sure("Clear all TROR extensions from marked sectors?", 0))
|
|
{
|
|
for (cf=0; cf<2; cf++)
|
|
for (SECTORS_OF_BUNCH(fb,cf, i))
|
|
yax_setbunch(i, cf, -1);
|
|
|
|
yax_update(0);
|
|
yax_updategrays(pos.z);
|
|
|
|
message("Cleared TROR bunch %d", fb);
|
|
asksave = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (/*!m32_sideview &&*/ numyaxbunches>0)
|
|
{
|
|
int32_t zsign=0;
|
|
|
|
if (PRESSED_KEYSC(PGDN) || (eitherCTRL && PRESSED_KEYSC(DOWN)))
|
|
zsign = 1;
|
|
else if (PRESSED_KEYSC(PGUP) || (eitherCTRL && PRESSED_KEYSC(UP)))
|
|
zsign = -1;
|
|
|
|
if (zsign)
|
|
{
|
|
int32_t bestzdiff=INT32_MAX, hiz=0, loz=0, bottomp=0;
|
|
|
|
for (i=0; i<numsectors; i++)
|
|
{
|
|
if (yax_getbunch(i, YAX_FLOOR) < 0 /*&& yax_getbunch(i, YAX_CEILING) < 0*/)
|
|
continue;
|
|
|
|
loz = min(loz, sector[i].floorz);
|
|
hiz = max(hiz, sector[i].floorz);
|
|
|
|
// TODO: see if at least one sector point inside sceeen
|
|
j = (sector[i].floorz-pos.z)*zsign;
|
|
if (j>0 && j < bestzdiff)
|
|
bestzdiff = j;
|
|
}
|
|
|
|
if (bestzdiff==INT32_MAX)
|
|
{
|
|
if (zsign == 1)
|
|
bottomp=1, bestzdiff = (hiz+(1024<<4) - pos.z);
|
|
else
|
|
bestzdiff = pos.z - loz;
|
|
}
|
|
|
|
pos.z += zsign*bestzdiff;
|
|
yax_updategrays(pos.z);
|
|
|
|
printmessage16("Z position: %d%s", pos.z,
|
|
bottomp ? " (bottom)":(pos.z==loz ? " (top)":""));
|
|
updatesectorz(pos.x, pos.y, pos.z, &cursectnum);
|
|
}
|
|
}
|
|
|
|
if (eitherCTRL && PRESSED_KEYSC(A))
|
|
{
|
|
if (eitherALT)
|
|
{
|
|
showinnergray = !showinnergray;
|
|
printmessage16("Display grayed out walls: %s", ONOFF(showinnergray));
|
|
}
|
|
else
|
|
{
|
|
autogray = !autogray;
|
|
printmessage16("Automatic grayout of plain sectors %s", ONOFF(autogray));
|
|
yax_updategrays(pos.z);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Ctrl-R set editor z range to hightlightsectors' c/f bounds
|
|
if (eitherCTRL && PRESSED_KEYSC(R))
|
|
{
|
|
if (highlightsectorcnt <= 0)
|
|
{
|
|
editorzrange[0] = INT32_MIN;
|
|
editorzrange[1] = INT32_MAX;
|
|
printmessage16("Reset Z range");
|
|
}
|
|
else
|
|
{
|
|
int32_t damin=INT32_MAX, damax=INT32_MIN;
|
|
|
|
for (i=0; i<highlightsectorcnt; i++)
|
|
{
|
|
damin = min(damin, sector[highlightsector[i]].ceilingz);
|
|
damax = max(damax, sector[highlightsector[i]].floorz);
|
|
}
|
|
|
|
if (damin < damax)
|
|
{
|
|
editorzrange[0] = damin;
|
|
editorzrange[1] = damax;
|
|
printmessage16("Set Z range to highlighted sector bounds (%d..%d)",
|
|
editorzrange[0], editorzrange[1]);
|
|
}
|
|
}
|
|
yax_updategrays(pos.z);
|
|
}
|
|
|
|
#if 0
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(Z)) // ' z
|
|
{
|
|
editorzrange[0] = getnumber16("Upper Z range: ", editorzrange[0], INT32_MAX, 1);
|
|
editorzrange[1] = getnumber16("Lower Z range: ", editorzrange[1], INT32_MAX, 1);
|
|
// printmessage16("");
|
|
}
|
|
#endif
|
|
|
|
if (PRESSED_KEYSC(T)) // T (tag)
|
|
{
|
|
char buffer[80];
|
|
|
|
if (eitherCTRL) //Ctrl-T
|
|
{
|
|
if (eitherSHIFT)
|
|
showtags--;
|
|
else
|
|
showtags++;
|
|
showtags += 3;
|
|
showtags %= 3;
|
|
printmessage16("Show tags %s", showtags<2?ONOFF(showtags):"LABELED");
|
|
}
|
|
else if (eitherALT) //ALT
|
|
{
|
|
if (pointhighlight >= 16384)
|
|
{
|
|
i = pointhighlight-16384;
|
|
j = taglab_linktags(1, i);
|
|
j = 4*(j&1);
|
|
Bsprintf(buffer,"Sprite (%d) Lo-tag: ", i);
|
|
sprite[i].lotag = _getnumber16(buffer, sprite[i].lotag, BTAG_MAX, 0+j, sprite[i].picnum==SECTOREFFECTOR ?
|
|
(void *)SectorEffectorTagText : NULL);
|
|
}
|
|
else if (linehighlight >= 0)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getnextwall(linehighlight, YAX_CEILING)>=0)
|
|
message("Can't change lotag in protected wall");
|
|
else
|
|
#endif
|
|
{
|
|
i = linehighlight;
|
|
j = taglab_linktags(1, i);
|
|
j = 4*(j&1);
|
|
Bsprintf(buffer,"Wall (%d) Lo-tag: ", i);
|
|
wall[i].lotag = getnumber16(buffer, wall[i].lotag, BTAG_MAX, 0+j);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (tcursectornum >= 0)
|
|
{
|
|
Bsprintf(buffer,"Sector (%d) Lo-tag: ", tcursectornum);
|
|
sector[tcursectornum].lotag =
|
|
_getnumber16(buffer, sector[tcursectornum].lotag, BTAG_MAX, 0, (void *)ExtGetSectorType);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(F1) || (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_TILDE])) //F1 or ' ~
|
|
{
|
|
// PK_
|
|
if (numhelppages>0)
|
|
IntegratedHelp();
|
|
else
|
|
printmessage16("m32help.hlp invalid or not found!");
|
|
}
|
|
|
|
if (PRESSED_KEYSC(F2))
|
|
if (g_numsounds > 0)
|
|
{
|
|
SoundDisplay();
|
|
}
|
|
|
|
// F3: side view toggle (handled in build.c)
|
|
|
|
getpoint(searchx,searchy, &mousxplc,&mousyplc);
|
|
ppointhighlight = getpointhighlight(mousxplc,mousyplc, ppointhighlight);
|
|
|
|
if ((ppointhighlight&0xc000) == 16384)
|
|
{
|
|
// sprite[ppointhighlight&16383].cstat ^= 1;
|
|
cursprite = ppointhighlight&16383;
|
|
}
|
|
|
|
if (keystatus[KEYSC_F9]) // F9 f1=3b
|
|
ShowFileText("sthelp.hlp");
|
|
|
|
/* start Mapster32 */
|
|
|
|
if (PRESSED_KEYSC(F4))
|
|
{
|
|
showfirstwall = !showfirstwall;
|
|
message("Sector firstwall highlight %s", showfirstwall?"enabled":"disabled");
|
|
}
|
|
|
|
if (PRESSED_KEYSC(M)) // M (tag)
|
|
{
|
|
if (eitherALT) //ALT
|
|
{
|
|
if (pointhighlight >= 16384)
|
|
{
|
|
i = pointhighlight-16384;
|
|
Bsprintf(tempbuf, "Sprite %d Extra: ", i);
|
|
sprite[i].extra = getnumber16(tempbuf, sprite[i].extra, BTAG_MAX, 1);
|
|
}
|
|
else if (linehighlight >= 0)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getnextwall(linehighlight, YAX_FLOOR)>=0)
|
|
message("Can't change extra in protected wall");
|
|
else
|
|
#endif
|
|
{
|
|
i = linehighlight;
|
|
Bsprintf(tempbuf,"Wall %d Extra: ",i);
|
|
wall[i].extra = getnumber16(tempbuf,wall[i].extra,BTAG_MAX,1);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (tcursectornum >= 0)
|
|
{
|
|
Bsprintf(tempbuf,"Sector %d Extra: ",tcursectornum);
|
|
sector[tcursectornum].extra = getnumber16(tempbuf,sector[tcursectornum].extra,BTAG_MAX,1);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!eitherCTRL && PRESSED_KEYSC(E)) // E (expand)
|
|
{
|
|
if (tcursectornum >= 0)
|
|
{
|
|
sector[tcursectornum].floorstat ^= 8;
|
|
message("Sector %d floor texture expansion bit %s", tcursectornum,
|
|
ONOFF(sector[tcursectornum].floorstat&8));
|
|
asksave = 1;
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(SLASH)) // / Reset panning&repeat to 0
|
|
{
|
|
if ((ppointhighlight&0xc000) == 16384)
|
|
{
|
|
if (eitherSHIFT)
|
|
sprite[cursprite].xrepeat = sprite[cursprite].yrepeat;
|
|
else
|
|
sprite[cursprite].xrepeat = sprite[cursprite].yrepeat = 64;
|
|
asksave = 1;
|
|
}
|
|
else if (graphicsmode != 0)
|
|
{
|
|
i = tcursectornum;
|
|
|
|
if (i >= 0)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getbunch(i, YAX_FLOOR) < 0)
|
|
#endif
|
|
sector[i].floorxpanning = 0;
|
|
sector[i].floorypanning = 0;
|
|
message("Sector %d floor panning reset", i);
|
|
asksave = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (k=0; k<2; k++) // panning/repeat
|
|
{
|
|
if (k==0)
|
|
j = (keystatus[KEYSC_gLEFT]<<1)|keystatus[KEYSC_gRIGHT]; // 4 & 6 (keypad 2D)
|
|
else
|
|
j = (keystatus[KEYSC_gUP]<<1)|keystatus[KEYSC_gDOWN]; // 2 & 8 (keypad 2D)
|
|
|
|
if (j)
|
|
{
|
|
smooshy = keystatus[KEYSC_gKP5];
|
|
|
|
if (repeatcnt[k] == 0 || repeatcnt[k] > 32)
|
|
{
|
|
changedir = 1-(j&2);
|
|
|
|
if ((ppointhighlight&0xc000) == 16384 && (sprite[cursprite].cstat & 48))
|
|
{
|
|
uint8_t *repeat = (k==0) ? &sprite[cursprite].xrepeat : &sprite[cursprite].yrepeat;
|
|
*repeat = max(4, changechar(*repeat, changedir, smooshy, 1));
|
|
silentmessage("Sprite %d repeat: %d, %d", cursprite,
|
|
sprite[cursprite].xrepeat, sprite[cursprite].yrepeat);
|
|
}
|
|
else
|
|
{
|
|
i = tcursectornum;
|
|
|
|
if (i >= 0)
|
|
#ifdef YAX_ENABLE
|
|
if (k==1 || yax_getbunch(i, YAX_FLOOR) < 0)
|
|
#endif
|
|
{
|
|
uint8_t *panning = (k==0) ? §or[i].floorxpanning : §or[i].floorypanning;
|
|
*panning = changechar(*panning, changedir, smooshy, 0);
|
|
silentmessage("Sector %d floor panning: %d, %d", searchsector,
|
|
sector[i].floorxpanning, sector[i].floorypanning);
|
|
}
|
|
}
|
|
|
|
asksave = 1;
|
|
repeatcnt[k] = max(1,repeatcnt[k]-2);
|
|
}
|
|
repeatcnt[k] += synctics;
|
|
}
|
|
else
|
|
repeatcnt[k] = 0;
|
|
}
|
|
|
|
if (PRESSED_KEYSC(R)) // R (relative alignment, rotation)
|
|
{
|
|
if (pointhighlight >= 16384)
|
|
{
|
|
const char *aligntype[4] = { "view", "wall", "floor", "???" };
|
|
|
|
i = sprite[cursprite].cstat;
|
|
if ((i&48) < 32)
|
|
i += 16;
|
|
else
|
|
i &= ~48;
|
|
sprite[cursprite].cstat = i;
|
|
|
|
message("Sprite %d now %s aligned", cursprite, aligntype[(i&48)/16]);
|
|
asksave = 1;
|
|
}
|
|
}
|
|
|
|
if (keystatus[KEYSC_QUOTE] && keystatus[KEYSC_S]) // ' S
|
|
{
|
|
if (pointhighlight >= 16384)
|
|
{
|
|
keystatus[KEYSC_S] = 0;
|
|
Bsprintf(tempbuf, "Sprite %d xrepeat: ", cursprite);
|
|
sprite[cursprite].xrepeat = getnumber16(tempbuf, sprite[cursprite].xrepeat, 255, 0);
|
|
Bsprintf(tempbuf, "Sprite %d yrepeat: ", cursprite);
|
|
sprite[cursprite].yrepeat = getnumber16(tempbuf, sprite[cursprite].yrepeat, 255, 0);
|
|
printmessage16("Sprite %d updated", i);
|
|
}
|
|
}
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(F)) // ' F
|
|
{
|
|
FuncMenu();
|
|
}
|
|
|
|
tsign = 0;
|
|
if (PRESSED_KEYSC(LBRACK)) // [ search backward
|
|
tsign = -1;
|
|
if (PRESSED_KEYSC(RBRACK)) // ] search forward
|
|
tsign = +1;
|
|
|
|
if (tsign)
|
|
{
|
|
if (eitherALT && numcorruptthings>0)
|
|
{
|
|
int32_t wrap=0, x, y, z;
|
|
|
|
if (curcorruptthing<0 || curcorruptthing>=numcorruptthings)
|
|
curcorruptthing = 0;
|
|
else
|
|
{
|
|
curcorruptthing += tsign;
|
|
wrap = (curcorruptthing<0 || curcorruptthing>=numcorruptthings);
|
|
curcorruptthing += numcorruptthings;
|
|
curcorruptthing %= numcorruptthings;
|
|
}
|
|
|
|
k = corruptthings[curcorruptthing];
|
|
j = -1;
|
|
switch (k&CORRUPT_MASK)
|
|
{
|
|
case 0:
|
|
printmessage16("MAP LIMITS EXCEEDED!");
|
|
x = y = z = 0;
|
|
break;
|
|
case CORRUPT_SECTOR:
|
|
i = k&(MAXSECTORS-1);
|
|
j = 0;
|
|
x = wall[sector[i].wallptr].x;
|
|
y = wall[sector[i].wallptr].y;
|
|
z = getflorzofslope(i, x, y);
|
|
break;
|
|
case CORRUPT_WALL:
|
|
i = k&(MAXWALLS-1);
|
|
j = 1;
|
|
x = wall[i].x + (wall[wall[i].point2].x-wall[i].x)/2;
|
|
y = wall[i].y + (wall[wall[i].point2].y-wall[i].y)/2;
|
|
z = getflorzofslope(sectorofwall(i), x, y);
|
|
break;
|
|
case CORRUPT_SPRITE:
|
|
i = k&(MAXSPRITES-1);
|
|
j = 2;
|
|
x = sprite[i].x;
|
|
y = sprite[i].y;
|
|
z = sprite[i].z;
|
|
break;
|
|
default:
|
|
k = 0;
|
|
x = y = z = 0;
|
|
break;
|
|
}
|
|
|
|
if (k)
|
|
{
|
|
static const char *secwalspr[3] = {"sector", "wall", "sprite"};
|
|
if (x>=-editorgridextent && x<=editorgridextent &&
|
|
y>=-editorgridextent && y<=editorgridextent)
|
|
{
|
|
pos.x = x;
|
|
pos.y = y;
|
|
pos.z = z;
|
|
#ifdef YAX_ENABLE
|
|
yax_updategrays(pos.z);
|
|
#endif
|
|
}
|
|
else x=editorgridextent+1;
|
|
|
|
printmessage16("#%d: %s Corrupt %s %d%s", curcorruptthing+1, tsign<0?"<":">", secwalspr[j],
|
|
i, (x==editorgridextent+1) ? " (outside grid)" : (wrap ? " (wrap)" : ""));
|
|
}
|
|
}
|
|
else if (wallsprite==0)
|
|
{
|
|
SearchSectors(tsign);
|
|
}
|
|
else if (wallsprite==1)
|
|
{
|
|
if ((tsign<0 && curwallnum>0) || (tsign>0 && curwallnum<numwalls))
|
|
curwallnum += tsign;
|
|
|
|
for (i=curwallnum; i>=0 && i<numwalls; i+=tsign)
|
|
{
|
|
if ((wall[i].picnum==wall[curwall].picnum)
|
|
&& (search_lotag==0 || search_lotag==wall[i].lotag)
|
|
&& (search_hitag==0 || search_hitag==wall[i].hitag))
|
|
{
|
|
pos.x = wall[i].x - (wall[i].x-POINT2(i).x)/2;
|
|
pos.y = wall[i].y - (wall[i].y-POINT2(i).y)/2;
|
|
pos.z = getflorzofslope(sectorofwall(i), pos.x, pos.y);
|
|
printmessage16("%s Wall search: found", tsign<0?"<":">");
|
|
return;
|
|
}
|
|
curwallnum--;
|
|
}
|
|
printmessage16("%s Wall search: none found", tsign<0?"<":">");
|
|
}
|
|
else if (wallsprite==2)
|
|
DoSpriteSearch(tsign);
|
|
|
|
///__old_sprite_search_1__
|
|
|
|
///__old_sprite_search_2__
|
|
|
|
}
|
|
|
|
if (PRESSED_KEYSC(G)) // G (grid on/off)
|
|
{
|
|
if (autogrid)
|
|
{
|
|
grid = 8*eitherSHIFT;
|
|
|
|
autogrid = 0;
|
|
}
|
|
else
|
|
{
|
|
grid += (1-2*eitherSHIFT);
|
|
if (grid == -1 || grid == 9)
|
|
{
|
|
autogrid = 1;
|
|
grid = 0;
|
|
}
|
|
}
|
|
|
|
if (autogrid)
|
|
printmessage16("Grid size: 9 (autosize)");
|
|
else if (!grid)
|
|
printmessage16("Grid off");
|
|
else
|
|
printmessage16("Grid size: %d (%d units)", grid, 2048>>grid);
|
|
}
|
|
|
|
if (autogrid)
|
|
{
|
|
grid = min(zoom+512, 65536);
|
|
grid = scale(grid, 6, 6144);
|
|
grid = clamp(grid, 0, 7);
|
|
}
|
|
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(L)) // ' L (set sprite/wall coordinates)
|
|
{
|
|
if (pointhighlight >= 16384)
|
|
{
|
|
i = pointhighlight - 16384;
|
|
Bsprintf(tempbuf, "Sprite %d x: ", i);
|
|
sprite[i].x = getnumber16(tempbuf, sprite[i].x, editorgridextent-1, 1);
|
|
Bsprintf(tempbuf, "Sprite %d y: ", i);
|
|
sprite[i].y = getnumber16(tempbuf, sprite[i].y, editorgridextent-1, 1);
|
|
Bsprintf(tempbuf, "Sprite %d z: ", i);
|
|
sprite[i].z = getnumber16(tempbuf, sprite[i].z, BZ_MAX, 1);
|
|
Bsprintf(tempbuf, "Sprite %d angle: ", i);
|
|
sprite[i].ang = getnumber16(tempbuf, sprite[i].ang, 2048, 1);
|
|
sprite[i].ang &= 2047;
|
|
printmessage16("Sprite %d updated", i);
|
|
}
|
|
else if (pointhighlight >= 0)
|
|
{
|
|
i = linehighlight;
|
|
j = wall[i].x;
|
|
k = wall[i].y;
|
|
|
|
Bsprintf(tempbuf, "Wall %d x: ", i);
|
|
j = getnumber16(tempbuf, j, editorgridextent, 1);
|
|
Bsprintf(tempbuf, "Wall %d y: ", i);
|
|
k = getnumber16(tempbuf, k, editorgridextent, 1);
|
|
dragpoint(i, j, k);
|
|
printmessage16("Wall %d updated", i);
|
|
}
|
|
}
|
|
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(3)) // ' 3
|
|
{
|
|
onnames = (onnames+1)%M32_NUM_SPRITE_MODES;
|
|
printmessage16("Mode %d %s", onnames, SpriteMode[onnames]);
|
|
}
|
|
// Ver();
|
|
|
|
///__motorcycle___
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(7)) // ' 7 : swap hilo
|
|
{
|
|
|
|
if (pointhighlight >= 16384)
|
|
{
|
|
swapshort(&sprite[cursprite].lotag, &sprite[cursprite].hitag);
|
|
printmessage16("Sprite %d tags swapped", cursprite);
|
|
}
|
|
else if (linehighlight >= 0)
|
|
{
|
|
#ifdef YAX_ENABLE
|
|
if (yax_getnextwall(linehighlight, YAX_CEILING)>=0 || yax_getnextwall(searchwall, YAX_FLOOR)>=0)
|
|
message("Can't swap tags in protected wall");
|
|
else
|
|
#endif
|
|
{
|
|
swapshort(&wall[linehighlight].lotag, &wall[linehighlight].hitag);
|
|
printmessage16("Wall %d tags swapped", linehighlight);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(J)) // ' J
|
|
{
|
|
char dachars[4] = {'s', 'w', 'i', 'c'};
|
|
|
|
fade_editor_screen(-1);
|
|
i = editor_ask_function("Jump to (s)ector, (w)all, spr(i)te, or (c)oordinates?", dachars, 4);
|
|
|
|
switch (i)
|
|
{
|
|
case 0:
|
|
if (numsectors > 0)
|
|
{
|
|
j = getnumber16("Sector: ", 0, numsectors-1, 0+8);
|
|
if (j < 0)
|
|
break;
|
|
pos.x = wall[sector[j].wallptr].x;
|
|
pos.y = wall[sector[j].wallptr].y;
|
|
pos.z = sector[j].floorz;
|
|
printmessage16("Current pos now on sector %d's first wall-point", j);
|
|
}
|
|
break;
|
|
case 1:
|
|
if (numwalls > 0)
|
|
{
|
|
j = getnumber16("Wall: ", 0, numwalls-1, 0+8);
|
|
if (j < 0)
|
|
break;
|
|
pos.x = wall[j].x + (wall[wall[j].point2].x-wall[j].x)/4;
|
|
pos.y = wall[j].y + (wall[wall[j].point2].y-wall[j].y)/4;
|
|
pos.z = getflorzofslope(sectorofwall(j), pos.x, pos.y);
|
|
printmessage16("Current pos now on wall %d's midpoint", j);
|
|
}
|
|
break;
|
|
case 2:
|
|
j = getnumber16("Sprite: ", 0, MAXSPRITES-1, 0+8);
|
|
if (j < 0 || sprite[j].statnum==MAXSTATUS)
|
|
break;
|
|
pos.x = sprite[j].x;
|
|
pos.y = sprite[j].y;
|
|
pos.z = sprite[j].z;
|
|
printmessage16("Current pos now on sprite %d", j);
|
|
break;
|
|
|
|
case 3:
|
|
pos.x = getnumber16("X-coordinate: ", pos.x, editorgridextent, 1);
|
|
pos.y = getnumber16("Y-coordinate: ", pos.y, editorgridextent, 1);
|
|
printmessage16("Current pos now (%d, %d)", pos.x, pos.y);
|
|
break;
|
|
}
|
|
#ifdef YAX_ENABLE
|
|
yax_updategrays(pos.z);
|
|
#endif
|
|
}
|
|
}// end key2d
|
|
|
|
static void InitCustomColors(void)
|
|
{
|
|
int32_t i;
|
|
palette_t *edcol;
|
|
|
|
/* blue */
|
|
vgapal16[9*4+0] = 63;
|
|
vgapal16[9*4+1] = 31;
|
|
vgapal16[9*4+2] = 7;
|
|
|
|
/* orange */
|
|
vgapal16[31*4+0] = 20; // blue
|
|
vgapal16[31*4+1] = 45; // green
|
|
vgapal16[31*4+2] = 60; // red
|
|
|
|
vgapal16[39*4+0] = 36;
|
|
vgapal16[39*4+1] = 53;
|
|
vgapal16[39*4+2] = 63;
|
|
|
|
|
|
/* light yellow */
|
|
vgapal16[22*4+0] = 51;
|
|
vgapal16[22*4+1] = 63;
|
|
vgapal16[22*4+2] = 63;
|
|
|
|
/* grey */
|
|
vgapal16[23*4+0] = 45;
|
|
vgapal16[23*4+1] = 45;
|
|
vgapal16[23*4+2] = 45;
|
|
|
|
/* blue */
|
|
vgapal16[24*4+0] = 51;
|
|
vgapal16[24*4+1] = 41;
|
|
vgapal16[24*4+2] = 12;
|
|
|
|
vgapal16[32*4+0] = 60;
|
|
vgapal16[32*4+1] = 50;
|
|
vgapal16[32*4+2] = 21;
|
|
|
|
// grid color
|
|
vgapal16[25*4+0] = 19;
|
|
vgapal16[25*4+1] = 17;
|
|
vgapal16[25*4+2] = 17;
|
|
|
|
vgapal16[26*4+0] = 24;
|
|
vgapal16[26*4+1] = 24;
|
|
vgapal16[26*4+2] = 24;
|
|
|
|
vgapal16[33*4+0] = 0;//15; // blue
|
|
vgapal16[33*4+1] = 0;//30; // green
|
|
vgapal16[33*4+2] = 48;//45; // red
|
|
|
|
vgapal16[41*4+0] = 0;//24;
|
|
vgapal16[41*4+1] = 0;//40;
|
|
vgapal16[41*4+2] = 63;//48;
|
|
|
|
for (i = 0; i<256; i++)
|
|
{
|
|
edcol = (palette_t *)&vgapal16[4*i];
|
|
editorcolors[i] = getclosestcol(edcol->b,edcol->g,edcol->r);
|
|
}
|
|
}
|
|
|
|
int32_t ExtPreSaveMap(void)
|
|
{
|
|
int32_t numfixedsprites;
|
|
|
|
numfixedsprites = fixspritesectors(); //Do this before saving!
|
|
updatesectorz(startposx,startposy,startposz,&startsectnum);
|
|
if (startsectnum < 0)
|
|
updatesector(startposx,startposy,&startsectnum);
|
|
|
|
if (fixmaponsave_walls)
|
|
{
|
|
int32_t i, startwall, j, endwall;
|
|
|
|
for (i=0; i<numsectors; i++)
|
|
{
|
|
startwall = sector[i].wallptr;
|
|
for (j=startwall; j<numwalls; j++)
|
|
if (wall[j].point2 < startwall)
|
|
startwall = wall[j].point2;
|
|
if (sector[i].wallptr != startwall)
|
|
initprintf("Warning: set sector %d's wallptr to %d (was %d)\n", i,
|
|
sector[i].wallptr, startwall);
|
|
sector[i].wallptr = startwall;
|
|
}
|
|
|
|
for (i=numsectors-2; i>=0; i--)
|
|
sector[i].wallnum = sector[i+1].wallptr-sector[i].wallptr;
|
|
sector[numsectors-1].wallnum = numwalls - sector[numsectors-1].wallptr;
|
|
|
|
#ifdef YAX_ENABLE
|
|
// setting redwalls from scratch would very likely wreak havoc with TROR maps
|
|
if (numyaxbunches > 0)
|
|
return numfixedsprites;
|
|
#endif
|
|
for (i=0; i<numwalls; i++)
|
|
{
|
|
wall[i].nextsector = -1;
|
|
wall[i].nextwall = -1;
|
|
}
|
|
for (i=0; i<numsectors; i++)
|
|
{
|
|
startwall = sector[i].wallptr;
|
|
endwall = startwall + sector[i].wallnum;
|
|
for (j=startwall; j<endwall; j++)
|
|
checksectorpointer(j, i);
|
|
}
|
|
}
|
|
|
|
return numfixedsprites;
|
|
}
|
|
|
|
static void G_ShowParameterHelp(void)
|
|
{
|
|
const char *s = "Usage: mapster32 [files] [options]\n\n"
|
|
"-g[file.grp], -grp [file.grp]\tLoad extra group file\n"
|
|
"-h[file.def]\t\tLoad an alternate definitions file\n"
|
|
"-x[game.con]\t\tLoad a custom CON script for getting sound definitions\n"
|
|
"-mh [file.def]\t\tInclude additional definitions module\n"
|
|
"-mx [file.con]\t\tInclude additional CON module for getting sound definitions\n"
|
|
"-j[dir], -game_dir [dir]\n"
|
|
"\t\t\tAdds a directory to the file path stack\n"
|
|
"-cachesize #\t\tSets cache size, in Kb\n"
|
|
"-check\t\t\tEnables map pointer checking when saving\n"
|
|
#ifdef HAVE_CLIPSHAPE_FEATURE
|
|
"-clipmap [file.map]\t\tLoad an additional clipping map for use with clipshape\n"
|
|
#endif
|
|
"-namesfile [file.h]\t\tLoad a custom NAMES.H for tile names\n"
|
|
"-nocheck\t\t\tDisables map pointer checking when saving (default)\n" // kept for script compat
|
|
#if defined RENDERTYPEWIN || (defined RENDERTYPESDL && ((defined __APPLE__ && defined OSX_STARTUPWINDOW) || defined HAVE_GTK2))
|
|
"-setup\t\t\tDisplays the configuration dialog\n"
|
|
#endif
|
|
#if !defined(_WIN32)
|
|
"-usecwd\t\t\tRead game data and configuration file from working directory\n"
|
|
#endif
|
|
"\n-?, -help, --help\t\tDisplay this help message and exit"
|
|
;
|
|
Bsprintf(tempbuf, "Mapster32 %s %s", VERSION, s_buildRev);
|
|
wm_msgbox(tempbuf, "%s", s);
|
|
}
|
|
|
|
|
|
#define COPYARG(i) \
|
|
Bmemcpy(&testplay_addparam[j], argv[i], lengths[i]); \
|
|
j += lengths[i]; \
|
|
testplay_addparam[j++] = ' ';
|
|
|
|
#if defined(RENDERTYPEWIN) && defined(USE_OPENGL)
|
|
extern char forcegl;
|
|
#endif
|
|
|
|
static void G_CheckCommandLine(int32_t argc, const char **argv)
|
|
{
|
|
int32_t i = 1, j, maxlen=0, *lengths;
|
|
char *c, *k;
|
|
|
|
mapster32_fullpath = argv[0];
|
|
|
|
#ifdef HAVE_CLIPSHAPE_FEATURE
|
|
// pre-form the default 10 clipmaps
|
|
for (j = '0'; j<='9'; ++j)
|
|
{
|
|
char clipshape[16] = "_clipshape0.map";
|
|
|
|
clipshape[10] = j;
|
|
g_clipMapFiles = (char **) Brealloc (g_clipMapFiles, (g_clipMapFilesNum+1) * sizeof(char *));
|
|
g_clipMapFiles[g_clipMapFilesNum] = Bstrdup(clipshape);
|
|
++g_clipMapFilesNum;
|
|
}
|
|
#endif
|
|
|
|
if (argc <= 1)
|
|
return;
|
|
|
|
lengths = Bmalloc(argc*sizeof(int32_t));
|
|
for (j=1; j<argc; j++)
|
|
{
|
|
lengths[j] = Bstrlen(argv[j]);
|
|
maxlen += lengths[j];
|
|
}
|
|
|
|
testplay_addparam = Bmalloc(maxlen+argc);
|
|
testplay_addparam[0] = 0;
|
|
|
|
j = 0;
|
|
|
|
while (i < argc)
|
|
{
|
|
c = (char *)argv[i];
|
|
|
|
if ((*c == '-')
|
|
#ifdef _WIN32
|
|
|| (*c == '/')
|
|
#endif
|
|
)
|
|
{
|
|
if (!Bstrcasecmp(c+1,"?") || !Bstrcasecmp(c+1,"help") || !Bstrcasecmp(c+1,"-help"))
|
|
{
|
|
G_ShowParameterHelp();
|
|
exit(0);
|
|
}
|
|
|
|
if (!Bstrcasecmp(c+1, "g") || !Bstrcasecmp(c+1, "grp"))
|
|
{
|
|
if (argc > i+1)
|
|
{
|
|
G_AddGroup(argv[i+1]);
|
|
COPYARG(i);
|
|
COPYARG(i+1);
|
|
i++;
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
if (!Bstrcasecmp(c+1,"game_dir"))
|
|
{
|
|
if (argc > i+1)
|
|
{
|
|
#ifdef USE_OPENGL
|
|
Bsnprintf(tempbuf,sizeof(tempbuf),"%s/%s",argv[i+1],TEXCACHEFILE);
|
|
Bstrncpy(TEXCACHEFILE,tempbuf, sizeof(TEXCACHEFILE));
|
|
TEXCACHEFILE[sizeof(TEXCACHEFILE)-1] = 0;
|
|
#endif
|
|
Bstrncpy(g_modDir, argv[i+1], sizeof(g_modDir));
|
|
g_modDir[sizeof(g_modDir)-1] = 0;
|
|
G_AddPath(argv[i+1]);
|
|
|
|
COPYARG(i);
|
|
COPYARG(i+1);
|
|
i++;
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!Bstrcasecmp(c+1,"cachesize"))
|
|
{
|
|
if (argc > i+1)
|
|
{
|
|
int32_t sz = atoi_safe(argv[i+1]);
|
|
if (sz >= 16<<10 && sz <= 1024<<10)
|
|
{
|
|
g_maxCacheSize = sz<<10;
|
|
initprintf("Cache size: %dkB\n",sz);
|
|
|
|
COPYARG(i);
|
|
COPYARG(i+1);
|
|
}
|
|
i++;
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!Bstrcasecmp(c+1,"cfg"))
|
|
{
|
|
if (argc > i+1)
|
|
{
|
|
Bstrcpy(setupfilename,argv[i+1]);
|
|
i++;
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!Bstrcasecmp(c+1,"gamegrp"))
|
|
{
|
|
if (argc > i+1)
|
|
{
|
|
Bstrcpy(defaultduke3dgrp,argv[i+1]);
|
|
COPYARG(i);
|
|
COPYARG(i+1);
|
|
i++;
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!Bstrcasecmp(c+1,"nam"))
|
|
{
|
|
Bstrcpy(g_grpNamePtr, "nam.grp");
|
|
Bstrcpy(defaultduke3dgrp, "nam.grp");
|
|
Bstrcpy(defsfilename, "nam.def");
|
|
// Bstrcpy(g_defNamePtr, "nam.def");
|
|
Bstrcpy(defaultgamecon[0], "nam.con");
|
|
COPYARG(i);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!Bstrcasecmp(c+1,"namesfile"))
|
|
{
|
|
g_namesFileName = argv[i+1];
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!Bstrcasecmp(c+1,"mx"))
|
|
{
|
|
if (argc > i+1)
|
|
{
|
|
g_scriptModules = (char **) Brealloc (g_scriptModules, (g_scriptModulesNum+1) * sizeof(char *));
|
|
g_scriptModules[g_scriptModulesNum] = Bstrdup(argv[i+1]);
|
|
++g_scriptModulesNum;
|
|
i++;
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!Bstrcasecmp(c+1,"mh"))
|
|
{
|
|
if (argc > i+1)
|
|
{
|
|
g_defModules = (char **) Brealloc (g_defModules, (g_defModulesNum+1) * sizeof(char *));
|
|
g_defModules[g_defModulesNum] = Bstrdup(argv[i+1]);
|
|
++g_defModulesNum;
|
|
i++;
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
#ifdef HAVE_CLIPSHAPE_FEATURE
|
|
if (!Bstrcasecmp(c+1,"clipmap"))
|
|
{
|
|
if (argc > i+1)
|
|
{
|
|
g_clipMapFiles = (char **) Brealloc (g_clipMapFiles, (g_clipMapFilesNum+1) * sizeof(char *));
|
|
g_clipMapFiles[g_clipMapFilesNum] = Bstrdup(argv[i+1]);
|
|
++g_clipMapFilesNum;
|
|
i++;
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
#endif
|
|
if (!Bstrcasecmp(c+1,"nm") || !Bstrcasecmp(c+1,"ns"))
|
|
{
|
|
COPYARG(i);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!Bstrcasecmp(c+1,"ww2gi"))
|
|
{
|
|
Bstrcpy(g_grpNamePtr, "ww2gi.grp");
|
|
Bstrcpy(defaultduke3dgrp, "ww2gi.grp");
|
|
Bstrcpy(defaultgamecon[0], "ww2gi.con");
|
|
Bstrcpy(defsfilename, "ww2gi.def");
|
|
// Bstrcpy(g_defNamePtr, "ww2gi.def");
|
|
COPYARG(i);
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!Bstrcasecmp(c+1,"check"))
|
|
{
|
|
initprintf("Map wall checking on save enabled\n");
|
|
fixmaponsave_walls = 1;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!Bstrcasecmp(c+1,"nocheck"))
|
|
{
|
|
initprintf("Map wall checking on save disabled\n");
|
|
fixmaponsave_walls = 0;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (!Bstrcasecmp(c+1,"noautoload"))
|
|
{
|
|
initprintf("Autoload disabled\n");
|
|
NoAutoLoad = 1;
|
|
COPYARG(i);
|
|
i++;
|
|
continue;
|
|
}
|
|
#if !defined(_WIN32)
|
|
if (!Bstrcasecmp(c+1,"usecwd"))
|
|
{
|
|
usecwd = 1;
|
|
COPYARG(i);
|
|
i++;
|
|
continue;
|
|
}
|
|
#endif
|
|
#if defined(RENDERTYPEWIN) && defined(USE_OPENGL)
|
|
if (!Bstrcasecmp(c+1,"forcegl"))
|
|
{
|
|
forcegl = 1;
|
|
i++;
|
|
continue;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
if ((*c == '-')
|
|
#ifdef _WIN32
|
|
|| (*c == '/')
|
|
#endif
|
|
)
|
|
{
|
|
c++;
|
|
switch (*c)
|
|
{
|
|
case 'h':
|
|
case 'H':
|
|
c++;
|
|
if (*c)
|
|
{
|
|
g_defNamePtr = c;
|
|
g_skipDefaultDefs = 1;
|
|
COPYARG(i);
|
|
initprintf("Using DEF file \"%s\".\n",g_defNamePtr);
|
|
}
|
|
break;
|
|
case 'j':
|
|
case 'J':
|
|
c++;
|
|
if (!*c) break;
|
|
G_AddPath(c);
|
|
COPYARG(i);
|
|
break;
|
|
case 'g':
|
|
case 'G':
|
|
c++;
|
|
if (!*c) break;
|
|
G_AddGroup(c);
|
|
COPYARG(i);
|
|
break;
|
|
case 'x':
|
|
case 'X':
|
|
c++;
|
|
if (!*c) break;
|
|
gamecon = c;
|
|
g_skipDefaultCons = 1;
|
|
COPYARG(i);
|
|
initprintf("Using CON file \"%s\".\n",gamecon);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
k = Bstrrchr(c,'.');
|
|
if (k)
|
|
{
|
|
if (!Bstrcasecmp(k,".grp") || !Bstrcasecmp(k,".zip"))
|
|
{
|
|
COPYARG(i);
|
|
G_AddGroup(argv[i++]);
|
|
continue;
|
|
}
|
|
else if (!Bstrcasecmp(k,".def"))
|
|
{
|
|
COPYARG(i);
|
|
g_defNamePtr = (char *)argv[i++];
|
|
g_skipDefaultDefs = 1;
|
|
initprintf("Using DEF file \"%s\".\n",g_defNamePtr);
|
|
continue;
|
|
}
|
|
else if (!Bstrcasecmp(k,".con"))
|
|
{
|
|
COPYARG(i);
|
|
gamecon = (char *)argv[i++];
|
|
g_skipDefaultCons = 1;
|
|
initprintf("Using CON file \"%s\".\n",gamecon);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
|
|
Bfree(lengths);
|
|
|
|
if (j > 0)
|
|
{
|
|
testplay_addparam[j-1] = 0;
|
|
testplay_addparam = Brealloc(testplay_addparam, j*sizeof(char));
|
|
}
|
|
else
|
|
{
|
|
Bfree(testplay_addparam);
|
|
testplay_addparam = NULL;
|
|
}
|
|
|
|
}
|
|
#undef COPYARG
|
|
|
|
int32_t ExtPreInit(int32_t argc,const char **argv)
|
|
{
|
|
wm_setapptitle("Mapster32");
|
|
|
|
#ifdef _WIN32
|
|
tempbuf[GetModuleFileName(NULL,tempbuf,BMAX_PATH)] = 0;
|
|
Bcorrectfilename(tempbuf,1);
|
|
//chdir(tempbuf);
|
|
#endif
|
|
|
|
OSD_SetLogFile("mapster32.log");
|
|
OSD_SetVersion("Mapster32" " " VERSION,0,2);
|
|
initprintf("Mapster32 %s %s\n", VERSION, s_buildRev);
|
|
initprintf("Compiled %s\n", __DATE__" "__TIME__);
|
|
// initprintf("Copyright (c) 2008 EDuke32 team\n");
|
|
|
|
G_CheckCommandLine(argc,argv);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int32_t osdcmd_quit(const osdfuncparm_t *parm)
|
|
{
|
|
UNREFERENCED_PARAMETER(parm);
|
|
|
|
ExtUnInit();
|
|
// clearfilenames();
|
|
uninitengine();
|
|
|
|
exit(0);
|
|
}
|
|
|
|
static int32_t osdcmd_editorgridextent(const osdfuncparm_t *parm)
|
|
{
|
|
int32_t i;
|
|
|
|
if (parm->numparms == 0)
|
|
{
|
|
OSD_Printf("\"editorgridextent\" is \"%d\"\n", editorgridextent);
|
|
return OSDCMD_SHOWHELP;
|
|
}
|
|
else if (parm->numparms != 1)
|
|
return OSDCMD_SHOWHELP;
|
|
|
|
i = Batol(parm->parms[0]);
|
|
|
|
if (i >= 65536 && i <= BXY_MAX)
|
|
{
|
|
editorgridextent = i;
|
|
OSD_Printf("editorgridextent %d\n", editorgridextent);
|
|
}
|
|
else
|
|
OSD_Printf("editorgridextent: value out of range (65536 to %d)\n", BXY_MAX);
|
|
|
|
return OSDCMD_OK;
|
|
}
|
|
|
|
static int32_t osdcmd_addpath(const osdfuncparm_t *parm)
|
|
{
|
|
char pathname[BMAX_PATH];
|
|
|
|
if (parm->numparms != 1) return OSDCMD_SHOWHELP;
|
|
|
|
Bstrcpy(pathname,parm->parms[0]);
|
|
addsearchpath(pathname);
|
|
return OSDCMD_OK;
|
|
}
|
|
|
|
static int32_t osdcmd_initgroupfile(const osdfuncparm_t *parm)
|
|
{
|
|
char file[BMAX_PATH];
|
|
|
|
if (parm->numparms != 1) return OSDCMD_SHOWHELP;
|
|
|
|
Bstrcpy(file,parm->parms[0]);
|
|
initgroupfile(file);
|
|
return OSDCMD_OK;
|
|
}
|
|
|
|
static int32_t osdcmd_sensitivity(const osdfuncparm_t *parm)
|
|
{
|
|
if (parm->numparms != 1)
|
|
{
|
|
OSD_Printf("\"sensitivity\" is \"%.2f\"\n",msens);
|
|
return OSDCMD_SHOWHELP;
|
|
}
|
|
msens = atof(parm->parms[0]);
|
|
OSD_Printf("sensitivity %.2f\n",msens);
|
|
return OSDCMD_OK;
|
|
}
|
|
|
|
static int32_t osdcmd_noclip(const osdfuncparm_t *parm)
|
|
{
|
|
UNREFERENCED_PARAMETER(parm);
|
|
m32_clipping--;
|
|
if (m32_clipping < 0)
|
|
m32_clipping = 2;
|
|
OSD_Printf("Clipping %s\n", m32_clipping==0 ? "disabled" :
|
|
(m32_clipping==1 ? "non-masks only" : "enabled"));
|
|
|
|
return OSDCMD_OK;
|
|
}
|
|
|
|
static int32_t osdcmd_testplay_addparam(const osdfuncparm_t *parm)
|
|
{
|
|
int32_t slen;
|
|
|
|
if (parm->numparms != 1)
|
|
{
|
|
OSD_Printf("additional parameters for test playing: %s%s%s\n",
|
|
testplay_addparam ? "\"" : "",
|
|
testplay_addparam ? testplay_addparam : "<empty>",
|
|
testplay_addparam ? "\"" : "");
|
|
return OSDCMD_OK;
|
|
}
|
|
|
|
slen = Bstrlen(parm->parms[0]);
|
|
|
|
if (slen > 0)
|
|
{
|
|
if (!testplay_addparam)
|
|
testplay_addparam = Bmalloc(slen+1);
|
|
else
|
|
testplay_addparam = Brealloc(testplay_addparam, slen+1);
|
|
|
|
Bmemcpy(testplay_addparam, parm->parms[0], slen);
|
|
testplay_addparam[slen] = 0;
|
|
}
|
|
else
|
|
{
|
|
if (testplay_addparam)
|
|
{
|
|
Bfree(testplay_addparam);
|
|
testplay_addparam = NULL;
|
|
}
|
|
}
|
|
|
|
return OSDCMD_OK;
|
|
}
|
|
|
|
|
|
//PK vvv ------------
|
|
static int32_t osdcmd_vars_pk(const osdfuncparm_t *parm)
|
|
{
|
|
int32_t showval = (parm->numparms < 1);
|
|
|
|
// this is something of a misnomer, since it's actually accel+decel
|
|
if (!Bstrcasecmp(parm->name, "pk_turnaccel"))
|
|
{
|
|
if (showval)
|
|
OSD_Printf("Turning acceleration+declaration is %d\n", pk_turnaccel);
|
|
else
|
|
{
|
|
pk_turnaccel = atoi_safe(parm->parms[0]);
|
|
pk_turnaccel = pk_turnaccel<=pk_turndecel ? (pk_turndecel+1):pk_turnaccel;
|
|
pk_turnaccel = pk_turnaccel>256 ? 256:pk_turnaccel;
|
|
}
|
|
}
|
|
else if (!Bstrcasecmp(parm->name, "pk_turndecel"))
|
|
{
|
|
if (showval)
|
|
OSD_Printf("Turning deceleration is %d\n", pk_turndecel);
|
|
else
|
|
{
|
|
pk_turndecel = atoi_safe(parm->parms[0]);
|
|
pk_turndecel = pk_turndecel<=0 ? 1:pk_turndecel;
|
|
pk_turndecel = pk_turndecel>=pk_turnaccel ? (pk_turnaccel-1):pk_turndecel;
|
|
pk_turndecel = pk_turndecel>128 ? 128:pk_turndecel;
|
|
}
|
|
}
|
|
else if (!Bstrcasecmp(parm->name, "pk_quickmapcycling"))
|
|
{
|
|
OSD_Printf("Quick map cycling ((LShift-)Ctrl-X): %s\n",
|
|
(quickmapcycling = !quickmapcycling) ? "enabled":"disabled");
|
|
}
|
|
else if (!Bstrcasecmp(parm->name, "pk_uedaccel"))
|
|
{
|
|
if (parm->numparms==1)
|
|
{
|
|
pk_uedaccel = atoi_safe(parm->parms[0]);
|
|
pk_uedaccel = pk_uedaccel<0 ? 0:pk_uedaccel;
|
|
pk_uedaccel = pk_uedaccel>5 ? 5:pk_uedaccel;
|
|
}
|
|
|
|
if (parm->numparms <= 1)
|
|
OSD_Printf("UnrealEd mouse navigation acceleration is %d\n", pk_uedaccel);
|
|
else
|
|
return OSDCMD_SHOWHELP;
|
|
}
|
|
else if (!Bstrcasecmp(parm->name, "osd_tryscript"))
|
|
{
|
|
m32_osd_tryscript = !m32_osd_tryscript;
|
|
OSD_Printf("Try M32 script execution on invalid OSD command: %s\n", m32_osd_tryscript?"on":"off");
|
|
}
|
|
else if (!Bstrcasecmp(parm->name, "sideview_reversehorizrot"))
|
|
{
|
|
sideview_reversehrot = !sideview_reversehrot;
|
|
OSD_Printf("Side view reverse horizontal rotation: %s\n", sideview_reversehrot?"on":"off");
|
|
}
|
|
else if (!Bstrcasecmp(parm->name, "script_expertmode"))
|
|
{
|
|
m32_script_expertmode = !m32_script_expertmode;
|
|
if (m32_script_expertmode)
|
|
OSD_Printf("M32 Script expert mode ENABLED. Be sure to know what you are doing!\n");
|
|
else
|
|
OSD_Printf("M32 Script expert mode DISABLED.\n");
|
|
}
|
|
else if (!Bstrcasecmp(parm->name, "fixmaponsave_sprites"))
|
|
{
|
|
OSD_Printf("Fix sprite sectnums on map saving: %s\n",
|
|
(fixmaponsave_sprites = !fixmaponsave_sprites) ? "enabled":"disabled");
|
|
}
|
|
else if (!Bstrcasecmp(parm->name, "show_heightindicators"))
|
|
{
|
|
static const char *how[3] = {"none", "two-sided walls only", "all"};
|
|
|
|
if (parm->numparms == 1)
|
|
showheightindicators = clamp(atoi_safe(parm->parms[0]), 0, 2);
|
|
|
|
if (parm->numparms <= 1)
|
|
OSD_Printf("height indicators: %s\n", how[showheightindicators]);
|
|
else
|
|
return OSDCMD_SHOWHELP;
|
|
}
|
|
else if (!Bstrcasecmp(parm->name, "show_ambiencesounds"))
|
|
{
|
|
static const char *how[3] = {"none", "current sector only", "all"};
|
|
|
|
if (parm->numparms == 1)
|
|
showambiencesounds = clamp(atoi_safe(parm->parms[0]), 0, 2);
|
|
|
|
if (parm->numparms <= 1)
|
|
OSD_Printf("ambience sound circles: %s\n", how[showambiencesounds]);
|
|
else
|
|
return OSDCMD_SHOWHELP;
|
|
}
|
|
else if (!Bstrcasecmp(parm->name, "corruptcheck"))
|
|
{
|
|
int32_t tryfix = parm->numparms>=1 && !Bstrcasecmp(parm->parms[0], "tryfix");
|
|
|
|
if (parm->numparms >= 1 || tryfix)
|
|
{
|
|
if (!Bstrcasecmp(parm->parms[0], "noalreadyrefd"))
|
|
{
|
|
corruptcheck_noalreadyrefd = !corruptcheck_noalreadyrefd;
|
|
OSD_Printf("%sgnore 'already referenced' corruption\n",
|
|
corruptcheck_noalreadyrefd?"I":"Don't i");
|
|
return OSDCMD_OK;
|
|
}
|
|
else if (!Bstrcasecmp(parm->parms[0], "now"))
|
|
{
|
|
int32_t printfromlevel = 1;
|
|
if (parm->numparms > 1)
|
|
printfromlevel = clamp(atoi_safe(parm->parms[1]), 1, 5);
|
|
if (CheckMapCorruption(printfromlevel, 0)==0)
|
|
OSD_Printf("All OK.\n");
|
|
return OSDCMD_OK;
|
|
}
|
|
else if (tryfix)
|
|
{
|
|
uint64_t whicherrs = parm->numparms==1 ? 0xffffffffffffffffull : 0;
|
|
corrupt_tryfix_alt = 0;
|
|
|
|
if (whicherrs==0)
|
|
{
|
|
int32_t i, n, m;
|
|
char *endptr;
|
|
for (i=1; i<parm->numparms; i++)
|
|
{
|
|
if (i==parm->numparms-1 && !Bstrcmp(parm->parms[i], "?"))
|
|
{
|
|
corrupt_tryfix_alt = 1;
|
|
break;
|
|
}
|
|
|
|
n = (int32_t)Bstrtol(parm->parms[i], &endptr, 10);
|
|
if (endptr != parm->parms[i])
|
|
{
|
|
if (*endptr=='-')
|
|
{
|
|
m = (int32_t)Bstrtol(endptr+1, NULL, 10);
|
|
if (n>=1 && n<=m && m<=MAXCORRUPTTHINGS)
|
|
{
|
|
uint64_t mask = 0xffffffffffffffffull;
|
|
m = m-n+1;
|
|
mask >>= (MAXCORRUPTTHINGS-m);
|
|
mask <<= (n-1);
|
|
|
|
whicherrs |= mask;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (n>=1 && n<=MAXCORRUPTTHINGS)
|
|
whicherrs |= (1ull<<(n-1));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CheckMapCorruption(whicherrs?5:3, whicherrs);
|
|
return OSDCMD_OK;
|
|
}
|
|
else if (isdigit(parm->parms[0][0]))
|
|
{
|
|
autocorruptcheck = clamp(atoi_safe(parm->parms[0]), 0, 3600);
|
|
corruptchecktimer = totalclock + 120*autocorruptcheck;
|
|
}
|
|
}
|
|
|
|
if (parm->numparms <= 1)
|
|
{
|
|
if (autocorruptcheck)
|
|
OSD_Printf("auto corruption check: %d seconds\n", autocorruptcheck);
|
|
else
|
|
OSD_Printf("auto corruption check: off\n");
|
|
}
|
|
else if (!tryfix)
|
|
return OSDCMD_SHOWHELP;
|
|
}
|
|
|
|
return OSDCMD_OK;
|
|
}
|
|
|
|
#ifdef USE_OPENGL
|
|
static int32_t osdcmd_tint(const osdfuncparm_t *parm)
|
|
{
|
|
int32_t i;
|
|
palette_t *p;
|
|
|
|
if (parm->numparms==1)
|
|
{
|
|
i = atoi_safe(parm->parms[0]);
|
|
if (i>=0 && i<=M32_MAXPALOOKUPS)
|
|
{
|
|
p = &hictinting[i];
|
|
OSD_Printf("pal %d: r=%d g=%d b=%d f=%d\n", i, p->r, p->g, p->b, p->f);
|
|
}
|
|
}
|
|
else if (parm->numparms==0)
|
|
{
|
|
OSD_Printf("Hightile tintings:\n");
|
|
for (i=0,p=&hictinting[0]; i<=M32_MAXPALOOKUPS; i++,p++)
|
|
if (*(int32_t *)&hictinting[i] != B_LITTLE32(0x00ffffff))
|
|
OSD_Printf("pal %d: rgb %3d %3d %3d f %d\n", i, p->r, p->g, p->b, p->f);
|
|
}
|
|
else if (parm->numparms>=2)
|
|
{
|
|
i = atoi_safe(parm->parms[0]);
|
|
if (i<0 || i>M32_MAXPALOOKUPS)
|
|
return OSDCMD_SHOWHELP;
|
|
|
|
p = &hictinting[i];
|
|
p->r = atoi_safe(parm->parms[1]);
|
|
p->g = (parm->numparms>=3) ? atoi_safe(parm->parms[2]) : 255;
|
|
p->b = (parm->numparms>=4) ? atoi_safe(parm->parms[3]) : 255;
|
|
p->f = (parm->numparms>=5) ? atoi_safe(parm->parms[4])&HICEFFECTMASK : 0;
|
|
}
|
|
return OSDCMD_OK;
|
|
}
|
|
#endif
|
|
|
|
// M32 script vvv
|
|
static int32_t osdcmd_include(const osdfuncparm_t *parm)
|
|
{
|
|
if (parm->numparms != 1)
|
|
return OSDCMD_SHOWHELP;
|
|
C_Compile(parm->parms[0], 1);
|
|
return OSDCMD_OK;
|
|
}
|
|
|
|
static int32_t osdcmd_scriptinfo(const osdfuncparm_t *parm)
|
|
{
|
|
UNREFERENCED_PARAMETER(parm);
|
|
C_CompilationInfo();
|
|
return OSDCMD_OK;
|
|
}
|
|
|
|
#ifdef DEBUGGINGAIDS
|
|
extern void X_Disasm(ofstype beg, int32_t size);
|
|
|
|
static int32_t osdcmd_disasm(const osdfuncparm_t *parm)
|
|
{
|
|
int32_t i;
|
|
|
|
if (parm->numparms != 2)
|
|
return OSDCMD_SHOWHELP;
|
|
|
|
if (!isdigit(parm->parms[1][0]))
|
|
return OSDCMD_SHOWHELP;
|
|
|
|
i=atoi_safe(parm->parms[1]);
|
|
|
|
if (parm->parms[0][0]=='s')
|
|
{
|
|
if (i>=0 && i<g_stateCount)
|
|
X_Disasm(statesinfo[i].ofs, statesinfo[i].codesize);
|
|
}
|
|
else
|
|
{
|
|
if (i>=0 && i<MAXEVENTS && aEventOffsets[i]>=0)
|
|
X_Disasm(aEventOffsets[i], aEventSizes[i]);
|
|
}
|
|
return OSDCMD_OK;
|
|
}
|
|
#endif
|
|
|
|
static int32_t osdcmd_do(const osdfuncparm_t *parm)
|
|
{
|
|
intptr_t oscrofs;
|
|
char *tp;
|
|
int32_t i, j, slen, ofs, dontsavehist;
|
|
int32_t onumconstants=g_numSavedConstants;
|
|
|
|
if (parm->numparms==0)
|
|
return OSDCMD_SHOWHELP;
|
|
|
|
oscrofs = (g_scriptPtr-script);
|
|
|
|
ofs = 2*(parm->numparms>0); // true if "do" command
|
|
slen = Bstrlen(parm->raw+ofs);
|
|
tp = Bmalloc(slen+2);
|
|
if (!tp) goto OUTOFMEM;
|
|
Bmemcpy(tp, parm->raw+ofs, slen);
|
|
|
|
// M32script call from 'special functions' menu
|
|
dontsavehist = (slen==0 || tp[0]==' ');
|
|
|
|
// needed so that subsequent commands won't execute old stuff.
|
|
tp[slen] = '\n';
|
|
tp[slen+1] = '\0';
|
|
|
|
g_didDefineSomething = 0;
|
|
|
|
C_Compile(tp, 0);
|
|
|
|
if (parm->numparms>=0)
|
|
Bfree(tp);
|
|
|
|
if (g_numCompilerErrors)
|
|
{
|
|
// g_scriptPtr = script + oscrofs; // handled in C_Compile()
|
|
return OSDCMD_OK;
|
|
}
|
|
|
|
for (i=0,j=0; i<MAXEVENTS; i++)
|
|
if (aEventOffsets[i]>=0)
|
|
j++;
|
|
|
|
if (g_didDefineSomething == 0)
|
|
{
|
|
g_numSavedConstants = onumconstants;
|
|
|
|
*g_scriptPtr = CON_RETURN + (g_lineNumber<<12);
|
|
g_scriptPtr = script + oscrofs;
|
|
|
|
insptr = script + oscrofs;
|
|
Bmemcpy(&vm, &vm_default, sizeof(vmstate_t));
|
|
|
|
if (qsetmode==200 && AIMING_AT_SPRITE)
|
|
{
|
|
vm.g_i = searchwall;
|
|
vm.g_sp = &sprite[vm.g_i];
|
|
}
|
|
|
|
// If OSD is down, that would interfere with user input, so don't consider
|
|
// m32script executed from the console as 'interactive'. Which leaves only
|
|
// that from the 'special functions' menu
|
|
if (OSD_GetRowsCur() < 0)
|
|
vm.miscflags |= VMFLAG_MISC_INTERACTIVE;
|
|
|
|
VM_Execute(0);
|
|
|
|
M32_PostScriptExec();
|
|
|
|
if (!(vm.flags&VMFLAG_ERROR) && !dontsavehist)
|
|
{
|
|
int32_t idx, dosave=1;
|
|
|
|
for (i=1; i<=4; i++)
|
|
{
|
|
idx = (scripthistend-i)&(SCRIPTHISTSIZ-1);
|
|
if (!scripthist[idx])
|
|
break;
|
|
else if (!Bstrcmp(scripthist[idx], parm->raw))
|
|
{
|
|
dosave = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (dosave)
|
|
{
|
|
if (scripthist[scripthistend])
|
|
Bfree((void *)scripthist[scripthistend]);
|
|
scripthist[scripthistend] = Bstrdup(parm->raw);
|
|
scripthistend++;
|
|
scripthistend %= SCRIPTHISTSIZ;
|
|
}
|
|
}
|
|
// asksave = 1; // handled in Access(Sprite|Sector|Wall)
|
|
}
|
|
|
|
return OSDCMD_OK;
|
|
OUTOFMEM:
|
|
message("OUT OF MEMORY!\n");
|
|
return OSDCMD_OK;
|
|
}
|
|
|
|
void M32RunScript(const char *s)
|
|
{
|
|
osdfuncparm_t parm;
|
|
|
|
parm.numparms = -1;
|
|
parm.raw = s;
|
|
|
|
osdcmd_do(&parm);
|
|
}
|
|
|
|
static int32_t osdcmd_endisableevent(const osdfuncparm_t *parm)
|
|
{
|
|
int32_t i, j, enable;
|
|
|
|
if (!label) return OSDCMD_OK;
|
|
|
|
if (parm->numparms < 1)
|
|
{
|
|
OSD_Printf("--- Defined events:\n");
|
|
for (i=0; i<MAXEVENTS; i++)
|
|
if (aEventOffsets[i] >= 0)
|
|
OSD_Printf("%s (%d): %s\n", label+(i*MAXLABELLEN), i, aEventEnabled[i]?"on":"off");
|
|
return OSDCMD_OK;
|
|
}
|
|
|
|
enable = !Bstrcasecmp(parm->name, "enableevent");
|
|
|
|
if (parm->numparms == 1)
|
|
{
|
|
if (!Bstrcasecmp(parm->parms[0], "all") || !Bstrcasecmp(parm->parms[0], "a"))
|
|
{
|
|
for (i=0; i<MAXEVENTS; i++)
|
|
aEventEnabled[i] = enable?1:0;
|
|
OSD_Printf("%sabled all events.\n", enable?"En":"Dis");
|
|
return OSDCMD_OK;
|
|
}
|
|
}
|
|
|
|
for (i=0; i<parm->numparms; i++)
|
|
{
|
|
char buf[64] = "EVENT_", buf2[64];
|
|
|
|
if (isdigit(parm->parms[i][0]))
|
|
{
|
|
j = atoi_safe(parm->parms[i]);
|
|
Bsprintf(buf2, "event %d", j);
|
|
}
|
|
else if (!Bstrncmp(parm->parms[i], "EVENT_", 6))
|
|
{
|
|
j = hash_find(&h_labels, parm->parms[i]);
|
|
Bstrncpy(buf2, parm->parms[i], sizeof(buf2));
|
|
buf2[sizeof(buf2)-1] = '\0';
|
|
}
|
|
else
|
|
{
|
|
Bstrncat(buf, parm->parms[i], sizeof(buf)-6-1);
|
|
j = hash_find(&h_labels, buf);
|
|
Bmemcpy(buf2, buf, sizeof(buf2));
|
|
}
|
|
|
|
if (j>=0 && j<MAXEVENTS)
|
|
{
|
|
aEventEnabled[j] = enable?1:0;
|
|
OSD_Printf("%sabled %s.\n", enable?"En":"Dis", buf2);
|
|
}
|
|
else
|
|
OSD_Printf("Invalid event %s.\n", buf2);
|
|
}
|
|
return OSDCMD_OK;
|
|
}
|
|
|
|
static int32_t registerosdcommands(void)
|
|
{
|
|
OSD_RegisterFunction("addpath","addpath <path>: adds path to game filesystem", osdcmd_addpath);
|
|
|
|
OSD_RegisterFunction("editorgridextent","editorgridextent: sets the size of the 2D mode editing grid",osdcmd_editorgridextent);
|
|
|
|
OSD_RegisterFunction("initgroupfile","initgroupfile <path>: adds a grp file into the game filesystem", osdcmd_initgroupfile);
|
|
|
|
OSD_RegisterFunction("m32_clipping","m32_clipping: toggles clipping mode", osdcmd_noclip);
|
|
|
|
OSD_RegisterFunction("quit","quit: exits the editor immediately", osdcmd_quit);
|
|
OSD_RegisterFunction("exit","exit: exits the editor immediately", osdcmd_quit);
|
|
|
|
OSD_RegisterFunction("sensitivity","sensitivity <value>: changes the mouse sensitivity", osdcmd_sensitivity);
|
|
|
|
//PK
|
|
OSD_RegisterFunction("pk_turnaccel", "pk_turnaccel <value>: sets turning acceleration+deceleration", osdcmd_vars_pk);
|
|
OSD_RegisterFunction("pk_turndecel", "pk_turndecel <value>: sets turning deceleration", osdcmd_vars_pk);
|
|
OSD_RegisterFunction("pk_uedaccel", "pk_uedaccel <value>: sets UnrealEd movement speed factor (0-5, exponentially)", osdcmd_vars_pk);
|
|
OSD_RegisterFunction("pk_quickmapcycling", "pk_quickmapcycling: toggles quick cycling of maps with (Shift-)Ctrl-X", osdcmd_vars_pk);
|
|
OSD_RegisterFunction("testplay_addparam", "testplay_addparam \"string\": sets additional parameters for test playing", osdcmd_testplay_addparam);
|
|
OSD_RegisterFunction("show_heightindicators", "show_heightindicators {0, 1 or 2}: sets display of height indicators in 2D mode", osdcmd_vars_pk);
|
|
OSD_RegisterFunction("show_ambiencesounds", "show_ambiencesounds {0, 1 or 2}>: sets display of MUSICANDSFX circles in 2D mode", osdcmd_vars_pk);
|
|
OSD_RegisterFunction("corruptcheck", "corruptcheck {<seconds>|now|tryfix}: sets auto corruption check interval if <seconds> given, otherwise as indicated", osdcmd_vars_pk);
|
|
#ifdef USE_OPENGL
|
|
OSD_RegisterFunction("tint", "tint <pal> <r> <g> <b> <flags>: queries or sets hightile tinting", osdcmd_tint);
|
|
#endif
|
|
|
|
// M32 script
|
|
OSD_RegisterFunction("include", "include <filenames...>: compiles one or more M32 script files", osdcmd_include);
|
|
OSD_RegisterFunction("do", "do (m32 script ...): executes M32 script statements", osdcmd_do);
|
|
OSD_RegisterFunction("script_info", "script_info: shows information about compiled M32 script", osdcmd_scriptinfo);
|
|
OSD_RegisterFunction("script_expertmode", "script_expertmode: toggles M32 script expert mode", osdcmd_vars_pk);
|
|
OSD_RegisterFunction("enableevent", "enableevent {all|EVENT_...|(event number)}", osdcmd_endisableevent);
|
|
OSD_RegisterFunction("disableevent", "disableevent {all|EVENT_...|(event number)}", osdcmd_endisableevent);
|
|
OSD_RegisterFunction("osd_tryscript", "osd_tryscript: toggles execution of M32 script on invalid OSD command", osdcmd_vars_pk);
|
|
OSD_RegisterFunction("sideview_reversehorizrot", "sideview_reversehorizrot: toggles reversion of Q and W keys in side view mode", osdcmd_vars_pk);
|
|
#ifdef DEBUGGINGAIDS
|
|
OSD_RegisterFunction("disasm", "disasm [s|e] <state or event number>", osdcmd_disasm);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
#define DUKEOSD
|
|
#ifdef DUKEOSD
|
|
# if 0
|
|
void GAME_drawosdchar(int32_t x, int32_t y, char ch, int32_t shade, int32_t pal)
|
|
{
|
|
int32_t ac;
|
|
|
|
if (ch == 32) return;
|
|
ac = ch-'!'+STARTALPHANUM;
|
|
if (ac < STARTALPHANUM || ac > ENDALPHANUM) return;
|
|
|
|
rotatesprite_fs(((x<<3)+x)<<16, (y<<3)<<16, 65536l, 0, ac, shade, pal, 8|16);
|
|
}
|
|
|
|
void GAME_drawosdstr(int32_t x, int32_t y, char *ch, int32_t len, int32_t shade, int32_t pal)
|
|
{
|
|
int32_t ac;
|
|
|
|
for (x = (x<<3)+x; len>0; len--, ch++, x++)
|
|
{
|
|
if (*ch == 32)
|
|
{
|
|
x+=5;
|
|
continue;
|
|
}
|
|
ac = *ch-'!'+STARTALPHANUM;
|
|
if (ac < STARTALPHANUM || ac > ENDALPHANUM) return;
|
|
|
|
rotatesprite_fs(x<<16, (y<<3)<<16, 65536l, 0, ac, shade, pal, 8|16);
|
|
if (*ch >= '0' && *ch <= '9') x+=8;
|
|
else x += tilesizx[ac];
|
|
}
|
|
}
|
|
# endif
|
|
|
|
static int32_t GetTime(void)
|
|
{
|
|
return totalclock;
|
|
}
|
|
|
|
# if 0
|
|
void GAME_drawosdcursor(int32_t x, int32_t y, int32_t type, int32_t lastkeypress)
|
|
{
|
|
int32_t ac;
|
|
|
|
if (type) ac = SMALLFNTCURSOR;
|
|
else ac = '_'-'!'+STARTALPHANUM;
|
|
|
|
if (!((GetTime()-lastkeypress) & 0x40l))
|
|
rotatesprite_fs(((x<<3)+x)<<16, ((y<<3)+(type?-1:2))<<16, 65536l, 0, ac, 0, 8, 8|16);
|
|
}
|
|
|
|
int32_t GAME_getcolumnwidth(int32_t w)
|
|
{
|
|
return w/9;
|
|
}
|
|
|
|
int32_t GAME_getrowheight(int32_t w)
|
|
{
|
|
return w>>3;
|
|
}
|
|
# endif
|
|
|
|
//#define BGTILE 311
|
|
//#define BGTILE 1156
|
|
#define BGTILE 1141 // BIGHOLE
|
|
#define BORDTILE 3250 // VIEWBORDER
|
|
#define BITSTH 1+32+8+16 // high translucency
|
|
#define BITSTL 1+8+16 // low translucency
|
|
#define BITS 8+16+64 // solid
|
|
#define SHADE 16
|
|
#define PALETTE 4
|
|
void GAME_clearbackground(int32_t numcols, int32_t numrows)
|
|
{
|
|
UNREFERENCED_PARAMETER(numcols);
|
|
|
|
# ifdef USE_OPENGL
|
|
// if (getrendermode() < 3) bits = BITS;
|
|
// else
|
|
if (rendmode>=3 && qsetmode==200)
|
|
{
|
|
int32_t x, y, xsiz, ysiz, tx2, ty2;
|
|
int32_t daydim, bits;
|
|
|
|
bits = BITSTL;
|
|
|
|
daydim = numrows<<3;
|
|
|
|
xsiz = tilesizx[BGTILE];
|
|
tx2 = xdim/xsiz;
|
|
ysiz = tilesizy[BGTILE];
|
|
ty2 = daydim/ysiz;
|
|
|
|
setpolymost2dview();
|
|
bglEnable(GL_TEXTURE_2D);
|
|
|
|
for (x=0; x<=tx2; x++)
|
|
for (y=0; y<=ty2; y++)
|
|
rotatesprite(x*xsiz<<16,y*ysiz<<16,65536L,0,BGTILE,SHADE,PALETTE,bits,0,0,xdim,daydim);
|
|
|
|
xsiz = tilesizy[BORDTILE];
|
|
tx2 = xdim/xsiz;
|
|
ysiz = tilesizx[BORDTILE];
|
|
|
|
for (x=0; x<=tx2; x++)
|
|
rotatesprite(x*xsiz<<16,(daydim+ysiz+1)<<16,65536L,1536,
|
|
BORDTILE,SHADE-12,PALETTE,BITS,0,0,xdim,daydim+ysiz+1);
|
|
|
|
return;
|
|
}
|
|
# endif
|
|
|
|
CLEARLINES2D(0, min(ydim, numrows*8+8), editorcolors[16]);
|
|
}
|
|
|
|
static void m32_osdsetfunctions(void)
|
|
{
|
|
OSD_SetFunctions(
|
|
/*
|
|
GAME_drawosdchar,
|
|
GAME_drawosdstr,
|
|
GAME_drawosdcursor,
|
|
GAME_getcolumnwidth,
|
|
GAME_getrowheight,
|
|
*/
|
|
0,0,0,0,0,
|
|
GAME_clearbackground,
|
|
/*(int32_t( *)(void))*/GetTime,
|
|
NULL
|
|
);
|
|
}
|
|
#endif // defined DUKEOSD
|
|
|
|
enum
|
|
{
|
|
T_EOF = -2,
|
|
T_ERROR = -1,
|
|
T_INCLUDE = 0,
|
|
T_DEFINE = 1,
|
|
T_LOADGRP,
|
|
T_TILEGROUP,
|
|
T_TILE,
|
|
T_TILERANGE,
|
|
T_HOTKEY,
|
|
T_TILES,
|
|
T_NOAUTOLOAD,
|
|
T_COLORS,
|
|
|
|
T_ALPHABET,
|
|
T_MAP,
|
|
T_MAPA,
|
|
T_MAPRANGE,
|
|
T_MAPRANGEA,
|
|
T_OFFSET,
|
|
T_OFFSETA,
|
|
|
|
T_DEFINESOUND,
|
|
T_INCLUDEDEFAULT,
|
|
};
|
|
|
|
typedef struct
|
|
{
|
|
const char *text;
|
|
int32_t tokenid;
|
|
}
|
|
tokenlist;
|
|
|
|
static int32_t getatoken(scriptfile *sf, const tokenlist *tl, int32_t ntokens)
|
|
{
|
|
char *tok;
|
|
int32_t i;
|
|
|
|
if (!sf) return T_ERROR;
|
|
tok = scriptfile_gettoken(sf);
|
|
if (!tok) return T_EOF;
|
|
|
|
for (i=0; i<ntokens; i++)
|
|
{
|
|
if (!Bstrcasecmp(tok, tl[i].text))
|
|
return tl[i].tokenid;
|
|
}
|
|
return T_ERROR;
|
|
}
|
|
|
|
static void DoAutoload(const char *fn)
|
|
{
|
|
static const char *extensions[3] = { "*.grp", "*.zip", "*.pk3" };
|
|
int32_t i;
|
|
|
|
for (i=0; i<3; i++)
|
|
{
|
|
Bsprintf(tempbuf, "autoload/%s", fn);
|
|
getfilenames(tempbuf, extensions[i]);
|
|
|
|
while (findfiles)
|
|
{
|
|
Bsprintf(tempbuf, "autoload/%s/%s", fn, findfiles->name);
|
|
initprintf("Using group file \"%s\".\n", tempbuf);
|
|
initgroupfile(tempbuf);
|
|
findfiles = findfiles->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
int32_t parsegroupfiles(scriptfile *script);
|
|
|
|
void parsegroupfiles_include(const char *fn, scriptfile *script, char *cmdtokptr)
|
|
{
|
|
scriptfile *included;
|
|
|
|
included = scriptfile_fromfile(fn);
|
|
if (!included)
|
|
{
|
|
if (!Bstrcasecmp(cmdtokptr,"null"))
|
|
initprintf("Warning: Failed including %s as module\n", fn);
|
|
else
|
|
initprintf("Warning: Failed including %s on line %s:%d\n",
|
|
fn, script->filename,scriptfile_getlinum(script,cmdtokptr));
|
|
}
|
|
else
|
|
{
|
|
parsegroupfiles(included);
|
|
scriptfile_close(included);
|
|
}
|
|
}
|
|
|
|
int32_t parsegroupfiles(scriptfile *script)
|
|
{
|
|
int32_t tokn;
|
|
char *cmdtokptr;
|
|
|
|
tokenlist grptokens[] =
|
|
{
|
|
{ "include", T_INCLUDE },
|
|
{ "#include", T_INCLUDE },
|
|
{ "includedefault", T_INCLUDEDEFAULT },
|
|
{ "#includedefault", T_INCLUDEDEFAULT },
|
|
{ "loadgrp", T_LOADGRP },
|
|
{ "noautoload", T_NOAUTOLOAD }
|
|
};
|
|
|
|
while (1)
|
|
{
|
|
tokn = getatoken(script,grptokens,sizeof(grptokens)/sizeof(tokenlist));
|
|
cmdtokptr = script->ltextptr;
|
|
switch (tokn)
|
|
{
|
|
case T_LOADGRP:
|
|
{
|
|
char *fn;
|
|
|
|
pathsearchmode = 1;
|
|
if (!scriptfile_getstring(script,&fn))
|
|
{
|
|
int32_t j = initgroupfile(fn);
|
|
|
|
if (j == -1)
|
|
initprintf("Could not find group file \"%s\".\n",fn);
|
|
else
|
|
{
|
|
initprintf("Using group file \"%s\".\n",fn);
|
|
if (!NoAutoLoad)
|
|
DoAutoload(fn);
|
|
}
|
|
|
|
}
|
|
pathsearchmode = 0;
|
|
}
|
|
break;
|
|
case T_INCLUDE:
|
|
{
|
|
char *fn;
|
|
if (!scriptfile_getstring(script,&fn))
|
|
parsegroupfiles_include(fn, script, cmdtokptr);
|
|
break;
|
|
}
|
|
break;
|
|
case T_INCLUDEDEFAULT:
|
|
{
|
|
parsegroupfiles_include(defsfilename, script, cmdtokptr);
|
|
break;
|
|
}
|
|
break;
|
|
case T_NOAUTOLOAD:
|
|
NoAutoLoad = 1;
|
|
break;
|
|
case T_EOF:
|
|
return(0);
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int32_t loadgroupfiles(const char *fn)
|
|
{
|
|
scriptfile *script;
|
|
int32_t i;
|
|
|
|
script = scriptfile_fromfile(fn);
|
|
if (!script) return -1;
|
|
|
|
parsegroupfiles(script);
|
|
|
|
for (i=0; i < g_defModulesNum; ++i)
|
|
parsegroupfiles_include(g_defModules[i], NULL, "null");
|
|
|
|
scriptfile_close(script);
|
|
scriptfile_clearsymbols();
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t parsetilegroups(scriptfile *script)
|
|
{
|
|
int32_t tokn;
|
|
char *cmdtokptr;
|
|
|
|
tokenlist tgtokens[] =
|
|
{
|
|
{ "include", T_INCLUDE },
|
|
{ "#include", T_INCLUDE },
|
|
{ "define", T_DEFINE },
|
|
{ "#define", T_DEFINE },
|
|
{ "tilegroup", T_TILEGROUP },
|
|
{ "spritehotkey", T_HOTKEY },
|
|
{ "alphabet", T_ALPHABET },
|
|
};
|
|
|
|
while (1)
|
|
{
|
|
tokn = getatoken(script,tgtokens,sizeof(tgtokens)/sizeof(tokenlist));
|
|
cmdtokptr = script->ltextptr;
|
|
switch (tokn)
|
|
{
|
|
case T_HOTKEY:
|
|
{
|
|
int32_t i, j;
|
|
if (scriptfile_getsymbol(script,&i)) break;
|
|
if (scriptfile_getsymbol(script,&j)) break;
|
|
if (i < 0 || i > 9 || j < 0 || j >= MAXTILES) break;
|
|
prefixtiles[i] = j;
|
|
break;
|
|
}
|
|
case T_INCLUDE:
|
|
{
|
|
char *fn;
|
|
if (!scriptfile_getstring(script,&fn))
|
|
{
|
|
scriptfile *included;
|
|
|
|
included = scriptfile_fromfile(fn);
|
|
if (!included)
|
|
{
|
|
initprintf("Warning: Failed including %s on line %s:%d\n",
|
|
fn, script->filename,scriptfile_getlinum(script,cmdtokptr));
|
|
}
|
|
else
|
|
{
|
|
parsetilegroups(included);
|
|
scriptfile_close(included);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case T_DEFINE:
|
|
{
|
|
char *name;
|
|
int32_t number;
|
|
|
|
if (scriptfile_getstring(script,&name)) break;
|
|
if (scriptfile_getsymbol(script,&number)) break;
|
|
if (scriptfile_addsymbolvalue(name,number) < 0)
|
|
initprintf("Warning: Symbol %s was NOT redefined to %d on line %s:%d\n",
|
|
name,number,script->filename,scriptfile_getlinum(script,cmdtokptr));
|
|
break;
|
|
}
|
|
case T_TILEGROUP:
|
|
{
|
|
char *end, *name;
|
|
int32_t i;
|
|
|
|
if (tile_groups >= MAX_TILE_GROUPS) break;
|
|
if (scriptfile_getstring(script,&name)) break;
|
|
if (scriptfile_getbraces(script,&end)) break;
|
|
|
|
s_TileGroups[tile_groups].pIds = Bcalloc(MAX_TILE_GROUP_ENTRIES, sizeof(int32_t));
|
|
s_TileGroups[tile_groups].szText = Bstrdup(name);
|
|
|
|
while (script->textptr < end)
|
|
{
|
|
tokenlist tgtokens2[] =
|
|
{
|
|
{ "tilegroup", T_TILEGROUP },
|
|
{ "tile", T_TILE },
|
|
{ "tilerange", T_TILERANGE },
|
|
{ "hotkey", T_HOTKEY },
|
|
{ "tiles", T_TILES },
|
|
{ "colors", T_COLORS },
|
|
};
|
|
|
|
int32_t token = getatoken(script,tgtokens2,sizeof(tgtokens2)/sizeof(tokenlist));
|
|
switch (token)
|
|
{
|
|
case T_TILE:
|
|
{
|
|
if (scriptfile_getsymbol(script,&i)) break;
|
|
if (i >= 0 && i < MAXTILES && s_TileGroups[tile_groups].nIds < MAX_TILE_GROUP_ENTRIES)
|
|
s_TileGroups[tile_groups].pIds[s_TileGroups[tile_groups].nIds++] = i;
|
|
// OSD_Printf("added tile %d to group %d\n",i,g);
|
|
break;
|
|
}
|
|
case T_TILERANGE:
|
|
{
|
|
int32_t j;
|
|
if (scriptfile_getsymbol(script,&i)) break;
|
|
if (scriptfile_getsymbol(script,&j)) break;
|
|
if (i < 0 || i >= MAXTILES || j < 0 || j >= MAXTILES) break;
|
|
while (s_TileGroups[tile_groups].nIds < MAX_TILE_GROUP_ENTRIES && i <= j)
|
|
{
|
|
s_TileGroups[tile_groups].pIds[s_TileGroups[tile_groups].nIds++] = i++;
|
|
// OSD_Printf("added tile %d to group %d\n",i,g);
|
|
}
|
|
break;
|
|
}
|
|
case T_COLORS:
|
|
{
|
|
int32_t j;
|
|
if (scriptfile_getsymbol(script, &i)) break;
|
|
if (scriptfile_getsymbol(script, &j)) break;
|
|
if (i < 0 || i >= 256 || j < 0 || j >= 256) break;
|
|
s_TileGroups[tile_groups].color1 = i;
|
|
s_TileGroups[tile_groups].color2 = j;
|
|
break;
|
|
}
|
|
case T_HOTKEY:
|
|
{
|
|
char *c;
|
|
if (scriptfile_getstring(script,&c)) break;
|
|
s_TileGroups[tile_groups].key1 = Btoupper(c[0]);
|
|
s_TileGroups[tile_groups].key2 = Btolower(c[0]);
|
|
break;
|
|
}
|
|
case T_TILES:
|
|
{
|
|
char *end2;
|
|
if (scriptfile_getbraces(script,&end2)) break;
|
|
while (script->textptr < end2-1)
|
|
{
|
|
if (!scriptfile_getsymbol(script,&i))
|
|
{
|
|
if (i >= 0 && i < MAXTILES && s_TileGroups[tile_groups].nIds < MAX_TILE_GROUP_ENTRIES)
|
|
s_TileGroups[tile_groups].pIds[s_TileGroups[tile_groups].nIds++] = i;
|
|
// OSD_Printf("added tile %d to group %d\n",i,g);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
s_TileGroups[tile_groups].pIds = Brealloc(s_TileGroups[tile_groups].pIds,
|
|
s_TileGroups[tile_groups].nIds*sizeof(int32_t));
|
|
tile_groups++;
|
|
break;
|
|
}
|
|
case T_ALPHABET:
|
|
{
|
|
char *end;
|
|
int32_t i, j, k;
|
|
|
|
if (numalphabets >= MAX_ALPHABETS)
|
|
{
|
|
OSD_Printf("Too many alphabet definitions (max: %d).\n", MAX_ALPHABETS);
|
|
break;
|
|
}
|
|
|
|
if (scriptfile_getbraces(script,&end)) break;
|
|
|
|
for (i=0; i<NUMPRINTABLES; i++)
|
|
{
|
|
alphabets[numalphabets].pic[i] = -1;
|
|
alphabets[numalphabets].xofs[i] = 0;
|
|
alphabets[numalphabets].yofs[i] = 0;
|
|
}
|
|
|
|
while (script->textptr < end)
|
|
{
|
|
tokenlist alphtokens2[] =
|
|
{
|
|
{ "map", T_MAP },
|
|
{ "mapa", T_MAPA },
|
|
{ "maprange", T_MAPRANGE },
|
|
{ "maprangea", T_MAPRANGEA },
|
|
{ "offset", T_OFFSET },
|
|
{ "offseta", T_OFFSETA },
|
|
};
|
|
|
|
int32_t token = getatoken(script,alphtokens2,sizeof(alphtokens2)/sizeof(tokenlist));
|
|
switch (token)
|
|
{
|
|
case T_MAP: // map <ascii num> <start tilenum>, e.g. map 46 3002
|
|
{
|
|
if (scriptfile_getnumber(script,&i)) break;
|
|
if (scriptfile_getsymbol(script,&j)) break;
|
|
|
|
if (i>=33 && i<=126 && j>= 0 && j<MAXTILES)
|
|
alphabets[numalphabets].pic[i-33] = j;
|
|
|
|
break;
|
|
}
|
|
case T_MAPA: // mapa <ascii string> <start tilenum>, e.g. map ".,!?" 3002
|
|
{
|
|
char *s;
|
|
if (scriptfile_getstring(script,&s)) break;
|
|
if (scriptfile_getsymbol(script,&i)) break;
|
|
|
|
for (; *s; s++, i++)
|
|
{
|
|
if (*s>=33 && *s<=126 && i>= 0 && i<MAXTILES)
|
|
alphabets[numalphabets].pic[(*s)-33] = i;
|
|
}
|
|
break;
|
|
}
|
|
// maprange <start ascii num> <end ascii num> <start tilenum>, e.g. map 33 126 STARTALPHANUM
|
|
// maprangea <start char> <end char> <start tilenum>, e.g. map "!" "~" STARTALPHANUM
|
|
case T_MAPRANGE:
|
|
case T_MAPRANGEA:
|
|
{
|
|
if (token==T_MAPRANGE)
|
|
{
|
|
if (scriptfile_getnumber(script,&i)) break;
|
|
if (scriptfile_getnumber(script,&j)) break;
|
|
}
|
|
else
|
|
{
|
|
char *c1, *c2;
|
|
if (scriptfile_getstring(script,&c1)) break;
|
|
if (scriptfile_getstring(script,&c2)) break;
|
|
i=*c1;
|
|
j=*c2;
|
|
}
|
|
if (scriptfile_getsymbol(script,&k)) break;
|
|
|
|
if (i>126 || j<33) break;
|
|
for (; i<=j && k<MAXTILES; i++, k++)
|
|
{
|
|
if (i>=33 && i<=126)
|
|
alphabets[numalphabets].pic[i-33] = k;
|
|
}
|
|
break;
|
|
}
|
|
case T_OFFSET: // offset <ascii num> <xoffset> <yoffset>
|
|
{
|
|
if (scriptfile_getnumber(script, &i)) break;
|
|
if (scriptfile_getnumber(script, &j)) break;
|
|
if (scriptfile_getnumber(script, &k)) break;
|
|
|
|
if (i >= 33 && i <= 126)
|
|
{
|
|
alphabets[numalphabets].xofs[i-33] = j;
|
|
alphabets[numalphabets].yofs[i-33] = k;
|
|
}
|
|
break;
|
|
}
|
|
case T_OFFSETA: // offseta <ascii string> <xoffset> <yoffset>
|
|
{
|
|
char *s;
|
|
if (scriptfile_getstring(script, &s)) break;
|
|
if (scriptfile_getnumber(script, &i)) break;
|
|
if (scriptfile_getnumber(script, &j)) break;
|
|
|
|
for (; *s; s++)
|
|
if (*s >= 33 && *s <= 126)
|
|
{
|
|
alphabets[numalphabets].xofs[(*s)-33] = i;
|
|
alphabets[numalphabets].yofs[(*s)-33] = j;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
numalphabets++;
|
|
break;
|
|
}
|
|
case T_EOF:
|
|
return(0);
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int32_t loadtilegroups(const char *fn)
|
|
{
|
|
int32_t i, j;
|
|
scriptfile *script;
|
|
TileGroup blank = { NULL, 0, NULL, 0, 0, 0, 0};
|
|
|
|
script = scriptfile_fromfile(fn);
|
|
if (!script) return -1;
|
|
|
|
for (i=0; i<tile_groups; i++)
|
|
{
|
|
if (s_TileGroups[i].pIds)
|
|
Bfree(s_TileGroups[i].pIds);
|
|
if (s_TileGroups[i].szText)
|
|
Bfree(s_TileGroups[i].szText);
|
|
Bmemcpy(&s_TileGroups[i], &blank, sizeof(blank));
|
|
}
|
|
tile_groups = 0;
|
|
#if 0
|
|
// ---------- Init hardcoded tile group consisting of all named tiles
|
|
s_TileGroups[0].szText = Bstrdup("All named");
|
|
s_TileGroups[0].pIds = Bmalloc(MAXTILES * sizeof(s_TileGroups[0].pIds[0]));
|
|
if (!s_TileGroups[0].pIds)
|
|
return -1;
|
|
j = 0;
|
|
for (i=0; i<MAXTILES; i++)
|
|
if (names[i][0])
|
|
s_TileGroups[0].pIds[j++] = i;
|
|
if (j)
|
|
{
|
|
s_TileGroups[0].nIds = j;
|
|
s_TileGroups[0].key1 = 'Y';
|
|
s_TileGroups[0].key2 = 'y';
|
|
tile_groups++;
|
|
}
|
|
// --------------------
|
|
#endif
|
|
parsetilegroups(script);
|
|
|
|
scriptfile_close(script);
|
|
scriptfile_clearsymbols();
|
|
|
|
tilegroupItems = getTileGroup("Items");
|
|
tilegroupActors = getTileGroup("Actors");
|
|
|
|
// Apply 2d sprite colors as specified in tiles.cfg.
|
|
for (i=0; i<tile_groups; i++)
|
|
{
|
|
// If the colors were specified...
|
|
if (s_TileGroups[i].color1 && s_TileGroups[i].color2)
|
|
{
|
|
for (j = s_TileGroups[i].nIds-1; j >= 0 ; j--)
|
|
{
|
|
// Apply the colors to all tiles in the group.
|
|
spritecol2d[s_TileGroups[i].pIds[j]][0] = s_TileGroups[i].color1;
|
|
spritecol2d[s_TileGroups[i].pIds[j]][1] = s_TileGroups[i].color2;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/// vvv Parse CON files partially to get sound definitions
|
|
static int32_t parseconsounds(scriptfile *script);
|
|
|
|
static void parseconsounds_include(const char *fn, scriptfile *script, char *cmdtokptr)
|
|
{
|
|
scriptfile *included;
|
|
|
|
included = scriptfile_fromfile(fn);
|
|
if (!included)
|
|
{
|
|
if (!Bstrcasecmp(cmdtokptr,"null"))
|
|
initprintf("Warning: Failed including %s as module\n", fn);
|
|
else
|
|
initprintf("Warning: Failed including %s on line %s:%d\n",
|
|
fn, script->filename,scriptfile_getlinum(script,cmdtokptr));
|
|
}
|
|
else
|
|
{
|
|
parseconsounds(included);
|
|
scriptfile_close(included);
|
|
/*
|
|
// why?
|
|
int32_t tmp = parseconsounds(included);
|
|
scriptfile_close(included);
|
|
if (tmp < 0) return tmp;
|
|
*/
|
|
}
|
|
}
|
|
|
|
static int32_t parseconsounds(scriptfile *script)
|
|
{
|
|
int32_t tokn;
|
|
char *cmdtokptr;
|
|
int32_t num_invalidsounds=0;
|
|
|
|
tokenlist cstokens[] =
|
|
{
|
|
{ "include", T_INCLUDE },
|
|
{ "#include", T_INCLUDE },
|
|
{ "includedefault", T_INCLUDEDEFAULT },
|
|
{ "#includedefault", T_INCLUDEDEFAULT },
|
|
{ "define", T_DEFINE },
|
|
{ "#define", T_DEFINE },
|
|
{ "definesound", T_DEFINESOUND },
|
|
};
|
|
|
|
while (1)
|
|
{
|
|
tokn = getatoken(script,cstokens,sizeof(cstokens)/sizeof(tokenlist));
|
|
cmdtokptr = script->ltextptr;
|
|
switch (tokn)
|
|
{
|
|
case T_INCLUDE:
|
|
{
|
|
char *fn;
|
|
if (!scriptfile_getstring(script,&fn))
|
|
parseconsounds_include(fn, script, cmdtokptr);
|
|
break;
|
|
}
|
|
case T_INCLUDEDEFAULT:
|
|
{
|
|
parseconsounds_include(defaultgameconfile(), script, cmdtokptr);
|
|
break;
|
|
}
|
|
case T_DEFINE:
|
|
{
|
|
char *name;
|
|
int32_t number;
|
|
|
|
if (scriptfile_getstring(script,&name)) break;
|
|
if (scriptfile_getsymbol(script,&number)) break;
|
|
if (scriptfile_addsymbolvalue(name,number) < 0)
|
|
initprintf("Warning: Symbol %s was NOT redefined to %d on line %s:%d\n",
|
|
name,number,script->filename,scriptfile_getlinum(script,cmdtokptr));
|
|
break;
|
|
}
|
|
case T_DEFINESOUND:
|
|
{
|
|
char *definedname, *filename;
|
|
int32_t sndnum, ps, pe, pr, m, vo;
|
|
int32_t slen, duplicate=0;
|
|
|
|
if (scriptfile_getsymbol(script, &sndnum)) break;
|
|
|
|
definedname = Bstrdup(script->ltextptr);
|
|
if (!definedname) return -1;
|
|
|
|
if (sndnum < 0 || sndnum >= MAXSOUNDS)
|
|
{
|
|
initprintf("Warning: invalid sound definition %s (sound number < 0 or >= MAXSOUNDS) on line %s:%d\n",
|
|
definedname, script->filename,scriptfile_getlinum(script,cmdtokptr));
|
|
Bfree(definedname);
|
|
num_invalidsounds++;
|
|
break;
|
|
}
|
|
|
|
if (scriptfile_getstring(script, &filename))
|
|
{
|
|
Bfree(definedname);
|
|
num_invalidsounds++;
|
|
break;
|
|
}
|
|
|
|
slen = Bstrlen(filename);
|
|
if (slen >= BMAX_PATH)
|
|
{
|
|
initprintf("Warning: invalid sound definition %s (filename too long) on line %s:%d\n",
|
|
definedname, script->filename,scriptfile_getlinum(script,cmdtokptr));
|
|
Bfree(definedname);
|
|
num_invalidsounds++;
|
|
break;
|
|
}
|
|
|
|
if (g_sounds[sndnum].filename)
|
|
{
|
|
duplicate = 1;
|
|
Bfree(g_sounds[sndnum].filename);
|
|
}
|
|
g_sounds[sndnum].filename = Bcalloc(slen+1,sizeof(uint8_t));
|
|
// Hopefully noone does memcpy(..., g_sounds[].filename, BMAX_PATH)
|
|
if (!g_sounds[sndnum].filename)
|
|
{
|
|
Bfree(definedname);
|
|
return -1;
|
|
}
|
|
Bmemcpy(g_sounds[sndnum].filename, filename, slen+1);
|
|
|
|
if (scriptfile_getnumber(script, &ps)) goto BAD;
|
|
if (scriptfile_getnumber(script, &pe)) goto BAD;
|
|
if (scriptfile_getnumber(script, &pr)) goto BAD;
|
|
if (scriptfile_getnumber(script, &m)) goto BAD;
|
|
if (ParentalLock && (m&8)) goto BAD;
|
|
if (scriptfile_getnumber(script, &vo)) goto BAD;
|
|
if (0)
|
|
{
|
|
BAD:
|
|
Bfree(definedname);
|
|
Bfree(g_sounds[sndnum].filename);
|
|
g_sounds[sndnum].filename = NULL;
|
|
num_invalidsounds++;
|
|
break;
|
|
}
|
|
|
|
if (g_sounds[sndnum].definedname)
|
|
{
|
|
duplicate = 1;
|
|
Bfree(g_sounds[sndnum].definedname);
|
|
}
|
|
if (duplicate)
|
|
initprintf("warning: duplicate sound #%d, overwriting\n", sndnum);
|
|
|
|
g_sounds[sndnum].definedname = definedname; // we want to keep it for display purposes
|
|
g_sounds[sndnum].ps = ps;
|
|
g_sounds[sndnum].pe = pe;
|
|
g_sounds[sndnum].pr = pr;
|
|
g_sounds[sndnum].m = m;
|
|
g_sounds[sndnum].vo = vo;
|
|
if (!duplicate)
|
|
{
|
|
g_sndnum[g_numsounds] = g_definedsndnum[g_numsounds] = sndnum;
|
|
g_numsounds++;
|
|
if (g_numsounds == MAXSOUNDS)
|
|
goto END;
|
|
}
|
|
break;
|
|
}
|
|
case T_EOF:
|
|
goto END;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
END:
|
|
return g_numsounds;
|
|
}
|
|
|
|
static int32_t loadconsounds(const char *fn)
|
|
{
|
|
scriptfile *script;
|
|
int32_t ret, i;
|
|
|
|
initprintf("Loading sounds from \"%s\"\n",fn);
|
|
|
|
script = scriptfile_fromfile(fn);
|
|
if (!script)
|
|
{
|
|
initprintf("Error loading sounds: file \"%s\" not found.\n", fn);
|
|
return -1;
|
|
}
|
|
ret = parseconsounds(script);
|
|
|
|
for (i=0; i < g_scriptModulesNum; ++i)
|
|
{
|
|
parseconsounds_include(g_scriptModules[i], NULL, "null");
|
|
Bfree(g_scriptModules[i]);
|
|
}
|
|
Bfree(g_scriptModules);
|
|
|
|
if (ret < 0)
|
|
initprintf("There was an error parsing \"%s\".\n", fn);
|
|
else if (ret == 0)
|
|
initprintf("\"%s\" doesn't contain sound definitions. No sounds loaded.\n", fn);
|
|
else
|
|
initprintf("Loaded %d sound definitions.\n", ret);
|
|
|
|
scriptfile_close(script);
|
|
scriptfile_clearsymbols();
|
|
return ret;
|
|
}
|
|
|
|
void ExtPreLoadMap(void)
|
|
{
|
|
}
|
|
|
|
/// ^^^
|
|
|
|
static void m32script_interrupt_handler(int signo)
|
|
{
|
|
if (signo==SIGINT)
|
|
{
|
|
vm.flags |= VMFLAG_ERROR;
|
|
OSD_Printf("M32 script execution interrupted.\n");
|
|
Bmemset(aEventEnabled, 0, sizeof(aEventEnabled));
|
|
}
|
|
}
|
|
|
|
int32_t ExtInit(void)
|
|
{
|
|
int32_t rv = 0;
|
|
int32_t i;
|
|
char cwd[BMAX_PATH];
|
|
|
|
#if defined(__linux__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
|
|
addsearchpath("/usr/share/games/jfduke3d");
|
|
addsearchpath("/usr/local/share/games/jfduke3d");
|
|
addsearchpath("/usr/share/games/eduke32");
|
|
addsearchpath("/usr/local/share/games/eduke32");
|
|
#elif defined(__APPLE__)
|
|
addsearchpath("/Library/Application Support/JFDuke3D");
|
|
addsearchpath("/Library/Application Support/EDuke32");
|
|
#endif
|
|
|
|
if (getcwd(cwd,BMAX_PATH))
|
|
{
|
|
#if defined(__APPLE__)
|
|
/* Dirty hack on OS X to also look for gamedata inside the application bundle - rhoenie 08/08 */
|
|
char seekinappcontainer[BMAX_PATH];
|
|
Bsnprintf(seekinappcontainer,sizeof(seekinappcontainer),"%s/EDuke32.app/", cwd);
|
|
addsearchpath(seekinappcontainer);
|
|
#endif
|
|
addsearchpath(cwd);
|
|
Bstrcpy(program_origcwd, cwd);
|
|
}
|
|
else
|
|
program_origcwd[0] = '\0';
|
|
|
|
if (CommandPaths)
|
|
{
|
|
struct strllist *s;
|
|
while (CommandPaths)
|
|
{
|
|
s = CommandPaths->next;
|
|
i = addsearchpath(CommandPaths->str);
|
|
if (i < 0)
|
|
{
|
|
initprintf("Failed adding %s for game data: %s\n", CommandPaths->str,
|
|
i==-1 ? "not a directory" : "no such directory");
|
|
}
|
|
|
|
Bfree(CommandPaths->str);
|
|
Bfree(CommandPaths);
|
|
CommandPaths = s;
|
|
}
|
|
}
|
|
|
|
#if defined(_WIN32)
|
|
if (!access("user_profiles_enabled", F_OK))
|
|
#else
|
|
if (usecwd == 0 && access("user_profiles_disabled", F_OK))
|
|
#endif
|
|
{
|
|
char *homedir;
|
|
int32_t asperr;
|
|
|
|
if ((homedir = Bgethomedir()))
|
|
{
|
|
Bsnprintf(cwd,sizeof(cwd),"%s/"
|
|
#if defined(_WIN32)
|
|
"EDuke32 Settings"
|
|
#elif defined(__APPLE__)
|
|
"Library/Application Support/EDuke32"
|
|
#else
|
|
".eduke32"
|
|
#endif
|
|
,homedir);
|
|
asperr = addsearchpath(cwd);
|
|
if (asperr == -2)
|
|
{
|
|
if (Bmkdir(cwd,S_IRWXU) == 0) asperr = addsearchpath(cwd);
|
|
else asperr = -1;
|
|
}
|
|
if (asperr == 0)
|
|
chdir(cwd);
|
|
Bfree(homedir);
|
|
}
|
|
}
|
|
|
|
// JBF 20031220: Because it's annoying renaming GRP files whenever I want to test different game data
|
|
if (getenv("DUKE3DGRP"))
|
|
{
|
|
g_grpNamePtr = getenv("DUKE3DGRP");
|
|
initprintf("Using \"%s\" as main GRP file\n", g_grpNamePtr);
|
|
}
|
|
|
|
i = initgroupfile(g_grpNamePtr);
|
|
|
|
if (!NoAutoLoad)
|
|
{
|
|
static const char *extensions[3] = { "*.grp", "*.zip", "*.pk3" };
|
|
int32_t exti;
|
|
|
|
for (exti=0; exti<3; exti++)
|
|
{
|
|
getfilenames("autoload", extensions[exti]);
|
|
while (findfiles)
|
|
{
|
|
Bsprintf(tempbuf,"autoload/%s",findfiles->name);
|
|
initprintf("Using group file \"%s\".\n",tempbuf);
|
|
initgroupfile(tempbuf);
|
|
findfiles = findfiles->next;
|
|
}
|
|
}
|
|
|
|
if (i != -1)
|
|
DoAutoload(g_grpNamePtr);
|
|
}
|
|
|
|
if (getenv("DUKE3DDEF"))
|
|
{
|
|
g_defNamePtr = getenv("DUKE3DDEF");
|
|
g_skipDefaultDefs = 1;
|
|
initprintf("Using \"%s\" as definitions file\n", g_defNamePtr);
|
|
}
|
|
if (g_skipDefaultDefs == 0)
|
|
if (g_defNamePtr != defsfilename)
|
|
Bstrcpy(g_defNamePtr, defsfilename); // it MAY have changed, with NAM/WWII GI
|
|
|
|
loadgroupfiles(g_defNamePtr); // the defs are actually loaded in app_main in build.c
|
|
|
|
{
|
|
struct strllist *s;
|
|
int32_t j;
|
|
|
|
pathsearchmode = 1;
|
|
while (CommandGrps)
|
|
{
|
|
s = CommandGrps->next;
|
|
j = initgroupfile(CommandGrps->str);
|
|
if (j == -1) initprintf("Could not find group file \"%s\".\n",CommandGrps->str);
|
|
else
|
|
{
|
|
initprintf("Using group file \"%s\".\n",CommandGrps->str);
|
|
if (!NoAutoLoad)
|
|
DoAutoload(CommandGrps->str);
|
|
}
|
|
|
|
Bfree(CommandGrps->str);
|
|
Bfree(CommandGrps);
|
|
CommandGrps = s;
|
|
}
|
|
pathsearchmode = 0;
|
|
}
|
|
|
|
bpp = 32;
|
|
|
|
#ifdef USE_OPENGL
|
|
glusetexcache = -1;
|
|
|
|
if (Bstrcmp(setupfilename, "mapster32.cfg"))
|
|
initprintf("Using config file \"%s\".\n",setupfilename);
|
|
|
|
if (loadsetup(setupfilename) < 0)
|
|
initprintf("Configuration file not found, using defaults.\n"), rv = 1;
|
|
|
|
if (glusetexcache == -1)
|
|
{
|
|
int32_t i;
|
|
#if 0
|
|
i=wm_ynbox("Texture Cache",
|
|
"Would you like to enable the on-disk texture cache?\n\n"
|
|
"You generally want to say 'yes' here, especially if using the HRP.");
|
|
#else
|
|
i = 1;
|
|
#endif
|
|
if (i)
|
|
glusetexcompr = 1, glusetexcache = 2;
|
|
else glusetexcache = 0;
|
|
}
|
|
#endif
|
|
|
|
Bmemcpy(buildkeys, default_buildkeys, NUMBUILDKEYS); //Trick to make build use setup.dat keys
|
|
|
|
if (initengine())
|
|
{
|
|
initprintf("There was a problem initializing the engine.\n");
|
|
return -1;
|
|
}
|
|
|
|
setbasepaltable(basepaltable, BASEPALCOUNT);
|
|
|
|
kensplayerheight = 40; //32
|
|
zmode = 2;
|
|
zlock = kensplayerheight<<8;
|
|
|
|
showinvisibility = 1;
|
|
|
|
ReadPaletteTable();
|
|
|
|
InitCustomColors();
|
|
|
|
getmessageleng = 0;
|
|
getmessagetimeoff = 0;
|
|
|
|
Bsprintf(apptitle, "Mapster32 %s %s", VERSION, s_buildRev);
|
|
autosavetimer = totalclock+120*autosave;
|
|
|
|
#if defined(DUKEOSD)
|
|
m32_osdsetfunctions();
|
|
#endif
|
|
|
|
OSD_SetParameters(0,2, 0,0, 4,0);
|
|
registerosdcommands();
|
|
|
|
// backup pathsearchmode so that a later open
|
|
// will hopefully be the same file
|
|
pathsearchmode_oninit = pathsearchmode;
|
|
loadtilegroups(default_tiles_cfg);
|
|
|
|
ReadHelpFile("m32help.hlp");
|
|
|
|
MultiPskyInit();
|
|
|
|
signal(SIGINT, m32script_interrupt_handler);
|
|
|
|
return rv;
|
|
}
|
|
|
|
#ifdef RENDERTYPEWIN
|
|
void app_crashhandler(void)
|
|
{
|
|
if (levelname[0])
|
|
{
|
|
char *f = Bstrstr(levelname,".map");
|
|
|
|
if (f)
|
|
Bstrcpy(f,"_crash.map");
|
|
else Bstrcat(f,"_crash.map");
|
|
|
|
SaveBoard(f, 1);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void ExtUnInit(void)
|
|
{
|
|
// int32_t i;
|
|
// setvmode(0x03);
|
|
writesetup(setupfilename);
|
|
|
|
S_SoundShutdown();
|
|
uninitgroupfile();
|
|
#if 0
|
|
for (i = MAX_TILE_GROUPS-1; i >= 0; i--)
|
|
{
|
|
if (s_TileGroups[i].pIds != NULL)
|
|
Bfree(s_TileGroups[i].pIds);
|
|
if (s_TileGroups[i].szText != NULL)
|
|
Bfree(s_TileGroups[i].szText);
|
|
}
|
|
for (i = numhelppages-1; i >= 0; i--) Bfree(helppage[i]);
|
|
if (helppage) Bfree(helppage);
|
|
#endif
|
|
}
|
|
|
|
void ExtPreCheckKeys(void) // just before drawrooms
|
|
{
|
|
int32_t i = 0, ii;
|
|
int32_t radius, xp1, yp1;
|
|
int32_t col;
|
|
int32_t picnum, frames;
|
|
int32_t daang = 0, flags, shade;
|
|
|
|
if (qsetmode == 200) //In 3D mode
|
|
{
|
|
if (shadepreview)
|
|
{
|
|
for (i=0; i<highlightsectorcnt; i++)
|
|
{
|
|
ii = highlightsector[i];
|
|
sectorpals[ii][0] = sector[ii].floorpal;
|
|
sectorpals[ii][1] = sector[ii].ceilingpal;
|
|
|
|
sector[ii].floorpal = sector[ii].ceilingpal = 6;
|
|
}
|
|
|
|
// int32_t i = 0;
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
{
|
|
if (sprite[i].statnum==MAXSTATUS)
|
|
continue;
|
|
|
|
if (sprite[i].picnum == SECTOREFFECTOR &&
|
|
(sprite[i].lotag == 12 || sprite[i].lotag == 3 || sprite[i].lotag == 4))
|
|
{
|
|
int32_t w, isec=sprite[i].sectnum;
|
|
int32_t start_wall;
|
|
int32_t end_wall;
|
|
|
|
if (isec<0)
|
|
continue;
|
|
|
|
start_wall = sector[isec].wallptr;
|
|
end_wall = start_wall + sector[isec].wallnum;
|
|
|
|
for (w = start_wall; w < end_wall; w++)
|
|
{
|
|
if (!(wallflag[w>>3]&(1<<(w&7))))
|
|
{
|
|
wallshades[w] = wall[w].shade;
|
|
wallpals[w] = wall[w].pal;
|
|
|
|
wall[w].shade = sprite[i].shade;
|
|
wall[w].pal = sprite[i].pal;
|
|
|
|
wallflag[w>>3] |= (1<<(w&7));
|
|
}
|
|
// removed: same thing with nextwalls
|
|
}
|
|
sectorshades[isec][0] = sector[isec].floorshade;
|
|
sectorshades[isec][1] = sector[isec].ceilingshade;
|
|
sector[isec].floorshade = sprite[i].shade;
|
|
sector[isec].ceilingshade = sprite[i].shade;
|
|
|
|
sectorpals[isec][0] = sector[isec].floorpal;
|
|
sectorpals[isec][1] = sector[isec].ceilingpal;
|
|
sector[isec].floorpal = sprite[i].pal;
|
|
sector[isec].ceilingpal = sprite[i].pal;
|
|
|
|
for (w = headspritesect[isec]; w >= 0; w = nextspritesect[w])
|
|
{
|
|
if (w == i)
|
|
continue;
|
|
|
|
spriteshades[w] = sprite[w].shade;
|
|
spritepals[w] = sprite[w].pal;
|
|
|
|
sprite[w].shade = sprite[i].shade;
|
|
sprite[w].pal = sprite[i].pal;
|
|
}
|
|
}
|
|
else if (sprite[i].picnum == SECTOREFFECTOR && (sprite[i].lotag == 49 || sprite[i].lotag == 50))
|
|
{
|
|
#ifdef POLYMER
|
|
if (sprite[i].lotag == 49)
|
|
{
|
|
if (getrendermode() == 4)
|
|
{
|
|
if (spritelightptr[i] == NULL)
|
|
{
|
|
#pragma pack(push,1)
|
|
_prlight mylight;
|
|
#pragma pack(pop)
|
|
addprlight_common1(&mylight, i);
|
|
}
|
|
else
|
|
{
|
|
if (Bmemcmp(&sprite[i], spritelightptr[i], sizeof(vec3_t)))
|
|
{
|
|
Bmemcpy(spritelightptr[i], &sprite[i], sizeof(vec3_t));
|
|
spritelightptr[i]->sector = sprite[i].sectnum;
|
|
spritelightptr[i]->flags.invalidate = 1;
|
|
}
|
|
if (SHT != spritelightptr[i]->range)
|
|
{
|
|
spritelightptr[i]->range = SHT;
|
|
spritelightptr[i]->flags.invalidate = 1;
|
|
}
|
|
if (check_prlight_colors(i))
|
|
copy_prlight_colors(spritelightptr[i], i);
|
|
}
|
|
}
|
|
}
|
|
if (sprite[i].lotag == 50)
|
|
{
|
|
if (getrendermode() == 4)
|
|
{
|
|
if (spritelightptr[i] == NULL)
|
|
{
|
|
#pragma pack(push,1)
|
|
_prlight mylight;
|
|
#pragma pack(pop)
|
|
mylight.radius = (256-(SS+128))<<1;
|
|
mylight.faderadius = (int16_t)(mylight.radius * 0.75f);
|
|
mylight.tilenum = OW;
|
|
|
|
addprlight_common1(&mylight, i);
|
|
}
|
|
else
|
|
{
|
|
if (Bmemcmp(&sprite[i], spritelightptr[i], sizeof(vec3_t)))
|
|
{
|
|
Bmemcpy(spritelightptr[i], &sprite[i], sizeof(vec3_t));
|
|
spritelightptr[i]->sector = sprite[i].sectnum;
|
|
spritelightptr[i]->flags.invalidate = 1;
|
|
}
|
|
if (SHT != spritelightptr[i]->range)
|
|
{
|
|
spritelightptr[i]->range = SHT;
|
|
spritelightptr[i]->flags.invalidate = 1;
|
|
}
|
|
if (check_prlight_colors(i))
|
|
copy_prlight_colors(spritelightptr[i], i);
|
|
if (((256-(SS+128))<<1) != spritelightptr[i]->radius)
|
|
{
|
|
spritelightptr[i]->radius = (256-(SS+128))<<1;
|
|
spritelightptr[i]->faderadius = (int16_t)(spritelightptr[i]->radius * 0.75f);
|
|
spritelightptr[i]->flags.invalidate = 1;
|
|
}
|
|
if (SA != spritelightptr[i]->angle)
|
|
{
|
|
spritelightptr[i]->angle = SA;
|
|
spritelightptr[i]->flags.invalidate = 1;
|
|
}
|
|
if (SH != spritelightptr[i]->horiz)
|
|
{
|
|
spritelightptr[i]->horiz = SH;
|
|
spritelightptr[i]->flags.invalidate = 1;
|
|
}
|
|
spritelightptr[i]->tilenum = OW;
|
|
}
|
|
}
|
|
}
|
|
#endif // POLYMER
|
|
}
|
|
}
|
|
}
|
|
|
|
if (floor_over_floor) SE40Code(pos.x,pos.y,pos.z,ang,horiz);
|
|
if (purpleon) clearview(255);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
begindrawing(); //{{{
|
|
|
|
// if (cursectornum >= 0)
|
|
// fillsector(cursectornum, 31);
|
|
|
|
if (graphicsmode && !m32_sideview && zoom >= 256)
|
|
{
|
|
for (i=ii=0; i<MAXSPRITES && ii < Numsprites; i++)
|
|
{
|
|
if ((sprite[i].cstat & 48) != 0 || sprite[i].statnum == MAXSTATUS) continue;
|
|
ii++;
|
|
picnum = sprite[i].picnum;
|
|
daang = flags = frames = shade = 0;
|
|
|
|
switch (picnum)
|
|
{
|
|
// 5-frame walk
|
|
case 1550 : // Shark
|
|
frames=5;
|
|
// 2-frame walk
|
|
case 1445 : // duke kick
|
|
case LIZTROOPDUCKING :
|
|
case 2030 : // pig shot
|
|
case OCTABRAIN :
|
|
case PIGCOPDIVE :
|
|
case 2190 : // liz capt shot
|
|
case BOSS1SHOOT :
|
|
case BOSS1LOB :
|
|
case LIZTROOPSHOOT :
|
|
if (frames==0) frames=2;
|
|
|
|
// 4-frame walk
|
|
case 1491 : // duke crawl
|
|
case LIZTROOP :
|
|
case LIZTROOPRUNNING :
|
|
case PIGCOP :
|
|
case LIZMAN :
|
|
case BOSS1 :
|
|
case BOSS2 :
|
|
case BOSS3 :
|
|
case BOSS4 :
|
|
case NEWBEAST:
|
|
if (frames==0) frames=4;
|
|
case LIZTROOPJETPACK :
|
|
case DRONE :
|
|
case COMMANDER :
|
|
case TANK :
|
|
case RECON :
|
|
if (frames==0) frames = 10;
|
|
case CAMERA1:
|
|
case APLAYER :
|
|
if (frames==0) frames=1;
|
|
case GREENSLIME :
|
|
case EGG :
|
|
case PIGCOPSTAYPUT :
|
|
case LIZMANSTAYPUT:
|
|
case LIZTROOPSTAYPUT :
|
|
case LIZMANSPITTING :
|
|
case LIZMANFEEDING :
|
|
case LIZMANJUMP :
|
|
case NEWBEASTSTAYPUT :
|
|
case BOSS1STAYPUT :
|
|
{
|
|
int32_t k;
|
|
if (frames!=0)
|
|
{
|
|
if (frames==10) frames=0;
|
|
k = 1536;//getangle(tspr->x-pos.x,tspr->y-pos.y);
|
|
k = (((sprite[i].ang+3072+128-k)&2047)>>8)&7;
|
|
//This guy has only 5 pictures for 8 angles (3 are x-flipped)
|
|
if (k <= 4)
|
|
{
|
|
picnum += k;
|
|
daang = 0;
|
|
flags &= ~4;
|
|
}
|
|
else
|
|
{
|
|
picnum += 8-k;
|
|
daang = 1024;
|
|
flags |= 4;
|
|
}
|
|
}
|
|
|
|
if (graphicsmode == 2)
|
|
{
|
|
if (frames==2) picnum+=((((4-(totalclock>>5)))&1)*5);
|
|
if (frames==4) picnum+=((((4-(totalclock>>5)))&3)*5);
|
|
if (frames==5) picnum+=(((totalclock>>5)%5))*5;
|
|
}
|
|
|
|
if (tilesizx[picnum] == 0)
|
|
picnum -= 5; //Hack, for actors
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
xp1 = mulscale14(sprite[i].x-pos.x,zoom);
|
|
yp1 = mulscale14(sprite[i].y-pos.y-(tilesizy[picnum]<<2),zoom);
|
|
if (i+16384 != pointhighlight || !(totalclock&32))
|
|
{
|
|
shade = sprite[i].shade;
|
|
if (shade < 6)
|
|
shade = 6;
|
|
}
|
|
|
|
xp1 += halfxdim16;
|
|
yp1 += midydim16;
|
|
|
|
ydim16 = ydim-STATUS2DSIZ2;
|
|
|
|
if (xp1 < 4 || xp1 > xdim-6 || yp1 < 4 || yp1 > ydim16-6)
|
|
continue;
|
|
rotatesprite(xp1<<16,yp1<<16,zoom<<5,daang,picnum,
|
|
shade,sprite[i].pal,flags,0,0,xdim-1,ydim16-1);
|
|
}
|
|
}
|
|
|
|
if (showambiencesounds)
|
|
{
|
|
for (ii=0; ii<numsectors; ii++)
|
|
for (i=headspritesect[ii]; i>=0; i=nextspritesect[i])
|
|
{
|
|
if (sprite[i].picnum != MUSICANDSFX /*|| zoom < 256*/ )
|
|
continue;
|
|
|
|
if (showambiencesounds==1 && sprite[i].sectnum!=cursectnum)
|
|
continue;
|
|
|
|
screencoords(&xp1,&yp1, sprite[i].x-pos.x,sprite[i].y-pos.y, zoom);
|
|
if (m32_sideview)
|
|
yp1 += getscreenvdisp(sprite[i].z-pos.z, zoom);
|
|
|
|
radius = mulscale14(sprite[i].hitag,zoom);
|
|
col = 6;
|
|
if (i+16384 == pointhighlight)
|
|
if (totalclock & 32) col += (2<<2);
|
|
drawlinepat = 0xf0f0f0f0;
|
|
drawcircle16(halfxdim16+xp1, midydim16+yp1, radius, scalescreeny(16384), editorcolors[(int32_t)col]);
|
|
drawlinepat = 0xffffffff;
|
|
}
|
|
}
|
|
|
|
enddrawing(); //}}}
|
|
}
|
|
|
|
void ExtAnalyzeSprites(void)
|
|
{
|
|
int32_t i, k;
|
|
spritetype *tspr;
|
|
int32_t frames=0, sh;
|
|
|
|
for (i=0,tspr=&tsprite[0]; i<spritesortcnt; i++,tspr++)
|
|
{
|
|
frames=0;
|
|
|
|
if ((nosprites==1||nosprites==3) && tspr->picnum<11)
|
|
tspr->xrepeat=0;
|
|
|
|
if (nosprites==1||nosprites==3)
|
|
switch (tspr->picnum)
|
|
{
|
|
case SEENINE :
|
|
tspr->xrepeat=0;
|
|
}
|
|
|
|
if (showinvisibility && (tspr->cstat&32768))
|
|
{
|
|
tspr->pal = 6;
|
|
tspr->cstat &= ~32768;
|
|
tspr->cstat |= 2+512;
|
|
}
|
|
|
|
/* Shade preview rules (thanks to Gambini)
|
|
*
|
|
* 1st rule: Any pal value not equal to 0 in the floor of a sector will
|
|
* turn all the sprites within this sector to that pal value.
|
|
*
|
|
* 2nd rule: The shade of a sprite will be taken from the floor unless the
|
|
* ceiling is parallaxed, in which case will be taken from the
|
|
* ceiling. But not the pal which always follow the 1st rule.
|
|
*
|
|
* 3rd rule: relative to wall sprites will keep their own shade unless
|
|
* they're actors, but they will still retain the floor pal.
|
|
*/
|
|
if (shadepreview)
|
|
{
|
|
int32_t wallaligned = (tspr->cstat & 16);
|
|
|
|
if (tspr->sectnum<0)
|
|
continue;
|
|
|
|
// 1st rule
|
|
if (sector[tspr->sectnum].floorpal > 0 && sector[tspr->sectnum].floorpal < num_tables)
|
|
tspr->pal = sector[tspr->sectnum].floorpal;
|
|
|
|
// 2nd and 3rd rule minus "actor condition"
|
|
if (!wallaligned && (tspr->cstat&2048)==0)
|
|
{
|
|
if (sector[tspr->sectnum].ceilingstat&1)
|
|
sh = sector[tspr->sectnum].ceilingshade;
|
|
else
|
|
sh = sector[tspr->sectnum].floorshade;
|
|
|
|
inpclamp(&sh, -127, 127);
|
|
tspr->shade = sh;
|
|
}
|
|
}
|
|
|
|
switch (tspr->picnum)
|
|
{
|
|
// 5-frame walk
|
|
case 1550 : // Shark
|
|
frames=5;
|
|
// 2-frame walk
|
|
case 1445 : // duke kick
|
|
case LIZTROOPDUCKING :
|
|
case 2030 : // pig shot
|
|
case OCTABRAIN :
|
|
case PIGCOPDIVE :
|
|
case 2190 : // liz capt shot
|
|
case BOSS1SHOOT :
|
|
case BOSS1LOB :
|
|
case LIZTROOPSHOOT :
|
|
if (frames==0) frames=2;
|
|
|
|
// 4-frame walk
|
|
case 1491 : // duke crawl
|
|
case LIZTROOP :
|
|
case LIZTROOPRUNNING :
|
|
case PIGCOP :
|
|
case LIZMAN :
|
|
case BOSS1 :
|
|
case BOSS2 :
|
|
case BOSS3 :
|
|
case BOSS4 :
|
|
case NEWBEAST:
|
|
if (frames==0) frames=4;
|
|
case LIZTROOPJETPACK :
|
|
case DRONE :
|
|
case COMMANDER :
|
|
case TANK :
|
|
case RECON :
|
|
if (frames==0) frames = 10;
|
|
case ROTATEGUN :
|
|
case CAMERA1:
|
|
case APLAYER :
|
|
if (frames==0) frames=1;
|
|
case GREENSLIME :
|
|
case PIGCOPSTAYPUT :
|
|
case LIZMANSTAYPUT:
|
|
case LIZTROOPSTAYPUT :
|
|
case LIZMANSPITTING :
|
|
case LIZMANFEEDING :
|
|
case LIZMANJUMP :
|
|
case NEWBEASTSTAYPUT :
|
|
case BOSS1STAYPUT :
|
|
if (skill!=4)
|
|
{
|
|
if (tspr->lotag>skill+1)
|
|
{
|
|
tspr->xrepeat=0;
|
|
tspr->cstat=32768;
|
|
break;
|
|
}
|
|
}
|
|
if (nosprites==2||nosprites==3)
|
|
{
|
|
tspr->xrepeat=0;
|
|
tspr->cstat=32768;
|
|
}
|
|
// else tspr->cstat&=32767;
|
|
|
|
#ifdef USE_OPENGL
|
|
if (!usemodels || md_tilehasmodel(tspr->picnum,tspr->pal) < 0)
|
|
#endif
|
|
{
|
|
if (frames!=0)
|
|
{
|
|
if (frames==10) frames=0;
|
|
k = getangle(tspr->x-pos.x,tspr->y-pos.y);
|
|
k = (((tspr->ang+3072+128-k)&2047)>>8)&7;
|
|
//This guy has only 5 pictures for 8 angles (3 are x-flipped)
|
|
if (k <= 4)
|
|
{
|
|
tspr->picnum += k;
|
|
tspr->cstat &= ~4; //clear x-flipping bit
|
|
}
|
|
else
|
|
{
|
|
tspr->picnum += 8-k;
|
|
tspr->cstat |= 4; //set x-flipping bit
|
|
}
|
|
}
|
|
|
|
if (frames==2) tspr->picnum += (((4-(totalclock>>5)))&1)*5;
|
|
if (frames==4) tspr->picnum += (((4-(totalclock>>5)))&3)*5;
|
|
if (frames==5) tspr->picnum += ((totalclock>>5)%5)*5;
|
|
|
|
if (tilesizx[tspr->picnum] == 0)
|
|
tspr->picnum -= 5; //Hack, for actors
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
VM_OnEvent(EVENT_ANALYZESPRITES, -1);
|
|
}
|
|
|
|
#define MESSAGEX 3 // (xdimgame>>1)
|
|
#define MESSAGEY 3 // ((i/charsperline)<<3)+(ydimgame-(ydimgame>>3))-(((getmessageleng-1)/charsperline)<<3)
|
|
|
|
static void Keys2d3d(void)
|
|
{
|
|
int32_t i;
|
|
#if M32_UNDO
|
|
if (mapstate == NULL)
|
|
{
|
|
// map_revision = 0;
|
|
create_map_snapshot(); // initial map state
|
|
// Bfree(mapstate->next);
|
|
// mapstate = mapstate->prev;
|
|
}
|
|
#endif
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(A)) // 'A
|
|
{
|
|
if (qsetmode == 200)
|
|
autosave = autosave?0:getnumber256("Autosave interval, in seconds: ",180,3600,0);
|
|
else
|
|
autosave = autosave?0:getnumber16("Autosave interval, in seconds: ",180,3600,0);
|
|
|
|
if (autosave) message("Autosave enabled, interval: %d seconds",autosave);
|
|
else message("Autosave disabled");
|
|
}
|
|
|
|
if (keystatus[KEYSC_QUOTE] && PRESSED_KEYSC(N)) // 'N
|
|
{
|
|
m32_clipping--;
|
|
if (m32_clipping < 0)
|
|
m32_clipping = 2;
|
|
message("Clipping %s", m32_clipping==0 ? "disabled" :
|
|
(m32_clipping==1 ? "non-masks only" : "enabled"));
|
|
}
|
|
|
|
if (eitherCTRL && PRESSED_KEYSC(N)) // CTRL+N
|
|
{
|
|
spnoclip = !spnoclip;
|
|
message("Sprite clipping %s", spnoclip?"disabled":"enabled");
|
|
}
|
|
|
|
if (eitherCTRL) //CTRL
|
|
{
|
|
if (PRESSED_KEYSC(P)) // Ctrl-P: Map playtesting
|
|
{
|
|
if (qsetmode != 200)
|
|
test_map(eitherALT);
|
|
}
|
|
|
|
if (keystatus[KEYSC_S]) // S
|
|
{
|
|
if (levelname[0])
|
|
{
|
|
keystatus[KEYSC_S] = 0;
|
|
|
|
i = CheckMapCorruption(4, 0);
|
|
if (i<4)
|
|
{
|
|
Bsprintf(tempbuf, "Save to %s?", levelname);
|
|
if (!AskIfSure(tempbuf))
|
|
{
|
|
SaveBoard(levelname, 0);
|
|
|
|
message("Board saved to %s", levelname);
|
|
asksave = 0;
|
|
lastsave=totalclock;
|
|
}
|
|
}
|
|
else
|
|
message("Map is heavily corrupted, not saving. See OSD for details.");
|
|
}
|
|
}
|
|
if (keystatus[KEYSC_L]) // L
|
|
{
|
|
if (totalclock < (lastsave + 120*10) || !AskIfSure("Are you sure you want to load the last saved map?"))
|
|
{
|
|
int32_t sposx=pos.x,sposy=pos.y,sposz=pos.z,sang=ang;
|
|
char *f;
|
|
|
|
if (pathsearchmode) f = levelname;
|
|
else
|
|
{
|
|
// virtual filesystem mode can't save to directories so drop the file into
|
|
// the current directory
|
|
f = Bstrrchr(levelname, '/');
|
|
if (!f) f = levelname; else f++;
|
|
}
|
|
|
|
lastsave=totalclock;
|
|
// sectorhighlightstat = -1;
|
|
// newnumwalls = -1;
|
|
// joinsector[0] = -1;
|
|
// circlewall = -1;
|
|
// circlepoints = 7;
|
|
|
|
if (LoadBoard(f, 0))
|
|
message("Invalid map format.");
|
|
|
|
pos.x=sposx; pos.y=sposy; pos.z=sposz; ang=sang;
|
|
updatesectorz(pos.x, pos.y, pos.z, &cursectnum);
|
|
|
|
keystatus[KEYSC_L] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (keystatus[buildkeys[BK_MODE2D_3D]]) // Enter
|
|
{
|
|
getmessageleng = 0;
|
|
getmessagetimeoff = 0;
|
|
#if defined(DUKEOSD)
|
|
m32_osdsetfunctions();
|
|
#endif
|
|
}
|
|
|
|
if (getmessageleng > 0)
|
|
{
|
|
if (qsetmode != 200)
|
|
printmessage16("%s", getmessage);
|
|
if (totalclock > getmessagetimeoff)
|
|
getmessageleng = 0;
|
|
}
|
|
|
|
}
|
|
#undef EDUKE32_EXEC
|
|
#undef EDUKE32_LOCALEXEC
|
|
|
|
void ExtCheckKeys(void)
|
|
{
|
|
static int32_t soundinit = 0;
|
|
static int32_t lastbstatus = 0;
|
|
|
|
if (!soundinit)
|
|
{
|
|
g_numsounds = 0;
|
|
|
|
if (g_skipDefaultCons == 0)
|
|
loadconsounds(defaultgameconfile()); // Bstrcpy(gamecon, defaultgameconfile());
|
|
else
|
|
loadconsounds(gamecon);
|
|
|
|
if (g_numsounds > 0)
|
|
{
|
|
if (S_SoundStartup() != 0)
|
|
S_SoundShutdown();
|
|
}
|
|
soundinit = 1;
|
|
}
|
|
|
|
if (qsetmode == 200 && shadepreview)
|
|
{
|
|
int32_t i = 0, ii;
|
|
int32_t w, isec, start_wall, end_wall;
|
|
|
|
for (i=0; i<highlightsectorcnt; i++)
|
|
{
|
|
ii = highlightsector[i];
|
|
sector[ii].floorpal = sectorpals[ii][0];
|
|
sector[ii].ceilingpal = sectorpals[ii][1];
|
|
}
|
|
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
{
|
|
if (sprite[i].statnum==MAXSTATUS || sprite[i].picnum != SECTOREFFECTOR)
|
|
continue;
|
|
|
|
if (sprite[i].lotag != 12 && sprite[i].lotag != 3 && sprite[i].lotag != 4)
|
|
continue;
|
|
|
|
isec = sprite[i].sectnum;
|
|
if (isec<0)
|
|
continue;
|
|
|
|
start_wall = sector[isec].wallptr;
|
|
end_wall = start_wall + sector[isec].wallnum;
|
|
|
|
for (w = start_wall; w < end_wall; w++)
|
|
{
|
|
if (wallflag[w>>3]&(1<<(w&7)))
|
|
{
|
|
wall[w].shade = wallshades[w];
|
|
wall[w].pal = wallpals[w];
|
|
wallflag[w>>3] &= ~(1<<(w&7));
|
|
}
|
|
// removed: same thing with nextwalls
|
|
}
|
|
sector[isec].floorshade = sectorshades[isec][0];
|
|
sector[isec].ceilingshade = sectorshades[isec][1];
|
|
sector[isec].floorpal = sectorpals[isec][0];
|
|
sector[isec].ceilingpal = sectorpals[isec][1];
|
|
|
|
for (w=headspritesect[isec]; w>=0; w=nextspritesect[w])
|
|
{
|
|
if (w == i)
|
|
continue;
|
|
sprite[w].shade = spriteshades[w];
|
|
sprite[w].pal = spritepals[w];
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
lastbstatus = bstatus;
|
|
readmousebstatus(&bstatus);
|
|
|
|
Keys2d3d();
|
|
|
|
if (qsetmode == 200) //In 3D mode
|
|
{
|
|
Keys3d();
|
|
editinput();
|
|
if (infobox&2)
|
|
m32_showmouse();
|
|
}
|
|
else
|
|
{
|
|
Keys2d();
|
|
|
|
if (autocorruptcheck>0 && totalclock > corruptchecktimer)
|
|
{
|
|
if (CheckMapCorruption(3, 0)>=3)
|
|
printmessage16("Corruption detected. See OSD for details.");
|
|
corruptchecktimer = totalclock + 120*autocorruptcheck;
|
|
}
|
|
}
|
|
|
|
if (asksave == 1)
|
|
asksave++;
|
|
else if (asksave == 2 && (bstatus + lastbstatus) == 0
|
|
#if M32_UNDO
|
|
&& mapstate
|
|
#endif
|
|
)
|
|
{
|
|
int32_t i;
|
|
// check keys so that e.g. bulk deletions won't produce
|
|
// as much revisions as deleted sprites
|
|
for (i=sizeof(keystatus)/sizeof(keystatus[0])-1; i>=0; i--)
|
|
if (keystatus[i])
|
|
break;
|
|
if (i==-1)
|
|
{
|
|
#if M32_UNDO
|
|
create_map_snapshot();
|
|
#else
|
|
CheckMapCorruption(5, 0);
|
|
#endif
|
|
asksave++;
|
|
}
|
|
}
|
|
else if (asksave == 3)
|
|
asksave++;
|
|
|
|
if (totalclock > autosavetimer && autosave)
|
|
{
|
|
if (asksave == 4)
|
|
{
|
|
if (CheckMapCorruption(5, 0)>=4)
|
|
{
|
|
SaveBoard("autosave_corrupt.map", 1);
|
|
message("Board autosaved to AUTOSAVE_CORRUPT.MAP");
|
|
}
|
|
else
|
|
{
|
|
SaveBoard("autosave.map", 0);
|
|
message("Board autosaved to AUTOSAVE.MAP");
|
|
}
|
|
|
|
asksave++;
|
|
}
|
|
autosavetimer = totalclock+120*autosave;
|
|
}
|
|
|
|
if (PRESSED_KEYSC(F12)) //F12
|
|
{
|
|
#ifdef ENGINE_SCREENSHOT_DEBUG
|
|
extern int32_t engine_screenshot;
|
|
engine_screenshot = 1;
|
|
#else
|
|
extern int16_t capturecount;
|
|
|
|
Bsprintf(tempbuf, "Mapster32 %s", ExtGetVer());
|
|
screencapture("captxxxx.tga", eitherSHIFT, tempbuf);
|
|
silentmessage("Saved screenshot %04d", capturecount-1);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
//// port of a.m32's corruptchk ////
|
|
// returns value from 0 (all OK) to 5 (panic!)
|
|
#define CCHK_PANIC OSDTEXT_DARKRED "PANIC!!!^O "
|
|
//#define CCHKPREF OSDTEXT_RED "^O"
|
|
#define CCHK_CORRECTED OSDTEXT_GREEN " -> "
|
|
|
|
#define CORRUPTCHK_PRINT(errlev, what, fmt, ...) do \
|
|
{ \
|
|
bad = max(bad, errlev); \
|
|
if (numcorruptthings>=MAXCORRUPTTHINGS) \
|
|
goto too_many_errors; \
|
|
corruptthings[numcorruptthings++] = (what); \
|
|
if (errlev >= printfromlev) \
|
|
OSD_Printf("#%d: " fmt "\n", numcorruptthings, ## __VA_ARGS__); \
|
|
} while (0)
|
|
|
|
#ifdef YAX_ENABLE
|
|
static int32_t walls_have_equal_endpoints(int32_t w1, int32_t w2)
|
|
{
|
|
int32_t n1 = wall[w1].point2, n2 = wall[w2].point2;
|
|
|
|
return (wall[w1].x==wall[w2].x && wall[w1].y==wall[w2].y &&
|
|
wall[n1].x==wall[n2].x && wall[n1].y==wall[n2].y);
|
|
}
|
|
|
|
static void correct_yax_nextwall(int32_t wallnum, int32_t bunchnum, int32_t cf, int32_t tryfixingp)
|
|
{
|
|
int32_t i, j, startwall, endwall;
|
|
int32_t nummatching=0, lastwall[2]={-1,-1};
|
|
|
|
for (SECTORS_OF_BUNCH(bunchnum, !cf, i))
|
|
for (WALLS_OF_SECTOR(i, j))
|
|
{
|
|
// v v v shouldn't happen, 'stupidity safety'
|
|
if (j!=wallnum && walls_have_equal_endpoints(wallnum, j))
|
|
{
|
|
lastwall[nummatching++] = j;
|
|
if (nummatching==2)
|
|
goto outofloop;
|
|
}
|
|
}
|
|
outofloop:
|
|
if (nummatching==1)
|
|
{
|
|
if (!tryfixingp)
|
|
{
|
|
OSD_Printf(" will set wall %d's %s to %d on tryfix\n",
|
|
wallnum, yupdownwall[cf], lastwall[0]);
|
|
}
|
|
else
|
|
{
|
|
int32_t setreverse = 0;
|
|
yax_setnextwall(wallnum, cf, lastwall[0]);
|
|
if (yax_getnextwall(lastwall[0], !cf) < 0)
|
|
{
|
|
setreverse = 1;
|
|
yax_setnextwall(lastwall[0], !cf, wallnum);
|
|
}
|
|
|
|
OSD_Printf("auto-correction: set wall %d's %s to %d%s\n",
|
|
wallnum, yupdownwall[cf], lastwall[0], setreverse?" and its reverse link":"");
|
|
}
|
|
}
|
|
else if (!tryfixingp)
|
|
{
|
|
if (nummatching > 1)
|
|
{
|
|
OSD_Printf(" found more than one matching wall: at least %d and %d\n",
|
|
lastwall[0], lastwall[1]);
|
|
}
|
|
else if (nummatching == 0)
|
|
{
|
|
OSD_Printf(" found no matching walls!\n");
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// in reverse orientation
|
|
static int32_t walls_are_consistent(int32_t w1, int32_t w2)
|
|
{
|
|
return (wall[w2].x==POINT2(w1).x && wall[w2].y==POINT2(w1).y &&
|
|
wall[w1].x==POINT2(w2).x && wall[w1].y==POINT2(w2).y);
|
|
}
|
|
|
|
static void suggest_nextsector_correction(int32_t nw, int32_t j)
|
|
{
|
|
// wall j's nextsector is inconsistent with its nextwall... what shall we do?
|
|
|
|
if (nw>=0 && nw<numwalls)
|
|
{
|
|
// maybe wall[j].nextwall's nextwall is right?
|
|
if (wall[nw].nextwall==j && walls_are_consistent(nw, j))
|
|
OSD_Printf(" suggest setting wall[%d].nextsector to %d\n",
|
|
j, sectorofwall_noquick(nw));
|
|
}
|
|
|
|
// alternative
|
|
if (wall[j].nextsector>=0 && wall[j].nextsector<numsectors)
|
|
{
|
|
int32_t w, startwall, endwall;
|
|
for (WALLS_OF_SECTOR(wall[j].nextsector, w))
|
|
{
|
|
// XXX: need clearing some others?
|
|
if (walls_are_consistent(w, j))
|
|
{
|
|
OSD_Printf(" ? suggest setting wall[%d].nextwall to %d\n",
|
|
j, w);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void do_nextsector_correction(int32_t nw, int32_t j)
|
|
{
|
|
if (!corrupt_tryfix_alt)
|
|
{
|
|
if (nw>=0 && nw<numwalls)
|
|
if (wall[nw].nextwall==j && walls_are_consistent(nw, j))
|
|
{
|
|
int32_t newns = sectorofwall_noquick(nw);
|
|
wall[j].nextsector = newns;
|
|
OSD_Printf(CCHK_CORRECTED "auto-correction: set wall[%d].nextsector=%d\n",
|
|
j, newns);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (wall[j].nextsector>=0 && wall[j].nextsector<numsectors)
|
|
{
|
|
int32_t w, startwall, endwall;
|
|
for (WALLS_OF_SECTOR(wall[j].nextsector, w))
|
|
if (walls_are_consistent(w, j))
|
|
{
|
|
wall[j].nextwall = w;
|
|
OSD_Printf(CCHK_CORRECTED "auto-correction: set wall[%d].nextwall=%d\n",
|
|
j, w);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static int32_t csc_s, csc_i;
|
|
// 1: corrupt, 0: OK
|
|
static int32_t check_spritelist_consistency()
|
|
{
|
|
int32_t s, i, ournumsprites=0;
|
|
static uint8_t havesprite[MAXSPRITES>>3];
|
|
|
|
csc_s = csc_i = -1;
|
|
|
|
if ((unsigned)Numsprites >= MAXSPRITES)
|
|
return 1;
|
|
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
{
|
|
csc_i = i;
|
|
|
|
if ((sprite[i].statnum==MAXSTATUS) != (sprite[i].sectnum==MAXSECTORS))
|
|
return 2; // violation of .statnum==MAXSTATUS iff .sectnum==MAXSECTORS
|
|
|
|
if ((unsigned)sprite[i].statnum > MAXSTATUS || (unsigned)sprite[i].sectnum > MAXSECTORS)
|
|
return 3; // oob sectnum or statnum
|
|
|
|
if (sprite[i].statnum != MAXSTATUS)
|
|
ournumsprites++;
|
|
}
|
|
|
|
if (ournumsprites != Numsprites)
|
|
return 4; // counting sprites by statnum!=MAXSTATUS inconsistent with Numsprites
|
|
|
|
// SECTOR LIST
|
|
|
|
Bmemset(havesprite, 0, (Numsprites+7)>>3);
|
|
|
|
for (s=0; s<numsectors; s++)
|
|
{
|
|
csc_s = s;
|
|
|
|
for (i=headspritesect[s]; i>=0; i=nextspritesect[i])
|
|
{
|
|
csc_i = i;
|
|
|
|
if (i >= MAXSPRITES)
|
|
return 5; // oob sprite index in list, or Numsprites inconsistent
|
|
|
|
if (havesprite[i>>3]&(1<<(i&7)))
|
|
return 6; // have a cycle in the list
|
|
|
|
havesprite[i>>3] |= (1<<(i&7));
|
|
|
|
if (sprite[i].sectnum != s)
|
|
return 7; // .sectnum inconsistent with list
|
|
}
|
|
|
|
if (i!=-1)
|
|
return 8; // various code checks for -1 to break loop
|
|
}
|
|
|
|
csc_s = -1;
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
{
|
|
csc_i = i;
|
|
|
|
if (sprite[i].statnum!=MAXSTATUS && !(havesprite[i>>3]&(1<<(i&7))))
|
|
return 9; // have a sprite in the world not in sector list
|
|
}
|
|
|
|
|
|
// STATUS LIST -- we now clear havesprite[] bits
|
|
|
|
for (s=0; s<MAXSTATUS; s++)
|
|
{
|
|
csc_s = s;
|
|
|
|
for (i=headspritestat[s]; i>=0; i=nextspritestat[i])
|
|
{
|
|
csc_i = i;
|
|
|
|
if (i >= MAXSPRITES)
|
|
return 10; // oob sprite index in list, or Numsprites inconsistent
|
|
|
|
// have a cycle in the list, or status list inconsistent with
|
|
// sector list (*)
|
|
if (!(havesprite[i>>3]&(1<<(i&7))))
|
|
return 11;
|
|
|
|
havesprite[i>>3] &= ~(1<<(i&7));
|
|
|
|
if (sprite[i].statnum != s)
|
|
return 12; // .statnum inconsistent with list
|
|
}
|
|
|
|
if (i!=-1)
|
|
return 13; // various code checks for -1 to break loop
|
|
}
|
|
|
|
csc_s = -1;
|
|
for (i=0; i<Numsprites; i++)
|
|
{
|
|
csc_i = i;
|
|
|
|
// Status list contains only a proper subset of the sprites in the
|
|
// sector list. Reverse case is handled by (*)
|
|
if (havesprite[i>>3]&(1<<(i&7)))
|
|
return 14;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int32_t CheckMapCorruption(int32_t printfromlev, uint64_t tryfixing)
|
|
{
|
|
int32_t i, j, w0, numw, endwall, ns, nw;
|
|
int32_t ewall=0; // expected wall index
|
|
|
|
int32_t errlevel=0, bad=0;
|
|
int32_t heinumcheckstat = 0; // 1, 2
|
|
|
|
uint8_t *seen_nextwalls = NULL;
|
|
int16_t *lastnextwallsource = NULL;
|
|
|
|
numcorruptthings = 0;
|
|
|
|
if (numsectors>MAXSECTORS)
|
|
CORRUPTCHK_PRINT(5, 0, CCHK_PANIC "SECTOR LIMIT EXCEEDED (MAXSECTORS=%d)!!!", MAXSECTORS);
|
|
|
|
if (numwalls>MAXWALLS)
|
|
CORRUPTCHK_PRINT(5, 0, CCHK_PANIC "WALL LIMIT EXCEEDED (MAXWALLS=%d)!!!", MAXWALLS);
|
|
|
|
if (numsectors>MAXSECTORS || numwalls>MAXWALLS)
|
|
{
|
|
corruptlevel = bad;
|
|
return bad;
|
|
}
|
|
|
|
if (numsectors==0 || numwalls==0)
|
|
{
|
|
if (numsectors>0)
|
|
CORRUPTCHK_PRINT(5, 0, CCHK_PANIC " Have sectors but no walls!");
|
|
if (numwalls>0)
|
|
CORRUPTCHK_PRINT(5, 0, CCHK_PANIC " Have walls but no sectors!");
|
|
return bad;
|
|
}
|
|
|
|
if (!corruptcheck_noalreadyrefd)
|
|
{
|
|
seen_nextwalls = Bcalloc((numwalls+7)>>3,1);
|
|
if (!seen_nextwalls) return 5;
|
|
lastnextwallsource = Bmalloc(numwalls*sizeof(lastnextwallsource[0]));
|
|
if (!lastnextwallsource) { Bfree(seen_nextwalls); return 5; }
|
|
}
|
|
|
|
for (i=0; i<numsectors; i++)
|
|
{
|
|
bad = 0;
|
|
|
|
w0 = sector[i].wallptr;
|
|
numw = sector[i].wallnum;
|
|
|
|
if (w0 < 0 || w0 > numwalls)
|
|
CORRUPTCHK_PRINT(4, CORRUPT_SECTOR|i, "SECTOR[%d].WALLPTR=%d out of range (numwalls=%d)", i, w0, numw);
|
|
|
|
if (w0 != ewall)
|
|
CORRUPTCHK_PRINT(4, CORRUPT_SECTOR|i, "SECTOR[%d].WALLPTR=%d inconsistent, expected %d", i, w0, ewall);
|
|
|
|
if (numw <= 1)
|
|
CORRUPTCHK_PRINT(5, CORRUPT_SECTOR|i, CCHK_PANIC "SECTOR[%d].WALLNUM=%d INVALID!!!", i, numw);
|
|
else if (numw==2)
|
|
CORRUPTCHK_PRINT(3, CORRUPT_SECTOR|i, "SECTOR[%d].WALLNUM=2, expected at least 3", i);
|
|
|
|
ewall += numw;
|
|
|
|
endwall = w0 + numw;
|
|
if (endwall > numwalls)
|
|
CORRUPTCHK_PRINT(4, CORRUPT_SECTOR|i, "SECTOR[%d]: wallptr+wallnum=%d out of range: numwalls=%d", i, endwall, numwalls);
|
|
|
|
// inconsistent cstat&2 and heinum checker
|
|
{
|
|
int32_t cs, hn;
|
|
const char *cflabel[2] = {"ceiling", "floor"};
|
|
|
|
for (j=0; j<2; j++)
|
|
{
|
|
cs = !!(SECTORFLD(i,stat, j)&2);
|
|
hn = (SECTORFLD(i,heinum, j)!=0);
|
|
|
|
if (cs != hn && heinumcheckstat <= 1)
|
|
{
|
|
if (numcorruptthings < MAXCORRUPTTHINGS &&
|
|
(heinumcheckstat==1 || (heinumcheckstat==0 && (tryfixing & (1ull<<numcorruptthings)))))
|
|
{
|
|
setslope(i, j, 0);
|
|
OSD_Printf(CCHK_CORRECTED "auto-correction: reset sector %d's %s slope\n",
|
|
i, cflabel[j]);
|
|
heinumcheckstat = 1;
|
|
}
|
|
else if (heinumcheckstat==0)
|
|
{
|
|
CORRUPTCHK_PRINT(1, CORRUPT_SECTOR|i,
|
|
"SECTOR[%d]: inconsistent %sstat&2 and heinum", i, cflabel[j]);
|
|
}
|
|
|
|
if (heinumcheckstat != 1)
|
|
heinumcheckstat = 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
errlevel = max(errlevel, bad);
|
|
|
|
if (bad<4)
|
|
{
|
|
endwall--;
|
|
|
|
for (j=w0; j<=endwall; j++)
|
|
{
|
|
bad = 0;
|
|
|
|
if (wall[j].point2 < w0 || wall[j].point2 > endwall)
|
|
{
|
|
if (wall[j].point2 < 0 || wall[j].point2 >= MAXWALLS)
|
|
CORRUPTCHK_PRINT(5, CORRUPT_WALL|j, CCHK_PANIC "WALL[%d].POINT2=%d INVALID!!!",
|
|
j, wall[j].point2);
|
|
else
|
|
CORRUPTCHK_PRINT(4, CORRUPT_WALL|j, "WALL[%d].POINT2=%d out of range [%d, %d]",
|
|
j, wall[j].point2, w0, endwall);
|
|
}
|
|
|
|
nw = wall[j].nextwall;
|
|
ns = wall[j].nextsector;
|
|
|
|
if (nw >= numwalls)
|
|
CORRUPTCHK_PRINT(4, CORRUPT_WALL|j, "WALL[%d].NEXTWALL=%d out of range: numwalls=%d",
|
|
j, nw, numwalls);
|
|
|
|
if (ns >= numsectors)
|
|
CORRUPTCHK_PRINT(4, CORRUPT_WALL|j, "WALL[%d].NEXTSECTOR=%d out of range: numsectors=%d",
|
|
j, ns, numsectors);
|
|
|
|
if (nw>=w0 && nw<=endwall)
|
|
CORRUPTCHK_PRINT(4, CORRUPT_WALL|j, "WALL[%d].NEXTWALL is its own sector's wall", j);
|
|
|
|
#ifdef YAX_ENABLE
|
|
{
|
|
int32_t cf, ynw, ynwp2;
|
|
|
|
for (cf=0; cf<2; cf++)
|
|
{
|
|
ynw = yax_getnextwall(j, cf);
|
|
if (ynw >= 0)
|
|
{
|
|
if (ynw >= numwalls)
|
|
CORRUPTCHK_PRINT(4, CORRUPT_WALL|j, "WALL %d's %s=%d out of range: numwalls=%d",
|
|
j, YUPDOWNWALL[cf], ynw, numwalls);
|
|
else
|
|
{
|
|
int32_t ynextwallok = 1;
|
|
|
|
if (j == ynw)
|
|
{
|
|
CORRUPTCHK_PRINT(4, CORRUPT_WALL|j, "WALL %d's %s is itself",
|
|
j, YUPDOWNWALL[cf]);
|
|
ynextwallok = 0;
|
|
}
|
|
else if (!walls_have_equal_endpoints(j, ynw))
|
|
{
|
|
CORRUPTCHK_PRINT(4, CORRUPT_WALL|j, "WALL %d's and its %s=%d's "
|
|
"endpoints are inconsistent", j, YUPDOWNWALL[cf], ynw);
|
|
ynextwallok = 0;
|
|
}
|
|
|
|
{
|
|
int16_t bunchnum = yax_getbunch(i, cf);
|
|
int32_t onumct = numcorruptthings;
|
|
|
|
if (bunchnum < 0 || bunchnum >= numyaxbunches)
|
|
{
|
|
if (tryfixing == 0ull)
|
|
{
|
|
CORRUPTCHK_PRINT(4, CORRUPT_WALL|j, "WALL %d has %s=%d, "
|
|
"but its %s bunchnum=%d is invalid",
|
|
j, YUPDOWNWALL[cf], ynw,
|
|
cf==YAX_CEILING? "ceiling":"floor", bunchnum);
|
|
OSD_Printf(" will clear wall %d's %s to -1 on tryfix\n",
|
|
j, yupdownwall[cf]);
|
|
|
|
}
|
|
else if (tryfixing & (1ull<<onumct))
|
|
{
|
|
yax_setnextwall(j, cf, -1);
|
|
OSD_Printf(CCHK_CORRECTED "auto-correction: cleared wall %d's %s to -1\n",
|
|
j, yupdownwall[cf]);
|
|
}
|
|
}
|
|
else if (!ynextwallok && onumct < MAXCORRUPTTHINGS)
|
|
{
|
|
if ((tryfixing & (1ull<<onumct)) || 4>=printfromlev)
|
|
correct_yax_nextwall(j, bunchnum, cf, tryfixing!=0ull);
|
|
}
|
|
}
|
|
|
|
if (ynextwallok)
|
|
{
|
|
int32_t onumct = numcorruptthings;
|
|
|
|
ynwp2 = yax_getnextwall(ynw, !cf);
|
|
if (ynwp2 != j)
|
|
{
|
|
CORRUPTCHK_PRINT(4, CORRUPT_WALL|j, "WALL %d's %s=%d's reverse link wrong"
|
|
" (expected %d, have %d)", j, YUPDOWNWALL[cf], ynw, j, ynwp2);
|
|
if (onumct < MAXCORRUPTTHINGS)
|
|
{
|
|
if (tryfixing & (1ull<<onumct))
|
|
{
|
|
yax_setnextwall(ynw, !cf, j);
|
|
OSD_Printf(CCHK_CORRECTED "auto-correction: set wall %d's %s=%d's %s to %d\n",
|
|
j, yupdownwall[cf], ynw, yupdownwall[!cf], j);
|
|
}
|
|
else if (4>=printfromlev)
|
|
{
|
|
OSD_Printf(" will set wall %d's %s=%d's %s to %d on tryfix\n",
|
|
j, yupdownwall[cf], ynw, yupdownwall[!cf], j);
|
|
}
|
|
}
|
|
}
|
|
} // woot!
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
if (ns == i)
|
|
{
|
|
if (!bad)
|
|
{
|
|
int32_t onumct = numcorruptthings;
|
|
int32_t safetoclear = (nw==j || (wall[nw].nextwall==-1 && wall[nw].nextsector==-1));
|
|
|
|
CORRUPTCHK_PRINT(4, CORRUPT_WALL|j, "WALL[%d].NEXTSECTOR is its own sector", j);
|
|
if (onumct < MAXCORRUPTTHINGS)
|
|
{
|
|
if (tryfixing & (1ull<<onumct))
|
|
{
|
|
if (safetoclear)
|
|
{
|
|
wall[j].nextwall = wall[j].nextsector = -1;
|
|
OSD_Printf(CCHK_CORRECTED "auto-correction: cleared wall %d's nextwall"
|
|
" and nextsector\n", j);
|
|
}
|
|
else
|
|
do_nextsector_correction(nw, j);
|
|
}
|
|
else if (4>=printfromlev)
|
|
{
|
|
if (safetoclear)
|
|
OSD_Printf(" will clear wall %d's nextwall and nextsector on tryfix\n", j);
|
|
else
|
|
suggest_nextsector_correction(nw, j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!corruptcheck_noalreadyrefd && nw>=0 && nw<numwalls)
|
|
{
|
|
if (seen_nextwalls[nw>>3]&(1<<(nw&7)))
|
|
{
|
|
int16_t nwnw, lnws;
|
|
int32_t onumct = numcorruptthings;
|
|
|
|
lnws = lastnextwallsource[nw];
|
|
CORRUPTCHK_PRINT(3, CORRUPT_WALL|j, "WALL[%d].NEXTWALL=%d already referenced from wall %d",
|
|
j, nw, lnws);
|
|
nwnw = wall[nw].nextwall;
|
|
if (onumct < MAXCORRUPTTHINGS && (nwnw==j || nwnw==lnws))
|
|
{
|
|
int32_t walltoclear = nwnw==j ? lnws : j;
|
|
if (tryfixing & (1ull<<onumct))
|
|
{
|
|
wall[walltoclear].nextsector = wall[walltoclear].nextwall = -1;
|
|
OSD_Printf(CCHK_CORRECTED "auto-correction: cleared wall %d's nextwall and nextsector tags to -1\n",
|
|
walltoclear);
|
|
}
|
|
else if (3 >= printfromlev)
|
|
OSD_Printf(" wall[%d].nextwall=%d, suggest clearing wall %d's nextwall and nextsector tags to -1\n",
|
|
nw, nwnw, walltoclear);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
seen_nextwalls[nw>>3] |= 1<<(nw&7);
|
|
lastnextwallsource[nw] = j;
|
|
}
|
|
}
|
|
|
|
if (bad<4)
|
|
{
|
|
int32_t onumct = numcorruptthings;
|
|
if ((ns^nw)<0)
|
|
{
|
|
CORRUPTCHK_PRINT(4, CORRUPT_WALL|j, "WALL[%d].NEXTSECTOR=%d and .NEXTWALL=%d inconsistent:"
|
|
" missing one next pointer", j, ns, nw);
|
|
if (onumct < MAXCORRUPTTHINGS)
|
|
{
|
|
if (tryfixing & (1ull<<onumct))
|
|
do_nextsector_correction(nw, j);
|
|
else if (4>=printfromlev)
|
|
suggest_nextsector_correction(nw, j);
|
|
}
|
|
}
|
|
else if (ns>=0)
|
|
{
|
|
if (nw<sector[ns].wallptr || nw>=sector[ns].wallptr+sector[ns].wallnum)
|
|
{
|
|
CORRUPTCHK_PRINT(4, CORRUPT_WALL|j, "WALL[%d].NEXTWALL=%d out of .NEXTSECTOR=%d's bounds [%d .. %d]",
|
|
j, nw, ns, sector[ns].wallptr, sector[ns].wallptr+sector[ns].wallnum-1);
|
|
if (onumct < MAXCORRUPTTHINGS)
|
|
{
|
|
if (tryfixing & (1ull<<onumct))
|
|
do_nextsector_correction(nw, j);
|
|
else if (4 >= printfromlev)
|
|
suggest_nextsector_correction(nw, j);
|
|
}
|
|
}
|
|
#if 0
|
|
// this one usually appears together with the "already referenced" corruption
|
|
else if (wall[nw].nextsector != i || wall[nw].nextwall != j)
|
|
{
|
|
CORRUPTCHK_PRINT(4, CORRUPT_WALL|nw, "WALL %d nextwall's backreferences inconsistent. Expected nw=%d, ns=%d; got nw=%d, ns=%d",
|
|
nw, i, j, wall[nw].nextsector, wall[nw].nextwall);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
errlevel = max(errlevel, bad);
|
|
}
|
|
}
|
|
}
|
|
|
|
bad = 0;
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
{
|
|
if (sprite[i].statnum==MAXSTATUS)
|
|
continue;
|
|
|
|
if (sprite[i].sectnum<0 || sprite[i].sectnum>=numsectors)
|
|
CORRUPTCHK_PRINT(4, CORRUPT_SPRITE|i, "SPRITE[%d].SECTNUM=%d. Expect problems!", i, sprite[i].sectnum);
|
|
|
|
if (sprite[i].statnum<0 || sprite[i].statnum>MAXSTATUS)
|
|
CORRUPTCHK_PRINT(4, CORRUPT_SPRITE|i, "SPRITE[%d].STATNUM=%d. Expect problems!", i, sprite[i].statnum);
|
|
|
|
if (sprite[i].picnum<0 || sprite[i].picnum>=MAXTILES)
|
|
{
|
|
sprite[i].picnum = 0;
|
|
CORRUPTCHK_PRINT(0, CORRUPT_SPRITE|i, "SPRITE[%d].PICNUM=%d out of range, resetting to 0", i, sprite[i].picnum);
|
|
}
|
|
}
|
|
|
|
i = check_spritelist_consistency();
|
|
if (i)
|
|
CORRUPTCHK_PRINT(5, i<0?0:(CORRUPT_SPRITE|i), CCHK_PANIC "SPRITE LISTS CORRUPTED: error code %d, s=%d, i=%d!",
|
|
i, csc_s, csc_i);
|
|
|
|
if (0)
|
|
{
|
|
too_many_errors:
|
|
if (printfromlev<=errlevel)
|
|
OSD_Printf("!! too many errors, stopping. !!\n");
|
|
}
|
|
|
|
errlevel = max(errlevel, bad);
|
|
|
|
if (errlevel)
|
|
{
|
|
if (printfromlev<=errlevel)
|
|
OSD_Printf("-- corruption level: %d\n", errlevel);
|
|
if (tryfixing)
|
|
OSD_Printf("--\n");
|
|
}
|
|
|
|
if (seen_nextwalls)
|
|
{
|
|
Bfree(seen_nextwalls);
|
|
Bfree(lastnextwallsource);
|
|
}
|
|
|
|
corruptlevel = errlevel;
|
|
|
|
return errlevel;
|
|
}
|
|
////
|
|
|
|
void faketimerhandler(void)
|
|
{
|
|
sampletimer();
|
|
}
|
|
|
|
void SetBOSS1Palette(void)
|
|
{
|
|
if (acurpalette==3) return;
|
|
acurpalette=3;
|
|
setbrightness(GAMMA_CALC,5,2);
|
|
}
|
|
|
|
void SetSLIMEPalette(void)
|
|
{
|
|
if (acurpalette==2) return;
|
|
acurpalette=2;
|
|
setbrightness(GAMMA_CALC,2,2);
|
|
}
|
|
|
|
void SetWATERPalette(void)
|
|
{
|
|
if (acurpalette==1) return;
|
|
acurpalette=1;
|
|
setbrightness(GAMMA_CALC,1,2);
|
|
}
|
|
|
|
void SetGAMEPalette(void)
|
|
{
|
|
if (acurpalette==0) return;
|
|
acurpalette=0;
|
|
setbrightness(GAMMA_CALC,0,2);
|
|
}
|
|
|
|
static void SearchSectors(int32_t dir) // <0: backwards, >=0: forwards
|
|
{
|
|
int32_t ii=0;
|
|
dir = 1-2*(dir<0);
|
|
|
|
if (cursector_lotag!=0)
|
|
{
|
|
if ((dir>0 && cursectornum<MAXSECTORS) || (dir<0 && cursectornum>=0))
|
|
cursectornum += dir;
|
|
|
|
for (ii=cursectornum; ii>=0 && ii<numsectors; ii+=dir)
|
|
{
|
|
if (sector[ii].lotag==cursector_lotag)
|
|
{
|
|
pos.x = wall[sector[ii].wallptr].x;
|
|
pos.y = wall[sector[ii].wallptr].y;
|
|
printmessage16("%s Sector search: found", dir<0?"<":">");
|
|
cursectornum = ii;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
printmessage16("%s Sector search: none found", dir<0?"<":">");
|
|
}
|
|
|
|
|
|
//////////////////// manual editing ////////////////////
|
|
// Build edit originally by Ed Coolidge <semicharm@earthlink.net>
|
|
|
|
static char med_disptext[80];
|
|
static char med_edittext[80];
|
|
static const char *med_typename="";
|
|
static int32_t med_dispwidth=24;
|
|
static int32_t med_editval=0;
|
|
static int32_t med_thenum=-1;
|
|
|
|
static void handlemed(int32_t dohex, const char *disp_membername, const char *edit_membername,
|
|
void *themember, int32_t thesizeof, int32_t themax, int32_t sign)
|
|
{
|
|
int32_t i, val;
|
|
int32_t flags = sign;
|
|
sign &= 1;
|
|
|
|
if (thesizeof==sizeof(int8_t))
|
|
{
|
|
if (sign)
|
|
val = *(int8_t *)themember;
|
|
else
|
|
val = *(uint8_t *)themember;
|
|
}
|
|
else if (thesizeof==sizeof(int16_t))
|
|
val = *(int16_t *)themember;
|
|
else //if (thesizeof==sizeof(int32_t))
|
|
val = *(int32_t *)themember;
|
|
|
|
if (dohex)
|
|
i=Bsprintf(med_disptext,"%s: %x", disp_membername, val);
|
|
else
|
|
i=Bsprintf(med_disptext,"%s: %d", disp_membername, val);
|
|
|
|
for (; i<med_dispwidth; i++)
|
|
med_disptext[i] = ' ';
|
|
|
|
Bsprintf(med_edittext,"%s %d %s: ", med_typename, med_thenum, edit_membername);
|
|
if (med_editval)
|
|
{
|
|
printmessage16("%s", med_edittext);
|
|
val = getnumber16(med_edittext, val, themax, flags);
|
|
|
|
if (thesizeof==sizeof(int8_t))
|
|
{
|
|
if (sign)
|
|
*(int8_t *)themember = (int8_t)val;
|
|
else
|
|
*(uint8_t *)themember = (uint8_t)val;
|
|
}
|
|
else if (thesizeof==sizeof(int16_t))
|
|
*(int16_t *)themember = (int16_t)val;
|
|
else //if (thesizeof==sizeof(int32_t))
|
|
*(int32_t *)themember = val;
|
|
}
|
|
}
|
|
|
|
static void med_printcurline(int32_t xpos, int32_t ypos, int32_t row, int32_t selected)
|
|
{
|
|
printext16(xpos,ypos+row*8,editorcolors[11],editorcolors[!!selected],med_disptext,0);
|
|
}
|
|
|
|
static void med_handlecommon(int32_t xpos, int32_t ypos, int32_t *row, int32_t rowmax)
|
|
{
|
|
idle_waitevent();
|
|
if (handleevents())
|
|
quitevent = 0;
|
|
|
|
_printmessage16("Edit mode, press <Esc> to exit");
|
|
|
|
if (PRESSED_KEYSC(DOWN))
|
|
{
|
|
if (*row < rowmax)
|
|
{
|
|
med_printcurline(xpos, ypos, *row, 0);
|
|
(*row)++;
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(UP))
|
|
{
|
|
if (*row > 0)
|
|
{
|
|
med_printcurline(xpos, ypos, *row, 0);
|
|
(*row)--;
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(ENTER))
|
|
med_editval = 1;
|
|
}
|
|
|
|
static void EditSectorData(int16_t sectnum)
|
|
{
|
|
int32_t col=1, row=0, rowmax = 6, i = -1;
|
|
int32_t xpos = 208, ypos = ydim-STATUS2DSIZ+48;
|
|
|
|
med_editval = 0;
|
|
|
|
med_dispwidth = 24;
|
|
med_disptext[med_dispwidth] = 0;
|
|
|
|
med_typename = "Sector";
|
|
med_thenum = sectnum;
|
|
|
|
drawgradient();
|
|
|
|
showsectordata(sectnum, 0);
|
|
|
|
while (keystatus[KEYSC_ESC] == 0)
|
|
{
|
|
med_handlecommon(xpos, ypos, &row, rowmax);
|
|
|
|
if (PRESSED_KEYSC(LEFT))
|
|
{
|
|
if (col == 2)
|
|
{
|
|
med_printcurline(xpos, ypos, row, 0);
|
|
col = 1;
|
|
xpos = 208;
|
|
med_disptext[med_dispwidth] = 0;
|
|
if (row > rowmax) row = rowmax;
|
|
}
|
|
}
|
|
if (PRESSED_KEYSC(RIGHT))
|
|
{
|
|
if (col == 1)
|
|
{
|
|
med_printcurline(xpos, ypos, row, 0);
|
|
col = 2;
|
|
xpos = 408;
|
|
med_disptext[med_dispwidth] = 0;
|
|
if (row > rowmax) row = rowmax;
|
|
}
|
|
}
|
|
|
|
#ifdef YAX_ENABLE
|
|
if (med_editval)
|
|
{
|
|
if ((row==1 || row==3 || row==5) && yax_getbunch(sectnum, (col==2)) >= 0)
|
|
med_editval = 0;
|
|
}
|
|
#endif
|
|
|
|
if (col == 1)
|
|
{
|
|
switch (row)
|
|
{
|
|
case 0:
|
|
#ifdef YAX_ENABLE
|
|
i = sector[sectnum].ceilingstat&YAX_BIT;
|
|
#endif
|
|
handlemed(1, "Flags (hex)", "Ceiling Flags", §or[sectnum].ceilingstat,
|
|
sizeof(sector[sectnum].ceilingstat), 65535, 0);
|
|
#ifdef YAX_ENABLE
|
|
sector[sectnum].ceilingstat &= ~YAX_BIT;
|
|
sector[sectnum].ceilingstat |= i;
|
|
#endif
|
|
break;
|
|
case 1:
|
|
for (i=Bsprintf(med_disptext,"(X,Y)pan: %d, %d",sector[sectnum].ceilingxpanning,sector[sectnum].ceilingypanning); i < med_dispwidth; i++) med_disptext[i] = ' ';
|
|
if (med_editval)
|
|
{
|
|
Bsprintf(med_edittext,"Sector %d Ceiling X Pan: ",sectnum);
|
|
printmessage16("%s", med_edittext);
|
|
sector[sectnum].ceilingxpanning = (char)getnumber16(med_edittext,(int32_t)sector[sectnum].ceilingxpanning,255,0);
|
|
Bsprintf(med_edittext,"Sector %d Ceiling Y Pan: ",sectnum);
|
|
printmessage16("%s", med_edittext);
|
|
sector[sectnum].ceilingypanning = (char)getnumber16(med_edittext,(int32_t)sector[sectnum].ceilingypanning,255,0);
|
|
}
|
|
break;
|
|
case 2:
|
|
handlemed(0, "Shade byte", "Ceiling Shade", §or[sectnum].ceilingshade,sizeof(sector[sectnum].ceilingshade), 128, 1);
|
|
break;
|
|
case 3:
|
|
handlemed(0, "Z-coordinate", "Ceiling Z-coordinate", §or[sectnum].ceilingz,
|
|
sizeof(sector[sectnum].ceilingz), BZ_MAX, 1);
|
|
break;
|
|
case 4:
|
|
handlemed(0, "Tile number", "Ceiling Tile Number", §or[sectnum].ceilingpicnum,
|
|
sizeof(sector[sectnum].ceilingpicnum), MAXTILES, 0);
|
|
break;
|
|
case 5:
|
|
handlemed(0, "Ceiling heinum", "Ceiling Heinum", §or[sectnum].ceilingheinum,
|
|
sizeof(sector[sectnum].ceilingheinum), BHEINUM_MAX, 1);
|
|
setslope(sectnum, YAX_CEILING, sector[sectnum].ceilingheinum);
|
|
break;
|
|
case 6:
|
|
handlemed(0, "Palookup number", "Ceiling Palookup Number", §or[sectnum].ceilingpal,
|
|
sizeof(sector[sectnum].ceilingpal), M32_MAXPALOOKUPS, 0);
|
|
break;
|
|
}
|
|
}
|
|
else if (col == 2)
|
|
{
|
|
switch (row)
|
|
{
|
|
case 0:
|
|
#ifdef YAX_ENABLE
|
|
i = sector[sectnum].ceilingstat&YAX_BIT;
|
|
#endif
|
|
handlemed(1, "Flags (hex)", "Floor Flags", §or[sectnum].floorstat,
|
|
sizeof(sector[sectnum].floorstat), 65535, 0);
|
|
#ifdef YAX_ENABLE
|
|
sector[sectnum].ceilingstat &= ~YAX_BIT;
|
|
sector[sectnum].ceilingstat |= i;
|
|
#endif
|
|
break;
|
|
|
|
case 1:
|
|
for (i=Bsprintf(med_disptext,"(X,Y)pan: %d, %d",sector[sectnum].floorxpanning,sector[sectnum].floorypanning); i < med_dispwidth; i++) med_disptext[i] = ' ';
|
|
if (med_editval)
|
|
{
|
|
Bsprintf(med_edittext,"Sector %d Floor X Pan: ",sectnum);
|
|
printmessage16("%s", med_edittext);
|
|
sector[sectnum].floorxpanning = (char)getnumber16(med_edittext,(int32_t)sector[sectnum].floorxpanning,255,0);
|
|
Bsprintf(med_edittext,"Sector %d Floor Y Pan: ",sectnum);
|
|
printmessage16("%s", med_edittext);
|
|
sector[sectnum].floorypanning = (char)getnumber16(med_edittext,(int32_t)sector[sectnum].floorypanning,255,0);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
handlemed(0, "Shade byte", "Floor Shade", §or[sectnum].floorshade,
|
|
sizeof(sector[sectnum].floorshade), 128, 1);
|
|
break;
|
|
case 3:
|
|
handlemed(0, "Z-coordinate", "Floor Z-coordinate", §or[sectnum].floorz,
|
|
sizeof(sector[sectnum].floorz), BZ_MAX, 1); //2147483647L,-2147483648L
|
|
break;
|
|
case 4:
|
|
handlemed(0, "Tile number", "Floor Tile Number", §or[sectnum].floorpicnum,
|
|
sizeof(sector[sectnum].floorpicnum), MAXTILES, 0);
|
|
break;
|
|
case 5:
|
|
handlemed(0, "Floor heinum", "Floor Heinum", §or[sectnum].floorheinum,
|
|
sizeof(sector[sectnum].floorheinum), BHEINUM_MAX, 1);
|
|
setslope(sectnum, YAX_FLOOR, sector[sectnum].floorheinum);
|
|
break;
|
|
case 6:
|
|
handlemed(0, "Palookup number", "Floor Palookup Number", §or[sectnum].floorpal,
|
|
sizeof(sector[sectnum].floorpal), M32_MAXPALOOKUPS, 0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
med_printcurline(xpos, ypos, row, 1);
|
|
if (med_editval)
|
|
med_editval = 0;
|
|
|
|
showframe(1);
|
|
}
|
|
|
|
med_printcurline(xpos, ypos, row, 0);
|
|
// printmessage16("");
|
|
|
|
showframe(1);
|
|
keystatus[KEYSC_ESC] = 0;
|
|
}
|
|
|
|
static void EditWallData(int16_t wallnum)
|
|
{
|
|
int32_t row=0, i = -1;
|
|
int32_t xpos = 208, ypos = ydim-STATUS2DSIZ+48;
|
|
|
|
med_editval = 0;
|
|
|
|
med_dispwidth = 24;
|
|
med_disptext[med_dispwidth] = 0;
|
|
|
|
med_typename = "Wall";
|
|
med_thenum = wallnum;
|
|
|
|
drawgradient();
|
|
|
|
showwalldata(wallnum, 0);
|
|
|
|
while (keystatus[KEYSC_ESC] == 0)
|
|
{
|
|
med_handlecommon(xpos, ypos, &row, 6);
|
|
|
|
switch (row)
|
|
{
|
|
case 0:
|
|
i = wall[wallnum].cstat&YAX_NEXTWALLBITS;
|
|
handlemed(1, "Flags (hex)", "Flags", &wall[wallnum].cstat,
|
|
sizeof(wall[wallnum].cstat), 65535, 0);
|
|
wall[wallnum].cstat &= ~YAX_NEXTWALLBITS;
|
|
wall[wallnum].cstat |= i;
|
|
break;
|
|
case 1:
|
|
handlemed(0, "Shade", "Shade", &wall[wallnum].shade,
|
|
sizeof(wall[wallnum].shade), 128, 1);
|
|
break;
|
|
case 2:
|
|
handlemed(0, "Pal", "Pal", &wall[wallnum].pal,
|
|
sizeof(wall[wallnum].pal), M32_MAXPALOOKUPS, 0);
|
|
break;
|
|
case 3:
|
|
for (i=Bsprintf(med_disptext,"(X,Y)repeat: %d, %d",wall[wallnum].xrepeat,wall[wallnum].yrepeat); i < med_dispwidth; i++) med_disptext[i] = ' ';
|
|
if (med_editval)
|
|
{
|
|
Bsprintf(med_edittext,"Wall %d X Repeat: ",wallnum);
|
|
printmessage16("%s", med_edittext);
|
|
wall[wallnum].xrepeat = (char)getnumber16(med_edittext,(int32_t)wall[wallnum].xrepeat,255,0);
|
|
Bsprintf(med_edittext,"Wall %d Y Repeat: ",wallnum);
|
|
printmessage16("%s", med_edittext);
|
|
wall[wallnum].yrepeat = (char)getnumber16(med_edittext,(int32_t)wall[wallnum].yrepeat,255,0);
|
|
}
|
|
break;
|
|
case 4:
|
|
for (i=Bsprintf(med_disptext,"(X,Y)pan: %d, %d",wall[wallnum].xpanning,wall[wallnum].ypanning); i < med_dispwidth; i++) med_disptext[i] = ' ';
|
|
if (med_editval)
|
|
{
|
|
Bsprintf(med_edittext,"Wall %d X Pan: ",wallnum);
|
|
printmessage16("%s", med_edittext);
|
|
wall[wallnum].xpanning = (char)getnumber16(med_edittext,(int32_t)wall[wallnum].xpanning,255,0);
|
|
Bsprintf(med_edittext,"Wall %d Y Pan: ",wallnum);
|
|
printmessage16("%s", med_edittext);
|
|
wall[wallnum].ypanning = (char)getnumber16(med_edittext,(int32_t)wall[wallnum].ypanning,255,0);
|
|
}
|
|
break;
|
|
case 5:
|
|
handlemed(0, "Tile number", "Tile number", &wall[wallnum].picnum,
|
|
sizeof(wall[wallnum].picnum), MAXTILES, 0);
|
|
break;
|
|
|
|
case 6:
|
|
handlemed(0, "OverTile number", "OverTile number", &wall[wallnum].overpicnum,
|
|
sizeof(wall[wallnum].overpicnum), MAXTILES, 0);
|
|
break;
|
|
}
|
|
|
|
med_printcurline(xpos, ypos, row, 1);
|
|
if (med_editval)
|
|
{
|
|
med_editval = 0;
|
|
//showwalldata(wallnum, 0);
|
|
//// printmessage16("");
|
|
}
|
|
|
|
showframe(1);
|
|
}
|
|
|
|
med_printcurline(xpos, ypos, row, 0);
|
|
// printmessage16("");
|
|
|
|
showframe(1);
|
|
keystatus[KEYSC_ESC] = 0;
|
|
}
|
|
|
|
static void EditSpriteData(int16_t spritenum)
|
|
{
|
|
int32_t col=0, row=0, rowmax=4, i = -1;
|
|
int32_t xpos = 8, ypos = ydim-STATUS2DSIZ+48;
|
|
|
|
med_editval = 0;
|
|
|
|
med_dispwidth = 24;
|
|
med_disptext[med_dispwidth] = 0;
|
|
|
|
med_typename = "Sprite";
|
|
med_thenum = spritenum;
|
|
|
|
drawgradient();
|
|
|
|
// clearmidstatbar16();
|
|
|
|
while (keystatus[KEYSC_ESC] == 0)
|
|
{
|
|
showspritedata(spritenum, 0);
|
|
|
|
med_handlecommon(xpos, ypos, &row, rowmax);
|
|
|
|
if (PRESSED_KEYSC(LEFT))
|
|
{
|
|
switch (col)
|
|
{
|
|
case 1:
|
|
{
|
|
med_printcurline(xpos, ypos, row, 0);
|
|
col = 0;
|
|
xpos = 8;
|
|
rowmax = 4;
|
|
med_dispwidth = 23;
|
|
med_disptext[med_dispwidth] = 0;
|
|
if (row > rowmax) row = rowmax;
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
med_printcurline(xpos, ypos, row, 0);
|
|
col = 1;
|
|
xpos = 208;
|
|
rowmax = 5;
|
|
med_dispwidth = 24;
|
|
med_disptext[med_dispwidth] = 0;
|
|
if (row > rowmax) row = rowmax;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (PRESSED_KEYSC(RIGHT))
|
|
{
|
|
switch (col)
|
|
{
|
|
case 0:
|
|
{
|
|
med_printcurline(xpos, ypos, row, 0);
|
|
col = 1;
|
|
xpos = 208;
|
|
rowmax = 5;
|
|
med_dispwidth = 24;
|
|
med_disptext[med_dispwidth] = 0;
|
|
if (row > rowmax) row = rowmax;
|
|
}
|
|
break;
|
|
case 1:
|
|
{
|
|
med_printcurline(xpos, ypos, row, 0);
|
|
col = 2;
|
|
xpos = 408;
|
|
rowmax = 6;
|
|
med_dispwidth = 26;
|
|
med_disptext[med_dispwidth] = 0;
|
|
if (row > rowmax) row = rowmax;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch (col)
|
|
{
|
|
case 0:
|
|
{
|
|
switch (row)
|
|
{
|
|
case 0:
|
|
handlemed(0, "X-coordinate", "X-coordinate", &sprite[spritenum].x,
|
|
sizeof(sprite[spritenum].x), 131072, 1);
|
|
break;
|
|
case 1:
|
|
handlemed(0, "Y-coordinate", "Y-coordinate", &sprite[spritenum].y,
|
|
sizeof(sprite[spritenum].y), 131072, 1);
|
|
break;
|
|
case 2:
|
|
handlemed(0, "Z-coordinate", "Z-coordinate", &sprite[spritenum].z,
|
|
sizeof(sprite[spritenum].z), BZ_MAX, 1); //2147483647L,-2147483648L
|
|
break;
|
|
case 3:
|
|
i = sprite[spritenum].sectnum;
|
|
handlemed(0, "Sectnum", "Sectnum", &sprite[spritenum].sectnum,
|
|
sizeof(sprite[spritenum].sectnum), numsectors-1, 0);
|
|
if (i != sprite[spritenum].sectnum)
|
|
{
|
|
swapshort(&i, &sprite[spritenum].sectnum);
|
|
changespritesect(spritenum,i);
|
|
}
|
|
break;
|
|
case 4:
|
|
i = sprite[spritenum].statnum;
|
|
handlemed(0, "Statnum", "Statnum", &sprite[spritenum].statnum,
|
|
sizeof(sprite[spritenum].statnum), MAXSTATUS-1, 0);
|
|
if (i != sprite[spritenum].statnum)
|
|
{
|
|
swapshort(&i, &sprite[spritenum].statnum);
|
|
changespritestat(spritenum,i);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 1:
|
|
{
|
|
switch (row)
|
|
{
|
|
case 0:
|
|
handlemed(1, "Flags (hex)", "Flags", &sprite[spritenum].cstat,
|
|
sizeof(sprite[spritenum].cstat), 65535, 0);
|
|
break;
|
|
case 1:
|
|
handlemed(0, "Shade", "Shade", &sprite[spritenum].shade,
|
|
sizeof(sprite[spritenum].shade), 128, 1);
|
|
break;
|
|
case 2:
|
|
handlemed(0, "Pal", "Pal", &sprite[spritenum].pal,
|
|
sizeof(sprite[spritenum].pal), M32_MAXPALOOKUPS, 0);
|
|
break;
|
|
case 3:
|
|
{
|
|
for (i=Bsprintf(med_disptext,"(X,Y)repeat: %d, %d",sprite[spritenum].xrepeat,sprite[spritenum].yrepeat); i < med_dispwidth; i++) med_disptext[i] = ' ';
|
|
if (med_editval)
|
|
{
|
|
Bsprintf(med_edittext,"Sprite %d X Repeat: ",spritenum);
|
|
printmessage16("%s", med_edittext);
|
|
sprite[spritenum].xrepeat = (char)getnumber16(med_edittext,(int32_t)sprite[spritenum].xrepeat,255,0);
|
|
Bsprintf(med_edittext,"Sprite %d Y Repeat: ",spritenum);
|
|
printmessage16("%s", med_edittext);
|
|
sprite[spritenum].yrepeat = (char)getnumber16(med_edittext,(int32_t)sprite[spritenum].yrepeat,255,0);
|
|
}
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
for (i=Bsprintf(med_disptext,"(X,Y)offset: %d, %d",sprite[spritenum].xoffset,sprite[spritenum].yoffset); i < med_dispwidth; i++) med_disptext[i] = ' ';
|
|
if (med_editval)
|
|
{
|
|
Bsprintf(med_edittext,"Sprite %d X Offset: ",spritenum);
|
|
printmessage16("%s", med_edittext);
|
|
sprite[spritenum].xoffset = (char)getnumber16(med_edittext,(int32_t)sprite[spritenum].xoffset,128,1);
|
|
Bsprintf(med_edittext,"Sprite %d Y Offset: ",spritenum);
|
|
printmessage16("%s", med_edittext);
|
|
sprite[spritenum].yoffset = (char)getnumber16(med_edittext,(int32_t)sprite[spritenum].yoffset,128,1);
|
|
}
|
|
}
|
|
break;
|
|
case 5:
|
|
handlemed(0, "Tile number", "Tile number", &sprite[spritenum].picnum,
|
|
sizeof(sprite[spritenum].picnum), MAXTILES-1, 0+2);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
switch (row)
|
|
{
|
|
case 0:
|
|
handlemed(0, "Angle (2048 degrees)", "Angle", &sprite[spritenum].ang,
|
|
sizeof(sprite[spritenum].ang), 2048, 1);
|
|
if (med_editval)
|
|
sprite[spritenum].ang &= 2047;
|
|
break;
|
|
case 1:
|
|
handlemed(0, "X-Velocity", "X-Velocity", &sprite[spritenum].xvel,
|
|
sizeof(sprite[spritenum].xvel), 65535, 1);
|
|
break;
|
|
case 2:
|
|
handlemed(0, "Y-Velocity", "Y-Velocity", &sprite[spritenum].yvel,
|
|
sizeof(sprite[spritenum].yvel), 65535, 1);
|
|
break;
|
|
case 3:
|
|
handlemed(0, "Z-Velocity", "Z-Velocity", &sprite[spritenum].zvel,
|
|
sizeof(sprite[spritenum].zvel), 65535, 1);
|
|
break;
|
|
case 4:
|
|
handlemed(0, "Owner", "Owner", &sprite[spritenum].owner,
|
|
sizeof(sprite[spritenum].owner), MAXSPRITES-1, 1);
|
|
break;
|
|
case 5:
|
|
handlemed(0, "Clipdist", "Clipdist", &sprite[spritenum].clipdist,
|
|
sizeof(sprite[spritenum].clipdist), 255, 0);
|
|
break;
|
|
case 6:
|
|
handlemed(0, "Extra", "Extra", &sprite[spritenum].extra,
|
|
sizeof(sprite[spritenum].extra), BTAG_MAX, 1);
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
med_printcurline(xpos, ypos, row, 1);
|
|
if (med_editval)
|
|
med_editval = 0;
|
|
|
|
showframe(1);
|
|
}
|
|
|
|
med_printcurline(xpos, ypos, row, 0);
|
|
// printmessage16("");
|
|
showframe(1);
|
|
|
|
keystatus[KEYSC_ESC] = 0;
|
|
}
|
|
|
|
#define TWENTYFIVE_BLANKS " "
|
|
|
|
static void GenericSpriteSearch(void)
|
|
{
|
|
char disptext[80];
|
|
char edittext[80];
|
|
static int32_t col=0, row=0;
|
|
int32_t i, j, k;
|
|
int32_t rowmax[3]= {6,5,6}, dispwidth[3] = {24,24,28};
|
|
int32_t xpos[3] = {8,200,400}, ypos = ydim-STATUS2DSIZ+48;
|
|
|
|
static const char *labels[7][3] =
|
|
{
|
|
{"X-coordinate", "Flags (hex)", "Angle (2048 degrees)"},
|
|
{"Y-coordinate", "Shade", "X-Velocity"},
|
|
{"Z-coordinate", "Pal", "Y-Velocity"},
|
|
{"Sectnum", "(X/Y)repeat", "Z-Velocity"},
|
|
{"Statnum", "(X/Y)offset", "Owner"},
|
|
{"Hitag", "Tile number", "Clipdist"},
|
|
{"Lotag", "", "Extra"}
|
|
};
|
|
|
|
static int32_t maxval[7][3] =
|
|
{
|
|
{ BXY_MAX , 65535 , 2048 },
|
|
{ BXY_MAX , 128 , 65535 },
|
|
{ BZ_MAX , M32_MAXPALOOKUPS, 65535 },
|
|
{ MAXSECTORS-1, 128 , 65535 },
|
|
{ MAXSTATUS-1 , 128 , MAXSPRITES-1 },
|
|
{ BTAG_MAX , MAXTILES-1 , 256 },
|
|
{ BTAG_MAX , 0 , BTAG_MAX }
|
|
};
|
|
|
|
static char sign[7][3] =
|
|
{
|
|
{1, 0, 1},
|
|
{1, 1, 1},
|
|
{1, 0, 1},
|
|
{0, 0, 1},
|
|
{0, 1, 0},
|
|
{0+4, 0+2, 0},
|
|
{0+4, 0, 1}
|
|
};
|
|
|
|
clearmidstatbar16();
|
|
|
|
drawgradient();
|
|
|
|
printext16(xpos[0], ypos-2*8, editorcolors[10], editorcolors[0], "Sprite search", 0);
|
|
|
|
for (i=0; i<3; i++)
|
|
for (j=0; j<=rowmax[i]; j++)
|
|
{
|
|
if (gs_spriteTagInterested[i][j])
|
|
k=Bsprintf(disptext, "%s: %d", labels[j][i], gs_spriteTagValue[i][j]);
|
|
else
|
|
k=Bsprintf(disptext, "%s: ^7any", labels[j][i]);
|
|
// for (; k<dispwidth[i]; k++) disptext[k] = 0;
|
|
|
|
printext16(xpos[i], ypos+j*8, editorcolors[11], editorcolors[0], disptext, 0);
|
|
}
|
|
Bmemset(disptext, 0, sizeof(disptext));
|
|
|
|
// disptext[dispwidth[col]] = 0;
|
|
// showspritedata(spritenum, 0);
|
|
wallsprite = 2;
|
|
|
|
while (keystatus[KEYSC_ESC] == 0)
|
|
{
|
|
idle_waitevent();
|
|
if (handleevents())
|
|
{
|
|
if (quitevent) quitevent = 0;
|
|
}
|
|
|
|
printmessage16("Sprite search, press <Esc> to exit");
|
|
|
|
if (PRESSED_KEYSC(DOWN))
|
|
{
|
|
if (row < rowmax[col])
|
|
{
|
|
printext16(xpos[col],ypos+row*8,editorcolors[11],editorcolors[0],disptext,0);
|
|
row++;
|
|
}
|
|
}
|
|
if (PRESSED_KEYSC(UP))
|
|
{
|
|
if (row > 0)
|
|
{
|
|
printext16(xpos[col],ypos+row*8,editorcolors[11],editorcolors[0],disptext,0);
|
|
row--;
|
|
}
|
|
}
|
|
if (PRESSED_KEYSC(LEFT))
|
|
{
|
|
if (col > 0)
|
|
{
|
|
printext16(xpos[col],ypos+row*8,editorcolors[11],editorcolors[0],disptext,0);
|
|
col--;
|
|
disptext[dispwidth[col]] = 0;
|
|
if (row > rowmax[col]) row = rowmax[col];
|
|
}
|
|
}
|
|
if (PRESSED_KEYSC(RIGHT))
|
|
{
|
|
if (col < 2)
|
|
{
|
|
printext16(xpos[col],ypos+row*8,editorcolors[11],editorcolors[0],disptext,0);
|
|
col++;
|
|
disptext[dispwidth[col]] = 0;
|
|
if (row > rowmax[col]) row = rowmax[col];
|
|
}
|
|
}
|
|
if (PRESSED_KEYSC(ENTER))
|
|
{
|
|
Bsprintf(edittext, "%s: ", labels[row][col]);
|
|
printmessage16("%s", edittext);
|
|
i = getnumber16(edittext, gs_spriteTagInterested[col][row] ? gs_spriteTagValue[col][row] : 0,
|
|
maxval[row][col], sign[row][col]);
|
|
if (col == 2 && row == 0) i = (i+2048)&2047; // angle
|
|
gs_spriteTagValue[col][row] = i;
|
|
gs_spriteTagInterested[col][row] = 1;
|
|
|
|
if (col == 1 && row == 5) // picnum
|
|
{
|
|
printext16(xpos[1], ypos-2*8, editorcolors[14], editorcolors[0], TWENTYFIVE_BLANKS, 0);
|
|
if (names[i][0])
|
|
printext16(xpos[1], ypos-2*8, editorcolors[14], editorcolors[0], names[i], 0);
|
|
}
|
|
}
|
|
if (PRESSED_KEYSC(BS) || PRESSED_KEYSC(DELETE))
|
|
{
|
|
gs_spriteTagInterested[col][row] = 0;
|
|
|
|
if (col == 1 && row == 5) // picnum
|
|
printext16(xpos[1], ypos-2*8, editorcolors[14], editorcolors[0], TWENTYFIVE_BLANKS, 0);
|
|
}
|
|
|
|
i = gs_spriteTagInterested[col][row];
|
|
if (i)
|
|
{
|
|
if (col == 1 && row == 0) // flags
|
|
k = Bsprintf(disptext, "%s: %x", labels[row][col], gs_spriteTagValue[col][row]);
|
|
else
|
|
k = Bsprintf(disptext, "%s: %d", labels[row][col], gs_spriteTagValue[col][row]);
|
|
}
|
|
else
|
|
k = Bsprintf(disptext, "%s: ^7any", labels[row][col]);
|
|
// v-------^^
|
|
for (; k<dispwidth[col]-2*i; k++) disptext[k] = ' ';
|
|
disptext[k] = 0;
|
|
|
|
printext16(xpos[col],ypos+row*8,editorcolors[11],editorcolors[1],disptext,0);
|
|
|
|
showframe(1);
|
|
}
|
|
|
|
printext16(xpos[col],ypos+row*8,editorcolors[11],editorcolors[0],disptext,0);
|
|
printmessage16("Search sprite");
|
|
showframe(1);
|
|
|
|
keystatus[KEYSC_ESC] = 0;
|
|
}
|
|
|
|
////////// SPECIAL FUNCTIONS MENU //////////
|
|
|
|
static int32_t numMenuFunctions = 8;
|
|
static char *funcMenuStrings[8*3] =
|
|
{
|
|
"Replace invalid tiles",
|
|
"Delete all spr of tile #",
|
|
"Set map sky shade",
|
|
"Set map sky height",
|
|
"Global Z coord shift",
|
|
"Resize selection",
|
|
"Global shade divide",
|
|
"Global visibility divide"
|
|
// dynamic menu entries start here
|
|
};
|
|
|
|
static ofstype funcMenuStatenum[8*2];
|
|
|
|
void registerMenuFunction(const char *funcname, int32_t stateidx)
|
|
{
|
|
char fn[25];
|
|
int32_t i;
|
|
|
|
if (funcname == NULL) // unregister stateidx
|
|
{
|
|
int32_t j;
|
|
|
|
for (i=8; i<numMenuFunctions; i++)
|
|
if (funcMenuStatenum[i-8]==stateidx)
|
|
{
|
|
Bfree(funcMenuStrings[i]);
|
|
|
|
for (j=i; j<numMenuFunctions-1; j++)
|
|
{
|
|
funcMenuStatenum[j] = funcMenuStatenum[j+1];
|
|
funcMenuStrings[j] = funcMenuStrings[j+1];
|
|
}
|
|
|
|
funcMenuStatenum[j] = 0;
|
|
funcMenuStrings[j] = NULL;
|
|
|
|
numMenuFunctions--;
|
|
|
|
break;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// register menu entry named FUNCNAME to call the M32script
|
|
// state with index STATEIDX
|
|
Bstrncpy(fn, funcname, sizeof(fn));
|
|
fn[sizeof(fn)-1] = 0;
|
|
|
|
for (i=8; i<numMenuFunctions; i++)
|
|
{
|
|
if (funcMenuStatenum[i-8]==stateidx)
|
|
{
|
|
// same stateidx, different name
|
|
Bfree(funcMenuStrings[i]);
|
|
funcMenuStrings[i] = Bstrdup(fn);
|
|
return;
|
|
}
|
|
else if (!Bstrcmp(funcMenuStrings[i], fn))
|
|
{
|
|
// same name, different stateidx
|
|
funcMenuStatenum[i-8] = stateidx;
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (numMenuFunctions == 3*8)
|
|
return; // max reached
|
|
|
|
funcMenuStrings[numMenuFunctions] = Bstrdup(fn);
|
|
funcMenuStatenum[numMenuFunctions-8] = stateidx;
|
|
|
|
numMenuFunctions++;
|
|
}
|
|
|
|
#define MENU_Y_SPACING 8
|
|
#define MENU_BASE_Y ydim-STATUS2DSIZ+32
|
|
|
|
static int32_t correct_picnum(int16_t *picnumptr)
|
|
{
|
|
int32_t picnum = *picnumptr;
|
|
|
|
if ((unsigned)picnum >= MAXTILES || tilesizx[picnum] <= 0)
|
|
{
|
|
*picnumptr = 0;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void FuncMenuOpts(void)
|
|
{
|
|
int32_t x = 8;
|
|
int32_t y = MENU_BASE_Y+16;
|
|
int32_t i;
|
|
|
|
for (i=0; i<numMenuFunctions; i++)
|
|
{
|
|
if (i==8 || i==16)
|
|
{
|
|
x += 208;
|
|
y = MENU_BASE_Y+16;
|
|
}
|
|
|
|
printext16(x,y,editorcolors[11],editorcolors[0],funcMenuStrings[i],0);
|
|
y += MENU_Y_SPACING;
|
|
}
|
|
|
|
printext16(numMenuFunctions>8 ? 216 : 8, MENU_BASE_Y,
|
|
editorcolors[11], -1, "Special functions", 0);
|
|
|
|
clearkeys();
|
|
}
|
|
|
|
static void FuncMenu(void)
|
|
{
|
|
char disptext[80];
|
|
int32_t col=0, row=0, rowmax=7, dispwidth = 24, editval = 0, i = -1, j;
|
|
int32_t xpos = 8, ypos = MENU_BASE_Y+16;
|
|
int32_t crowmax[3] = {7, -1, -1};
|
|
|
|
if (numMenuFunctions > 16)
|
|
{
|
|
crowmax[2] = numMenuFunctions-16-1;
|
|
crowmax[1] = 7;
|
|
}
|
|
else if (numMenuFunctions > 8)
|
|
crowmax[1] = numMenuFunctions-8-1;
|
|
|
|
drawgradient();
|
|
|
|
disptext[dispwidth] = 0;
|
|
// clearmidstatbar16();
|
|
|
|
FuncMenuOpts();
|
|
|
|
while (!editval && keystatus[KEYSC_ESC] == 0)
|
|
{
|
|
idle_waitevent();
|
|
if (handleevents())
|
|
quitevent = 0;
|
|
|
|
_printmessage16("Select an option, press <Esc> to exit");
|
|
if (PRESSED_KEYSC(DOWN))
|
|
{
|
|
if (row < rowmax)
|
|
{
|
|
printext16(xpos,ypos+row*MENU_Y_SPACING,editorcolors[11],editorcolors[0],disptext,0);
|
|
row++;
|
|
}
|
|
}
|
|
if (PRESSED_KEYSC(UP))
|
|
{
|
|
if (row > 0)
|
|
{
|
|
printext16(xpos,ypos+row*MENU_Y_SPACING,editorcolors[11],editorcolors[0],disptext,0);
|
|
row--;
|
|
}
|
|
}
|
|
#if 1
|
|
if (PRESSED_KEYSC(LEFT))
|
|
{
|
|
if (col==1 || col==2)
|
|
{
|
|
printext16(xpos,ypos+row*8,editorcolors[11],0,disptext,0);
|
|
col--;
|
|
xpos -= 208;
|
|
rowmax = crowmax[col];
|
|
disptext[dispwidth] = 0;
|
|
if (row > rowmax) row = rowmax;
|
|
}
|
|
}
|
|
|
|
if (PRESSED_KEYSC(RIGHT))
|
|
{
|
|
if ((col==0 || col==1) && crowmax[col+1]>=0)
|
|
{
|
|
printext16(xpos,ypos+row*8,editorcolors[11],0,disptext,0);
|
|
col++;
|
|
xpos += 208;
|
|
rowmax = crowmax[col];
|
|
disptext[dispwidth] = 0;
|
|
if (row > rowmax) row = rowmax;
|
|
}
|
|
}
|
|
#endif
|
|
if (PRESSED_KEYSC(ENTER))
|
|
editval = 1;
|
|
|
|
switch (col)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
{
|
|
for (i=Bsnprintf(disptext,dispwidth,"%s",funcMenuStrings[col*8 + row]); i < dispwidth; i++)
|
|
disptext[i] = ' ';
|
|
|
|
if (editval)
|
|
{
|
|
char *statename = statesinfo[funcMenuStatenum[(col-1)*8 + row]].name;
|
|
int32_t snlen = Bstrlen(statename);
|
|
char *tmpscript = Bmalloc(1+5+1+snlen+1);
|
|
|
|
if (!tmpscript)
|
|
break;
|
|
|
|
tmpscript[0] = ' '; // don't save in history
|
|
Bmemcpy(&tmpscript[1], "state", 5);
|
|
tmpscript[1+5] = ' ';
|
|
Bmemcpy(&tmpscript[1+5+1], statename, snlen);
|
|
tmpscript[1+5+1+snlen] = 0;
|
|
|
|
M32RunScript(tmpscript);
|
|
Bfree(tmpscript);
|
|
|
|
if (vm.flags&VMFLAG_ERROR)
|
|
printmessage16("There were errors while executing the menu function");
|
|
else
|
|
printmessage16("Menu function executed successfully");
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 0:
|
|
switch (row)
|
|
{
|
|
case 0:
|
|
{
|
|
for (i=Bsprintf(disptext,"%s",funcMenuStrings[row]); i < dispwidth; i++) disptext[i] = ' ';
|
|
if (editval)
|
|
{
|
|
j = 0;
|
|
for (i=0; i<MAXSECTORS; i++)
|
|
{
|
|
j += correct_picnum(§or[i].ceilingpicnum);
|
|
j += correct_picnum(§or[i].floorpicnum);
|
|
}
|
|
for (i=0; i<MAXWALLS; i++)
|
|
{
|
|
j += correct_picnum(&wall[i].picnum);
|
|
j += correct_picnum(&wall[i].overpicnum);
|
|
}
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
{
|
|
j += correct_picnum(&sprite[i].picnum);
|
|
}
|
|
printmessage16("Replaced %d invalid tiles",j);
|
|
}
|
|
}
|
|
break;
|
|
case 1:
|
|
{
|
|
for (i=Bsprintf(disptext,"%s",funcMenuStrings[row]); i < dispwidth; i++) disptext[i] = ' ';
|
|
if (editval)
|
|
{
|
|
Bsprintf(tempbuf,"Delete all sprites of tile #: ");
|
|
i = getnumber16(tempbuf,-1,MAXSPRITES-1,1);
|
|
if (i >= 0)
|
|
{
|
|
int32_t k = 0;
|
|
for (j=0; j<MAXSPRITES; j++)
|
|
if (sprite[j].picnum == i)
|
|
deletesprite(j), k++;
|
|
printmessage16("%d sprite(s) deleted",k);
|
|
}
|
|
else printmessage16("Aborted");
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
for (i=Bsprintf(disptext,"%s",funcMenuStrings[row]); i < dispwidth; i++) disptext[i] = ' ';
|
|
if (editval)
|
|
{
|
|
j=getnumber16("Set map sky shade: ",0,128,1);
|
|
|
|
for (i=0; i<numsectors; i++)
|
|
{
|
|
if (sector[i].ceilingstat&1)
|
|
sector[i].ceilingshade = j;
|
|
}
|
|
printmessage16("All parallax skies adjusted");
|
|
}
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
for (i=Bsprintf(disptext,"%s",funcMenuStrings[row]); i < dispwidth; i++) disptext[i] = ' ';
|
|
if (editval)
|
|
{
|
|
j=getnumber16("Set map sky height: ",0,16777216,1);
|
|
if (j != 0)
|
|
{
|
|
for (i=0; i<numsectors; i++)
|
|
{
|
|
if (sector[i].ceilingstat&1)
|
|
sector[i].ceilingz = j;
|
|
}
|
|
printmessage16("All parallax skies adjusted");
|
|
}
|
|
else printmessage16("Aborted");
|
|
}
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
for (i=Bsprintf(disptext,"%s",funcMenuStrings[row]); i < dispwidth; i++) disptext[i] = ' ';
|
|
if (editval)
|
|
{
|
|
j=getnumber16("Z offset: ",0,16777216,1);
|
|
if (j!=0)
|
|
{
|
|
for (i=0; i<numsectors; i++)
|
|
{
|
|
sector[i].ceilingz += j;
|
|
sector[i].floorz += j;
|
|
}
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
sprite[i].z += j;
|
|
printmessage16("Map adjusted");
|
|
}
|
|
else printmessage16("Aborted");
|
|
}
|
|
}
|
|
break;
|
|
case 5:
|
|
{
|
|
for (i=Bsprintf(disptext,"%s",funcMenuStrings[row]); i < dispwidth; i++) disptext[i] = ' ';
|
|
if (editval)
|
|
{
|
|
j=getnumber16("Percentage of original: ",100,1000,0);
|
|
if (j!=100)
|
|
{
|
|
int32_t w, currsector, start_wall, end_wall;
|
|
double size = (j/100.f);
|
|
for (i = 0; i < highlightsectorcnt; i++)
|
|
{
|
|
currsector = highlightsector[i];
|
|
sector[currsector].ceilingz = (int32_t)(sector[currsector].ceilingz*size);
|
|
sector[currsector].floorz = (int32_t)(sector[currsector].floorz*size);
|
|
// Do all the walls in the sector
|
|
start_wall = sector[currsector].wallptr;
|
|
end_wall = start_wall + sector[currsector].wallnum;
|
|
for (w = start_wall; w < end_wall; w++)
|
|
{
|
|
wall[w].x = (int32_t)(wall[w].x*size);
|
|
wall[w].y = (int32_t)(wall[w].y*size);
|
|
wall[w].yrepeat = min((int32_t)(wall[w].yrepeat/size),255);
|
|
}
|
|
w = headspritesect[highlightsector[i]];
|
|
while (w >= 0)
|
|
{
|
|
sprite[w].x = (int32_t)(sprite[w].x*size);
|
|
sprite[w].y = (int32_t)(sprite[w].y*size);
|
|
sprite[w].z = (int32_t)(sprite[w].z*size);
|
|
sprite[w].xrepeat = min(max((int32_t)(sprite[w].xrepeat*size),1),255);
|
|
sprite[w].yrepeat = min(max((int32_t)(sprite[w].yrepeat*size),1),255);
|
|
w = nextspritesect[w];
|
|
}
|
|
}
|
|
printmessage16("Map scaled");
|
|
}
|
|
else printmessage16("Aborted");
|
|
}
|
|
}
|
|
break;
|
|
case 6:
|
|
{
|
|
for (i=Bsprintf(disptext,"%s",funcMenuStrings[row]); i < dispwidth; i++) disptext[i] = ' ';
|
|
if (editval)
|
|
{
|
|
j=getnumber16("Shade divisor: ",1,128,1);
|
|
if (j!=1)
|
|
{
|
|
for (i=0; i<numsectors; i++)
|
|
{
|
|
sector[i].ceilingshade /= j;
|
|
sector[i].floorshade /= j;
|
|
}
|
|
for (i=0; i<numwalls; i++)
|
|
wall[i].shade /= j;
|
|
for (i=0; i<MAXSPRITES; i++)
|
|
sprite[i].shade /= j;
|
|
printmessage16("Shades adjusted");
|
|
}
|
|
else printmessage16("Aborted");
|
|
}
|
|
}
|
|
break;
|
|
case 7:
|
|
{
|
|
for (i=Bsprintf(disptext,"%s",funcMenuStrings[row]); i < dispwidth; i++) disptext[i] = ' ';
|
|
if (editval)
|
|
{
|
|
j=getnumber16("Visibility divisor: ",1,128,0);
|
|
if (j!=1)
|
|
{
|
|
for (i=0; i<numsectors; i++)
|
|
{
|
|
if (sector[i].visibility < 240)
|
|
sector[i].visibility /= j;
|
|
else sector[i].visibility = 240 + (sector[i].visibility>>4)/j;
|
|
}
|
|
printmessage16("Visibility adjusted");
|
|
}
|
|
else printmessage16("Aborted");
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
printext16(xpos,ypos+row*MENU_Y_SPACING,editorcolors[11],editorcolors[1],disptext,0);
|
|
|
|
showframe(1);
|
|
}
|
|
|
|
printext16(xpos,ypos+row*MENU_Y_SPACING,editorcolors[11],editorcolors[0],disptext,0);
|
|
/*clearmidstatbar16();*/
|
|
|
|
showframe(1);
|
|
keystatus[KEYSC_ESC] = 0;
|
|
}
|