diff --git a/assets/CMakeLists.txt b/assets/CMakeLists.txt
index 68ff0fdf9fdd64134989b8a2a16fd7c74ff589a5..8811536826795daf8667d943a5a725ea112e19cf 100644
--- a/assets/CMakeLists.txt
+++ b/assets/CMakeLists.txt
@@ -13,11 +13,10 @@ set(SRB2_ASSET_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/installer"
CACHE STRING "Path to directory that contains all asset files for the installer.")
set(SRB2_ASSET_HASHED
-"srb2.srb;\
+"srb2.pk3;\
player.dta;\
-rings.dta;\
-zones.dta;\
-patch.dta"
+zones.pk3;\
+patch.pk3"
CACHE STRING "Asset filenames to apply MD5 checks. No spaces between entries!"
)
diff --git a/extras/conf/SRB2-22.cfg b/extras/conf/SRB2-22.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..92b072b4dd3c5b455c939d614b2404172b47e3e5
--- /dev/null
+++ b/extras/conf/SRB2-22.cfg
@@ -0,0 +1,6482 @@
+/*********************************************************\
+ Zone Builder Game Configuration
+ For Sonic Robo Blast 2 Version 2.2
+ Contributors (alphabetical):
+ * Foxboy
+ * JJames19119
+ * Kalaron
+ * Kristos
+ * MascaraSnake
+ * mazmazz
+ * Morpheus
+ * Neo Chaotikal
+ * Nev3r
+ * Oogaland
+ * Rob
+ * Shadow Hog
+ * Spherallic
+ * SRB2-Playah
+ * SSNTails
+ * SteelT
+ * ST218
+ * toaster
+ * Viola
+\*********************************************************/
+
+// This is required to prevent accidental use of a different configuration
+type = "Doom Builder 2 Game Configuration";
+
+// This is the title to show for this game
+game = "Sonic Robo Blast 2 - 2.2";
+
+//GZDB specific. Don't try to load lumps that don't exist.
+basegame = 0;
+
+// This is the simplified game engine/sourceport name
+engine = "zdoom";
+
+// When this is set to true, sectors with the same tag will light up when a line is highlighted
+linetagindicatesectors = true;
+
+// The format interface handles the map data format - DoomMapSetIO for SRB2DB2, SRB2MapSetIO for Zone Builder
+formatinterface = "SRB2MapSetIO";
+
+//Sky textures for vanilla maps
+defaultskytextures
+{
+ SKY1 = "MAP01,MAP02,MAP03,MAP50,MAPA1,MAPA2,MAPA5,MAPA6,MAPA9,MAPAA,MAPAB,MAPAC,MAPAD,MAPAE,MAPAG,MAPAJ,MAPAK,MAPF0,MAPF1,MAPFA,MAPM0,MAPM8,MAPMA,MAPMB,MAPMC";
+ SKY4 = "MAP04,MAP06,MAP51,MAPF8,MAPM1";
+ SKY6 = "MAP05";
+ SKY7 = "MAP07,MAP08,MAP09,MAP52,MAPM2,MAPM5";
+ SKY10 = "MAP12,MAP53,MAPM3";
+ SKY11 = "MAP10,MAP11,MAP16,MAP55,MAPF2,MAPF5,MAPF6,MAPF9,MAPM7";
+ SKY13 = "MAP13,MAP54,MAPAS";
+ SKY21 = "MAPAF,MAPF7,MAPM4";
+ SKY22 = "MAP22,MAP23,MAP24,MAP25,MAP56,MAPAN,MAPAO,MAPF4,MAPM6";
+ SKY29 = "MAP58,MAPAV";
+ SKY30 = "MAP30";
+ SKY35 = "MAP41";
+ SKY40 = "MAP40";
+ SKY55 = "MAPF3,MAPM9";
+ SKY66 = "MAPAT";
+ SKY99 = "MAP57";
+ SKY103 = "MAPA3,MAPA4,MAPAU";
+ SKY107 = "MAPA7,MAPA8";
+ SKY117 = "MAPAH,MAPAI";
+ SKY127 = "MAPAR";
+ SKY132 = "MAPAW";
+}
+
+// Default lump name for new map
+defaultlumpname = "MAP01";
+
+// Default testing parameters
+testparameters = "-file \"%AP\" \"%F\" -warp %L";
+testshortpaths = true;
+
+// Default nodebuilder configurations
+defaultsavecompiler = "zennode_normal";
+defaulttestcompiler = "zennode_fast";
+
+// Skill levels
+skills
+{
+ 1 = "Normal";
+}
+
+// Skins
+skins
+{
+ Sonic;
+ Tails;
+ Knuckles;
+ Metalsonic;
+ Fang;
+ Amy;
+}
+
+// Gametypes
+gametypes
+{
+ -1 = "Single Player";
+ 0 = "Co-op";
+ 1 = "Competition";
+ 2 = "Race";
+ 3 = "Match";
+ 4 = "Team Match";
+ 5 = "Tag";
+ 6 = "Hide and Seek";
+ 7 = "CTF";
+}
+
+// Special linedefs
+soundlinedefflag = 64; // See linedefflags
+singlesidedflag = 1; // See linedefflags
+doublesidedflag = 4; // See linedefflags
+impassableflag = 1;
+upperunpeggedflag = 8;
+lowerunpeggedflag = 16;
+repeatmidtextureflag = 1024;
+pegmidtextureflag = 256;
+
+// Generalized actions
+generalizedlinedefs = false;
+generalizedsectors = true;
+
+// Texture loading options
+defaultwalltexture = "GFZROCK";
+defaultfloortexture = "GFZFLR01";
+defaultceilingtexture = "F_SKY1";
+mixtexturesflats = true;
+defaulttexturescale = 1.0f;
+defaultflatscale = 1.0f;
+
+// Thing number for start position in 3D Mode
+start3dmode = 3328;
+
+
+
+
+/*
+TEXTURES AND FLAT SOURCES
+This tells Doom Builder where to find the information for textures
+and flats in the IWAD file, Addition WAD file and Map WAD file.
+
+Start and end lumps must be given in a structure (of which the
+key name doesnt matter) and any textures or flats in between them
+are loaded in either the textures category or flats category.
+
+For textures: PNAMES, TEXTURE1 and TEXTURE2 are loaded by default.
+Kalaron: and now TX_START
+*/
+
+// Texture sources
+textures
+{
+ zdoom1
+ {
+ start = "TX_START";
+ end = "TX_END";
+ }
+}
+
+// Patch sources
+patches
+{
+ standard1
+ {
+ start = "P_START";
+ end = "P_END";
+ }
+
+ standard2
+ {
+ start = "PP_START";
+ end = "PP_END";
+ }
+}
+
+// Sprite sources
+sprites
+{
+ standard1
+ {
+ start = "S_START";
+ end = "S_END";
+ }
+
+ standard2
+ {
+ start = "SS_START";
+ end = "SS_END";
+ }
+}
+
+// Flat sources
+flats
+{
+ standard1
+ {
+ start = "F_START";
+ end = "F_END";
+ }
+
+ standard2
+ {
+ start = "FF_START";
+ end = "FF_END";
+ }
+
+ standard3
+ {
+ start = "FF_START";
+ end = "F_END";
+ }
+
+ standard4
+ {
+ start = "F_START";
+ end = "FF_END";
+ }
+}
+
+
+/*
+GAME DETECT PATTERN
+Used to guess the game for which a WAD file is made.
+
+1 = One of these lumps must exist
+2 = None of these lumps must exist
+3 = All of these lumps must exist
+*/
+
+gamedetect
+{
+ EXTENDED = 2;
+
+
+ BEHAVIOR = 2;
+
+ E#M# = 2;
+
+ MAP?? = 1;
+}
+
+
+/*
+MAP LUMP NAMES
+Map lumps are loaded with the map as long as they are right after each other. When the editor
+meets a lump which is not defined in this list it will ignore the map if not satisfied.
+The order of items defines the order in which lumps will be written to WAD file on save.
+To indicate the map header lump, use ~MAP
+
+Legenda:
+required = Lump is required to exist.
+blindcopy = Lump will be copied along with the map blindly. (usefull for lumps Doom Builder doesn't use)
+nodebuild = The nodebuilder generates this lump.
+allowempty = The nodebuilder is allowed to leave this lump empty.
+script = This lump is a text-based script. Specify the filename of the script configuration to use.
+*/
+
+maplumpnames
+{
+ ~MAP
+ {
+ required = true;
+ blindcopy = true;
+ nodebuild = false;
+ }
+
+ THINGS
+ {
+ required = true;
+ nodebuild = true;
+ allowempty = true;
+ }
+
+ LINEDEFS
+ {
+ required = true;
+ nodebuild = true;
+ allowempty = false;
+ }
+
+ SIDEDEFS
+ {
+ required = true;
+ nodebuild = true;
+ allowempty = false;
+ }
+
+ VERTEXES
+ {
+ required = true;
+ nodebuild = true;
+ allowempty = false;
+ }
+
+ SEGS
+ {
+ required = false;
+ nodebuild = true;
+ allowempty = false;
+ }
+
+ SSECTORS
+ {
+ required = false;
+ nodebuild = true;
+ allowempty = false;
+ }
+
+ NODES
+ {
+ required = false;
+ nodebuild = true;
+ allowempty = false;
+ }
+
+ SECTORS
+ {
+ required = true;
+ nodebuild = true;
+ allowempty = false;
+ }
+
+ REJECT
+ {
+ required = false;
+ nodebuild = true;
+ allowempty = false;
+ }
+
+ BLOCKMAP
+ {
+ required = false;
+ nodebuild = true;
+ allowempty = true;
+ }
+}
+
+scriptlumpnames
+{
+ MAINCFG
+ {
+ script = "SOC.cfg";
+ }
+
+ OBJCTCFG
+ {
+ script = "SOC.cfg";
+ }
+
+ SOC_
+ {
+ script = "SOC.cfg";
+ isprefix = true;
+ }
+
+ LUA_
+ {
+ script = "Lua.cfg";
+ isprefix = true;
+ }
+}
+
+// DEFAULT SECTOR BRIGHTNESS LEVELS
+sectorbrightness
+{
+ 255;
+ 248;
+ 240;
+ 232;
+ 224;
+ 216;
+ 208;
+ 200;
+ 192;
+ 184;
+ 176;
+ 168;
+ 160;
+ 152;
+ 144;
+ 136;
+ 128;
+ 120;
+ 112;
+ 104;
+ 96;
+ 88;
+ 80;
+ 72;
+ 64;
+ 56;
+ 48;
+ 40;
+ 32;
+ 24;
+ 16;
+ 8;
+ 0;
+}
+
+// SECTOR TYPES-----------------------------------------------------------------
+sectortypes
+{
+ 0 = "Normal";
+ 1 = "Damage";
+ 2 = "Damage (Water)";
+ 3 = "Damage (Fire)";
+ 4 = "Damage (Electrical)";
+ 5 = "Spikes";
+ 6 = "Death Pit (Camera Tilt)";
+ 7 = "Death Pit (No Camera Tilt)";
+ 8 = "Instant Kill";
+ 9 = "Ring Drainer (Floor Touch)";
+ 10 = "Ring Drainer (Anywhere in Sector)";
+ 11 = "Special Stage Damage";
+ 12 = "Space Countdown";
+ 13 = "Ramp Sector (double step-up/down)";
+ 14 = "Non-Ramp Sector (no step-down)";
+ 15 = "Bouncy FOF";
+ 16 = "Trigger Line Ex. (Pushable Objects)";
+ 32 = "Trigger Line Ex. (Anywhere, All Players)";
+ 48 = "Trigger Line Ex. (Floor Touch, All Players)";
+ 64 = "Trigger Line Ex. (Anywhere in Sector)";
+ 80 = "Trigger Line Ex. (Floor Touch)";
+ 96 = "Trigger Line Ex. (Emerald Check)";
+ 112 = "Trigger Line Ex. (NiGHTS Mare)";
+ 128 = "Check for Linedef Executor on FOFs";
+ 144 = "Egg Capsule";
+ 160 = "Special Stage Time/Rings Parameters";
+ 176 = "Custom Global Gravity";
+ 512 = "Wind/Current";
+ 1024 = "Conveyor Belt";
+ 1280 = "Speed Pad";
+ 4096 = "Star Post Activator";
+ 8192 = "Exit/Special Stage Pit/Return Flag";
+ 12288 = "CTF Red Team Base";
+ 16384 = "CTF Blue Team Base";
+ 20480 = "Fan Sector";
+ 24576 = "Super Sonic Transform";
+ 28672 = "Force Spin";
+ 32768 = "Zoom Tube Start";
+ 36864 = "Zoom Tube End";
+ 40960 = "Circuit Finish Line";
+ 45056 = "Rope Hang";
+ 49152 = "Intangible to the Camera";
+}
+
+
+// GENERALISED SECTOR TYPES-----------------------------------------------------------------
+gen_sectortypes
+{
+ first
+ {
+ 0 = "Normal";
+ 1 = "Damage";
+ 2 = "Damage (Water)";
+ 3 = "Damage (Fire)";
+ 4 = "Damage (Electrical)";
+ 5 = "Spikes";
+ 6 = "Death Pit (Camera Tilt)";
+ 7 = "Death Pit (No Camera Tilt)";
+ 8 = "Instant Kill";
+ 9 = "Ring Drainer (Floor Touch)";
+ 10 = "Ring Drainer (Anywhere in Sector)";
+ 11 = "Special Stage Damage";
+ 12 = "Space Countdown";
+ 13 = "Ramp Sector (double step-up/down)";
+ 14 = "Non-Ramp Sector (no step-down)";
+ 15 = "Bouncy FOF";
+ }
+
+ second
+ {
+ 0 = "Normal";
+ 16 = "Trigger Line Ex. (Pushable Objects)";
+ 32 = "Trigger Line Ex. (Anywhere, All Players)";
+ 48 = "Trigger Line Ex. (Floor Touch, All Players)";
+ 64 = "Trigger Line Ex. (Anywhere in Sector)";
+ 80 = "Trigger Line Ex. (Floor Touch)";
+ 96 = "Trigger Line Ex. (Emerald Check)";
+ 112 = "Trigger Line Ex. (NiGHTS Mare)";
+ 128 = "Check for Linedef Executor on FOFs";
+ 144 = "Egg Capsule";
+ 160 = "Special Stage Time/Rings Parameters";
+ 176 = "Custom Global Gravity";
+ }
+
+ third
+ {
+ 0 = "Normal";
+ 512 = "Wind/Current";
+ 1024 = "Conveyor Belt";
+ 1280 = "Speed Pad";
+ }
+
+ fourth
+ {
+ 0 = "Normal";
+ 4096 = "Star Post Activator";
+ 8192 = "Exit/Special Stage Pit/Return Flag";
+ 12288 = "CTF Red Team Base";
+ 16384 = "CTF Blue Team Base";
+ 20480 = "Fan Sector";
+ 24576 = "Super Sonic Transform";
+ 28672 = "Force Spin";
+ 32768 = "Zoom Tube Start";
+ 36864 = "Zoom Tube End";
+ 40960 = "Circuit Finish Line";
+ 45056 = "Rope Hang";
+ 49152 = "Intangible to the Camera";
+ }
+}
+
+// LINEDEF FLAGS
+linedefflags
+{
+ 1 = "[0] Impassable";
+ 2 = "[1] Block Enemies";
+ 4 = "[2] Double-Sided";
+ 8 = "[3] Upper Unpegged";
+ 16 = "[4] Lower Unpegged";
+ 32 = "[5] Slope Skew (E1)";
+ 64 = "[6] Not Climbable";
+ 128 = "[7] No Midtexture Skew (E2)";
+ 256 = "[8] Peg Midtexture (E3)";
+ 512 = "[9] Solid Midtexture (E4)";
+ 1024 = "[10] Repeat Midtexture (E5)";
+ 2048 = "[11] Netgame Only";
+ 4096 = "[12] No Netgame";
+ 8192 = "[13] Effect 6";
+ 16384 = "[14] Bouncy Wall";
+ 32768 = "[15] Transfer Line";
+}
+
+// Linedef flags UDMF translation table
+// This is needed for copy/paste and prefabs to work properly
+// When the UDMF field name is prefixed with ! it is inverted
+linedefflagstranslation
+{
+ 1 = "blocking";
+ 2 = "blockmonsters";
+ 4 = "twosided";
+ 8 = "dontpegtop";
+ 16 = "dontpegbottom";
+ 32 = "secret";
+ 64 = "blocksound";
+ 128 = "dontdraw";
+ 256 = "mapped";
+}
+
+// LINEDEF ACTIVATIONS
+linedefactivations
+{
+}
+
+// LINEDEF TYPES
+linedeftypes
+{
+ misc
+ {
+ title = "Miscellaneous";
+
+ 0
+ {
+ title = "None";
+ prefix = "(0)";
+ }
+
+ 1
+ {
+ title = "Per-Sector Gravity";
+ prefix = "(1)";
+ flags64text = "[6] Flip in reverse gravity";
+ }
+
+ 5
+ {
+ title = "Camera Scanner";
+ prefix = "(5)";
+ }
+
+ 7
+ {
+ title = "Sector Flat Alignment";
+ prefix = "(7)";
+ flags2048text = "[11] Don't align floor";
+ flags4096text = "[12] Don't align ceiling";
+ flags8192text = "[13] Use texture offsets";
+ }
+
+ 10
+ {
+ title = "Culling Plane";
+ prefix = "(10)";
+ flags64text = "[6] Cull only while in sector";
+ }
+
+ 13
+ {
+ title = "Heat Wave Effect";
+ prefix = "(13)";
+ }
+
+ 40
+ {
+ title = "Visual Portal Between Tagged Linedefs";
+ prefix = "(40)";
+ }
+
+ 41
+ {
+ title = "Horizon Effect";
+ prefix = "(41)";
+ }
+
+ 50
+ {
+ title = "Instantly Lower Floor on Level Load";
+ prefix = "(50)";
+ }
+
+ 51
+ {
+ title = "Instantly Raise Ceiling on Level Load";
+ prefix = "(51)";
+ }
+
+ 63
+ {
+ title = "Fake Floor/Ceiling Planes";
+ prefix = "(63)";
+ }
+
+ 540
+ {
+ title = "Floor Friction";
+ prefix = "(540)";
+ }
+ }
+
+ parameters
+ {
+ title = "Parameters";
+
+ 2
+ {
+ title = "Custom Exit";
+ prefix = "(2)";
+ flags2text = "[1] Check emeralds";
+ flags64text = "[6] Skip score tally";
+ }
+
+ 3
+ {
+ title = "Zoom Tube Parameters";
+ prefix = "(3)";
+ flags512text = "[9] Ignore player direction";
+ }
+
+ 4
+ {
+ title = "Speed Pad Parameters";
+ prefix = "(4)";
+ flags512text = "[9] No teleport to center";
+ flags1024text = "[10] Force spinning frames";
+ }
+
+ 8
+ {
+ title = "Special Sector Properties";
+ prefix = "(8)";
+ flags32text = "[5] Invert precipitation";
+ flags64text = "[6] Touch only ceiling";
+ flags128text = "[7] Allow opposite gravity";
+ flags256text = "[8] Touch sector edge";
+ flags512text = "[9] Touch floor or ceiling";
+ }
+
+ 9
+ {
+ title = "Chain Parameters";
+ prefix = "(9)";
+ flags32text = "[5] Swing instead of spin";
+ flags64text = "[6] Player-turnable chain";
+ flags128text = "[7] Make chain from maces";
+ flags256text = "[8] Spawn mace at origin";
+ flags512text = "[9] Don't clip inside ground";
+ flags1024text = "[10] No distance check";
+ }
+
+ 11
+ {
+ title = "Rope Hang Parameters";
+ prefix = "(11)";
+ flags32text = "[5] Don't loop";
+ flags64text = "[6] Static";
+ }
+
+ 12
+ {
+ title = "Rock Spawner Parameters";
+ prefix = "(12)";
+ flags64text = "[6] Randomize speed";
+ }
+
+ 14
+ {
+ title = "Bustable Block Parameters";
+ prefix = "(14)";
+ flags32text = "[5] Particles launch from center";
+ }
+
+ 15
+ {
+ title = "Fan Particle Spawner Parameters";
+ prefix = "(15)";
+ }
+
+ 16
+ {
+ title = "Minecart Parameters";
+ prefix = "(16)";
+ }
+
+ 64
+ {
+ title = "Continuously Appearing/Disappearing FOF";
+ prefix = "(64)";
+ flags2text = "[1] Use control sector tag";
+ flags64text = "[6] No sound effect";
+ }
+
+ 65
+ {
+ title = "Bridge Thinker <disabled>";
+ prefix = "(65)";
+ }
+ }
+
+ polyobject
+ {
+ title = "PolyObject";
+
+ 20
+ {
+ title = "First Line";
+ prefix = "(20)";
+ }
+
+ 21
+ {
+ title = "Explicitly Include Line <disabled>";
+ prefix = "(21)";
+ }
+
+ 22
+ {
+ title = "Parameters";
+ prefix = "(22)";
+ flags64text = "[6] Trigger linedef executor";
+ flags128text = "[7] Intangible";
+ flags256text = "[8] Stopped by pushables";
+ flags512text = "[9] Render flats";
+ }
+
+ 30
+ {
+ title = "Waving Flag";
+ prefix = "(30)";
+ }
+
+ 31
+ {
+ title = "Displacement by Front Sector";
+ prefix = "(31)";
+ }
+
+ 32
+ {
+ title = "Angular Displacement by Front Sector";
+ prefix = "(32)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Don't turn players";
+ flags512text = "[9] Turn all objects";
+ }
+ }
+
+ planemove
+ {
+ title = "Plane Movement";
+
+ 52
+ {
+ title = "Continuously Falling Sector";
+ prefix = "(52)";
+ flags64text = "[6] Continuously rising";
+ }
+
+ 53
+ {
+ title = "Continuous Floor/Ceiling Mover";
+ prefix = "(53)";
+ }
+
+ 54
+ {
+ title = "Continuous Floor Mover";
+ prefix = "(54)";
+ }
+
+ 55
+ {
+ title = "Continuous Ceiling Mover";
+ prefix = "(55)";
+ }
+
+ 56
+ {
+ title = "Continuous Two-Speed Floor/Ceiling Mover";
+ prefix = "(56)";
+ }
+
+ 57
+ {
+ title = "Continuous Two-Speed Floor Mover";
+ prefix = "(57)";
+ }
+
+ 58
+ {
+ title = "Continuous Two-Speed Ceiling Mover";
+ prefix = "(58)";
+ }
+
+ 59
+ {
+ title = "Activate Moving Platform";
+ prefix = "(59)";
+ flags64text = "[6] Move upwards at start";
+ }
+
+ 60
+ {
+ title = "Activate Moving Platform (Adjustable Speed)";
+ prefix = "(60)";
+ flags64text = "[6] Move upwards at start";
+ }
+
+ 61
+ {
+ title = "Crusher (Ceiling to Floor)";
+ prefix = "(61)";
+ flags512text = "[9] Double, constant speed";
+ }
+
+ 62
+ {
+ title = "Crusher (Floor to Ceiling)";
+ prefix = "(62)";
+ flags512text = "[9] Double, constant speed";
+ }
+
+ 66
+ {
+ title = "Move Floor by Displacement";
+ prefix = "(66)";
+ flags64text = "[6] Inverse movement";
+ }
+
+ 67
+ {
+ title = "Move Ceiling by Displacement";
+ prefix = "(67)";
+ flags64text = "[6] Inverse movement";
+ }
+
+ 68
+ {
+ title = "Move Floor and Ceiling by Displacement";
+ prefix = "(68)";
+ flags64text = "[6] Inverse movement";
+ }
+ }
+
+ fofsolid
+ {
+ title = "FOF (solid)";
+
+ 100
+ {
+ title = "Solid, Opaque";
+ prefix = "(100)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "19F";
+ }
+
+ 101
+ {
+ title = "Solid, Opaque, No Shadow";
+ prefix = "(101)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "1DF";
+ }
+
+ 102
+ {
+ title = "Solid, Translucent";
+ prefix = "(102)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Render insides";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "195F";
+ flags643dfloorflagsadd = "7C80";
+ }
+
+ 103
+ {
+ title = "Solid, Sides Only";
+ prefix = "(103)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "1CF";
+ }
+
+ 104
+ {
+ title = "Solid, No Sides";
+ prefix = "(104)";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Cast shadow";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "1D7";
+ flags643dfloorflagsremove = "40";
+ }
+
+ 105
+ {
+ title = "Solid, Invisible";
+ prefix = "(105)";
+ flags32text = "[5] Only block player";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "47";
+ }
+
+ 140
+ {
+ title = "Intangible from Bottom, Opaque";
+ prefix = "(140)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Don't cast shadow";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "200841F";
+ flags643dfloorflagsadd = "40";
+ }
+
+ 141
+ {
+ title = "Intangible from Bottom, Translucent";
+ prefix = "(141)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Don't cast shadow";
+ flags128text = "[7] Render insides/block non-plr";
+ 3dfloor = true;
+ 3dfloorflags = "200191F";
+ flags1283dfloorflagsadd = "7C80";
+ flags643dfloorflagsadd = "40";
+ }
+
+ 142
+ {
+ title = "Intangible from Bottom, Translucent, No Sides";
+ prefix = "(142)";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Don't cast shadow";
+ flags128text = "[7] Render insides/block non-plr";
+ 3dfloor = true;
+ 3dfloorflags = "2001917";
+ flags1283dfloorflagsadd = "7C80";
+ flags643dfloorflagsadd = "40";
+ }
+
+ 143
+ {
+ title = "Intangible from Top, Opaque";
+ prefix = "(143)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Don't cast shadow";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "400841F";
+ flags643dfloorflagsadd = "40";
+ }
+
+ 144
+ {
+ title = "Intangible from Top, Translucent";
+ prefix = "(144)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Don't cast shadow";
+ flags128text = "[7] Render insides/block non-plr";
+ 3dfloor = true;
+ 3dfloorflags = "400191F";
+ flags1283dfloorflagsadd = "7C80";
+ flags643dfloorflagsadd = "40";
+ }
+
+ 145
+ {
+ title = "Intangible from Top, Translucent, No Sides";
+ prefix = "(145)";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Don't cast shadow";
+ flags128text = "[7] Render insides/block non-plr";
+ 3dfloor = true;
+ 3dfloorflags = "4001917";
+ flags1283dfloorflagsadd = "7C80";
+ flags643dfloorflagsadd = "40";
+ }
+
+ 146
+ {
+ title = "Only Tangible from Sides";
+ prefix = "(146)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "600800F";
+ }
+ }
+
+ fofintangible
+ {
+ title = "FOF (intangible)";
+
+ 120
+ {
+ title = "Water, Opaque";
+ prefix = "(120)";
+ flags8text = "[3] Slope skew sides";
+ flags64text = "[6] Use two light levels";
+ flags512text = "[9] Use target light level";
+ flags1024text = "[10] Ripple effect";
+ 3dfloor = true;
+ 3dfloorflags = "8F39";
+ flags643dfloorflagsadd = "20000";
+ flags5123dfloorflagsadd = "80000000";
+ flags10243dfloorflagsadd = "40000000";
+ }
+
+ 121
+ {
+ title = "Water, Translucent";
+ prefix = "(121)";
+ flags8text = "[3] Slope skew sides";
+ flags64text = "[6] Use two light levels";
+ flags512text = "[9] Use target light level";
+ flags1024text = "[10] Ripple effect";
+ 3dfloor = true;
+ 3dfloorflags = "9F39";
+ flags643dfloorflagsadd = "20000";
+ flags5123dfloorflagsadd = "80000000";
+ flags10243dfloorflagsadd = "40000000";
+ }
+
+ 122
+ {
+ title = "Water, Opaque, No Sides";
+ prefix = "(122)";
+ flags64text = "[6] Use two light levels";
+ flags512text = "[9] Use target light level";
+ flags1024text = "[10] Ripple effect";
+ 3dfloor = true;
+ 3dfloorflags = "F31";
+ flags643dfloorflagsadd = "20000";
+ flags5123dfloorflagsadd = "80000000";
+ flags10243dfloorflagsadd = "40000000";
+ }
+
+ 123
+ {
+ title = "Water, Translucent, No Sides";
+ prefix = "(123)";
+ flags64text = "[6] Use two light levels";
+ flags512text = "[9] Use target light level";
+ flags1024text = "[10] Ripple effect";
+ 3dfloor = true;
+ 3dfloorflags = "1F31";
+ flags643dfloorflagsadd = "20000";
+ flags5123dfloorflagsadd = "80000000";
+ flags10243dfloorflagsadd = "40000000";
+ }
+
+ 124
+ {
+ title = "Goo Water, Translucent";
+ prefix = "(124)";
+ flags8text = "[3] Slope skew sides";
+ flags64text = "[6] Use two light levels";
+ flags512text = "[9] Use target light level";
+ flags1024text = "[10] Ripple effect";
+ 3dfloor = true;
+ 3dfloorflags = "209F39";
+ flags643dfloorflagsadd = "20000";
+ flags5123dfloorflagsadd = "80000000";
+ flags10243dfloorflagsadd = "40000000";
+ }
+
+ 125
+ {
+ title = "Goo Water, Translucent, No Sides";
+ prefix = "(125)";
+ flags8text = "[3] Slope skew sides";
+ flags64text = "[6] Use two light levels";
+ flags512text = "[9] Use target light level";
+ flags1024text = "[10] Ripple effect";
+ 3dfloor = true;
+ 3dfloorflags = "201F31";
+ flags643dfloorflagsadd = "20000";
+ flags5123dfloorflagsadd = "80000000";
+ flags10243dfloorflagsadd = "40000000";
+ }
+
+ 220
+ {
+ title = "Intangible, Opaque";
+ prefix = "(220)";
+ flags8text = "[3] Slope skew sides";
+ 3dfloor = true;
+ 3dfloorflags = "8F19";
+ }
+
+ 221
+ {
+ title = "Intangible, Translucent";
+ prefix = "(221)";
+ flags8text = "[3] Slope skew sides";
+ flags64text = "[6] Cast shadow";
+ 3dfloor = true;
+ 3dfloorflags = "1B59";
+ flags643dfloorflagsremove = "40";
+ }
+
+ 222
+ {
+ title = "Intangible, Sides Only";
+ prefix = "(222)";
+ flags8text = "[3] Slope skew sides";
+ flags64text = "[6] Cast shadow";
+ 3dfloor = true;
+ 3dfloorflags = "8249";
+ flags643dfloorflagsremove = "240";
+ }
+
+ 223
+ {
+ title = "Intangible, Invisible";
+ prefix = "(223)";
+ 3dfloor = true;
+ 3dfloorflags = "41";
+ }
+ }
+
+ fofmoving
+ {
+ title = "FOF (moving)";
+
+ 150
+ {
+ title = "Air Bobbing";
+ prefix = "(150)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Spindash to move";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "19F";
+ }
+
+ 151
+ {
+ title = "Air Bobbing (Adjustable)";
+ prefix = "(151)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Spindash to move";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "19F";
+ }
+
+ 152
+ {
+ title = "Reverse Air Bobbing (Adjustable)";
+ prefix = "(152)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Spindash to move";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "19F";
+ }
+
+ 160
+ {
+ title = "Floating, Bobbing";
+ prefix = "(160)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "4019F";
+ }
+
+ 190
+ {
+ title = "Rising Platform, Solid, Opaque";
+ prefix = "(190)";
+ flags2text = "[1] Sink when stepped on";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Spindash to move";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "19F";
+ }
+
+ 191
+ {
+ title = "Rising Platform, Solid, Opaque, No Shadow";
+ prefix = "(191)";
+ flags2text = "[1] Sink when stepped on";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Spindash to move";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "1DF";
+ }
+
+ 192
+ {
+ title = "Rising Platform, Solid, Translucent";
+ prefix = "(192)";
+ flags2text = "[1] Sink when stepped on";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Spindash to move";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "195F";
+ }
+
+ 193
+ {
+ title = "Rising Platform, Solid, Invisible";
+ prefix = "(193)";
+ flags2text = "[1] Sink when stepped on";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Spindash to move";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "47";
+ }
+
+ 194
+ {
+ title = "Rising Platform, Intangible from Bottom, Opaque";
+ prefix = "(194)";
+ flags2text = "[1] Sink when stepped on";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Spindash, no shadow";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "200841F";
+ flags643dfloorflagsadd = "40";
+ }
+
+ 195
+ {
+ title = "Rising Platform, Intangible from Bottom, Translucent";
+ prefix = "(195)";
+ flags2text = "[1] Sink when stepped on";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Spindash, no shadow";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "2009D1F";
+ flags643dfloorflagsadd = "40";
+ }
+ }
+
+ fofcrumbling
+ {
+ title = "FOF (crumbling)";
+
+ 170
+ {
+ title = "Crumbling, Respawn";
+ prefix = "(170)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "10019F";
+ }
+
+ 171
+ {
+ title = "Crumbling, No Respawn";
+ prefix = "(171)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "80019F";
+ }
+
+ 172
+ {
+ title = "Crumbling, Respawn, Intangible from Bottom";
+ prefix = "(172)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Don't cast shadow";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "210841F";
+ flags643dfloorflagsadd = "40";
+ }
+
+ 173
+ {
+ title = "Crumbling, No Respawn, Intangible from Bottom";
+ prefix = "(173)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Don't cast shadow";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "218841F";
+ flags643dfloorflagsadd = "40";
+ }
+
+ 174
+ {
+ title = "Crumbling, Respawn, Int. from Bottom, Translucent";
+ prefix = "(174)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Don't cast shadow";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "210959F";
+ flags643dfloorflagsadd = "40";
+ }
+
+ 175
+ {
+ title = "Crumbling, No Respawn, Int. from Bottom, Translucent";
+ prefix = "(175)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Don't cast shadow";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "218959F";
+ flags643dfloorflagsadd = "40";
+ }
+
+ 176
+ {
+ title = "Crumbling, Respawn, Floating, Bobbing";
+ prefix = "(176)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Spindash to move";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "14019F";
+ }
+
+ 177
+ {
+ title = "Crumbling, No Respawn, Floating, Bobbing";
+ prefix = "(177)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Spindash to move";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "1C019F";
+ }
+
+ 178
+ {
+ title = "Crumbling, Respawn, Floating";
+ prefix = "(178)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "14019F";
+ }
+
+ 179
+ {
+ title = "Crumbling, No Respawn, Floating";
+ prefix = "(179)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "1C019F";
+ }
+
+ 180
+ {
+ title = "Crumbling, Respawn, Air Bobbing";
+ prefix = "(180)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags64text = "[6] Spindash to move";
+ flags128text = "[7] Only block non-players";
+ 3dfloor = true;
+ 3dfloorflags = "10019F";
+ }
+ }
+
+ fofspecial
+ {
+ title = "FOF (special)";
+
+ 200
+ {
+ title = "Light Block";
+ prefix = "(200)";
+ 3dfloor = true;
+ 3dfloorflags = "20201";
+ }
+
+ 201
+ {
+ title = "Half Light Block";
+ prefix = "(201)";
+ 3dfloor = true;
+ 3dfloorflags = "201";
+ }
+
+ 202
+ {
+ title = "Fog Block";
+ prefix = "(202)";
+ 3dfloor = true;
+ 3dfloorflags = "3EF19";
+ }
+
+ 250
+ {
+ title = "Mario Block";
+ prefix = "(250)";
+ flags32text = "[5] Invisible block";
+ flags64text = "[6] Brick block";
+ 3dfloor = true;
+ 3dfloorflags = "40019F";
+ }
+
+ 251
+ {
+ title = "Thwomp Block";
+ prefix = "(251)";
+ flags512text = "[9] Custom crushing sound";
+ flags1024text = "[10] Custom speed";
+ 3dfloor = true;
+ 3dfloorflags = "19F";
+ }
+
+ 252
+ {
+ title = "Shatter Block";
+ prefix = "(252)";
+ flags8text = "[3] Slope skew sides";
+ flags64text = "[6] Shatter only from below";
+ flags512text = "[9] Shattered by pushables";
+ flags1024text = "[10] Trigger linedef executor";
+ 3dfloor = true;
+ 3dfloorflags = "8800019";
+ flags643dfloorflagsadd = "200006";
+ }
+
+ 253
+ {
+ title = "Shatter Block, Translucent";
+ prefix = "(253)";
+ flags8text = "[3] Slope skew sides";
+ flags512text = "[9] Shattered by pushables";
+ flags1024text = "[10] Trigger linedef executor";
+ 3dfloor = true;
+ 3dfloorflags = "8801019";
+ }
+
+ 254
+ {
+ title = "Bustable Block";
+ prefix = "(254)";
+ flags8text = "[3] Slope skew sides";
+ flags64text = "[6] Strong characters only";
+ flags128text = "[7] Only block non-players";
+ flags512text = "[9] Shattered by pushables";
+ flags1024text = "[10] Trigger linedef executor";
+ 3dfloor = true;
+ 3dfloorflags = "80001F";
+ flags643dfloorflagsadd = "20000000";
+ }
+
+ 255
+ {
+ title = "Spin-Bustable Block";
+ prefix = "(255)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags128text = "[7] Only block non-players";
+ flags512text = "[9] Shattered by pushables";
+ flags1024text = "[10] Trigger linedef executor";
+ 3dfloor = true;
+ 3dfloorflags = "1080001F";
+ }
+
+ 256
+ {
+ title = "Spin-Bustable Block, Translucent";
+ prefix = "(256)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Only block player";
+ flags128text = "[7] Only block non-players";
+ flags512text = "[9] Shattered by pushables";
+ flags1024text = "[10] Trigger linedef executor";
+ 3dfloor = true;
+ 3dfloorflags = "1080101F";
+ }
+
+ 257
+ {
+ title = "Quicksand";
+ prefix = "(257)";
+ flags8text = "[3] Slope skew sides";
+ flags1024text = "[10] Ripple effect";
+ 3dfloor = true;
+ 3dfloorflags = "1008219";
+ flags10243dfloorflagsadd = "40000000";
+ }
+
+ 258
+ {
+ title = "Laser";
+ prefix = "(258)";
+ flags8text = "[3] Slope skew sides";
+ flags32text = "[5] Don't damage bosses";
+ 3dfloor = true;
+ 3dfloorflags = "959";
+ }
+
+ 259
+ {
+ title = "Custom FOF";
+ prefix = "(259)";
+ flags32text = "[5] Only block player";
+ flags128text = "[7] Only block non-players";
+ flags512text = "[9] Shattered by pushables";
+ flags1024text = "[10] Trigger linedef executor";
+ 3dfloor = true;
+ 3dfloorcustom = true;
+ }
+ }
+
+ linedeftrigger
+ {
+ title = "Linedef Executor Trigger";
+
+ 300
+ {
+ title = "Continuous";
+ prefix = "(300)";
+ }
+
+ 301
+ {
+ title = "Each Time";
+ prefix = "(301)";
+ flags16384text = "[14] Also trigger on exit";
+ }
+
+ 302
+ {
+ title = "Once";
+ prefix = "(302)";
+ }
+
+ 303
+ {
+ title = "Ring Count - Continuous";
+ prefix = "(303)";
+ flags2text = "[1] Rings greater or equal";
+ flags64text = "[6] Rings less or equal";
+ flags512text = "[9] Consider all players";
+ }
+
+ 304
+ {
+ title = "Ring Count - Once";
+ prefix = "(304)";
+ flags2text = "[1] Rings greater or equal";
+ flags64text = "[6] Rings less or equal";
+ flags512text = "[9] Consider all players";
+ }
+
+ 305
+ {
+ title = "Character Ability - Continuous";
+ prefix = "(305)";
+ }
+
+ 306
+ {
+ title = "Character Ability - Each Time";
+ prefix = "(306)";
+ flags16384text = "[14] Also trigger on exit";
+ }
+
+ 307
+ {
+ title = "Character Ability - Once";
+ prefix = "(307)";
+ }
+
+ 308
+ {
+ title = "Race Only - Once";
+ prefix = "(308)";
+ }
+
+ 309
+ {
+ title = "CTF Red Team - Continuous";
+ prefix = "(309)";
+ }
+
+ 310
+ {
+ title = "CTF Red Team - Each Time";
+ prefix = "(310)";
+ flags16384text = "[14] Also trigger on exit";
+ }
+
+ 311
+ {
+ title = "CTF Blue Team - Continuous";
+ prefix = "(311)";
+ }
+
+ 312
+ {
+ title = "CTF Blue Team - Each Time";
+ prefix = "(312)";
+ flags16384text = "[14] Also trigger on exit";
+ }
+
+ 313
+ {
+ title = "No More Enemies - Once";
+ prefix = "(313)";
+ }
+
+ 314
+ {
+ title = "Number of Pushables - Continuous";
+ prefix = "(314)";
+ flags64text = "[6] Number greater or equal";
+ flags512text = "[9] Number less";
+ }
+
+ 315
+ {
+ title = "Number of Pushables - Once";
+ prefix = "(315)";
+ flags64text = "[6] Number greater or equal";
+ flags512text = "[9] Number less";
+ }
+
+ 317
+ {
+ title = "Condition Set Trigger - Continuous";
+ prefix = "(317)";
+ }
+
+ 318
+ {
+ title = "Condition Set Trigger - Once";
+ prefix = "(318)";
+ }
+
+ 319
+ {
+ title = "Unlockable - Continuous";
+ prefix = "(319)";
+ }
+
+ 320
+ {
+ title = "Unlockable - Once";
+ prefix = "(320)";
+ }
+
+ 321
+ {
+ title = "Trigger After X Calls - Continuous";
+ prefix = "(321)";
+ flags64text = "[6] Trigger more than once";
+
+ }
+
+ 322
+ {
+ title = "Trigger After X Calls - Each Time";
+ prefix = "(322)";
+ flags64text = "[6] Trigger more than once";
+ }
+
+ 323
+ {
+ title = "NiGHTSerize - Each Time";
+ prefix = "(323)";
+ flags2text = "[1] Mare >= Front X Offset";
+ flags8text = "[3] Run only if player is NiGHTS";
+ flags16text = "[4] Count from lowest of players";
+ flags32text = "[5] Lap <= Front Y Offset";
+ flags64text = "[6] Mare <= Front X Offset";
+ flags128text = "[7] Lap >= Front Y Offset";
+ flags256text = "[8] Count laps from Bonus Time";
+ flags512text = "[9] Count from triggering player";
+ flags16384text = "[14] Run if no more mares";
+ flags32768text = "[15] Run if player is not NiGHTS";
+ }
+
+ 324
+ {
+ title = "NiGHTSerize - Once";
+ flags2text = "[1] Mare >= Front X Offset";
+ flags8text = "[3] Run only if player is NiGHTS";
+ flags16text = "[4] Count from lowest of players";
+ flags32text = "[5] Lap <= Front Y Offset";
+ flags64text = "[6] Mare <= Front X Offset";
+ flags128text = "[7] Lap >= Front Y Offset";
+ flags256text = "[8] Count laps from Bonus Time";
+ flags512text = "[9] Count from triggering player";
+ flags16384text = "[14] Run if no more mares";
+ flags32768text = "[15] Run if player is not NiGHTS";
+ prefix = "(324)";
+ }
+
+ 325
+ {
+ title = "De-NiGHTSerize - Each Time";
+ flags2text = "[1] Mare >= Front X Offset";
+ flags8text = "[3] Run if anyone is NiGHTS";
+ flags16text = "[4] Count from lowest of players";
+ flags32text = "[5] Lap <= Front Y Offset";
+ flags64text = "[6] Mare <= Front X Offset";
+ flags128text = "[7] Lap >= Front Y Offset";
+ flags256text = "[8] Count laps from Bonus Time";
+ flags512text = "[9] Count from triggering player";
+ flags32768text = "[15] Run if no one is NiGHTS";
+ prefix = "(325)";
+ }
+
+ 326
+ {
+ title = "De-NiGHTSerize - Once";
+ flags2text = "[1] Mare >= Front X Offset";
+ flags8text = "[3] Run if anyone is NiGHTS";
+ flags16text = "[4] Count from lowest of players";
+ flags32text = "[5] Lap <= Front Y Offset";
+ flags64text = "[6] Mare <= Front X Offset";
+ flags128text = "[7] Lap >= Front Y Offset";
+ flags256text = "[8] Count laps from Bonus Time";
+ flags512text = "[9] Count from triggering player";
+ flags32768text = "[15] Run if no one is NiGHTS";
+ prefix = "(326)";
+ }
+
+ 327
+ {
+ title = "NiGHTS Lap - Each Time";
+ flags2text = "[1] Mare >= Front X Offset";
+ flags16text = "[4] Count from lowest of players";
+ flags32text = "[5] Lap <= Front Y Offset";
+ flags64text = "[6] Mare <= Front X Offset";
+ flags128text = "[7] Lap >= Front Y Offset";
+ flags256text = "[8] Count laps from Bonus Time";
+ flags512text = "[9] Count from triggering player";
+ prefix = "(327)";
+ }
+
+ 328
+ {
+ title = "NiGHTS Lap - Once";
+ flags2text = "[1] Mare >= Front X Offset";
+ flags16text = "[4] Count from lowest of players";
+ flags32text = "[5] Lap <= Front Y Offset";
+ flags64text = "[6] Mare <= Front X Offset";
+ flags128text = "[7] Lap >= Front Y Offset";
+ flags256text = "[8] Count laps from Bonus Time";
+ flags512text = "[9] Count from triggering player";
+ prefix = "(328)";
+ }
+
+ 329
+ {
+ title = "Ideya Capture Touch - Each Time";
+ flags2text = "[1] Mare >= Front X Offset";
+ flags8text = "[3] Run regardless of spheres";
+ flags16text = "[4] Count from lowest of players";
+ flags32text = "[5] Lap <= Front Y Offset";
+ flags64text = "[6] Mare <= Front X Offset";
+ flags128text = "[7] Lap >= Front Y Offset";
+ flags256text = "[8] Count laps from Bonus Time";
+ flags512text = "[9] Count from triggering player";
+ flags16384text = "[14] Only if not enough spheres";
+ flags32768text = "[15] Run when entering Capture";
+ prefix = "(329)";
+ }
+
+ 330
+ {
+ title = "Ideya Capture Touch - Once";
+ flags2text = "[1] Mare >= Front X Offset";
+ flags8text = "[3] Run regardless of spheres";
+ flags16text = "[4] Count from lowest of players";
+ flags32text = "[5] Lap <= Front Y Offset";
+ flags64text = "[6] Mare <= Front X Offset";
+ flags128text = "[7] Lap >= Front Y Offset";
+ flags256text = "[8] Count laps from Bonus Time";
+ flags512text = "[9] Count from triggering player";
+ flags16384text = "[14] Only if not enough spheres";
+ flags32768text = "[15] Run when entering Capture";
+ prefix = "(330)";
+ }
+
+ 331
+ {
+ title = "Player Skin - Continuous";
+ flags64text = "[6] Disable for this skin";
+ prefix = "(331)";
+ }
+
+ 332
+ {
+ title = "Player Skin - Each Time";
+ flags64text = "[6] Disable for this skin";
+ prefix = "(332)";
+ }
+
+ 333
+ {
+ title = "Player Skin - Once";
+ flags64text = "[6] Disable for this skin";
+ prefix = "(333)";
+ }
+
+ 399
+ {
+ title = "Level Load";
+ prefix = "(399)";
+ }
+ }
+
+ linedefexecsector
+ {
+ title = "Linedef Executor (sector)";
+
+ 400
+ {
+ title = "Set Tagged Sector's Floor Height/Texture";
+ prefix = "(400)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Keep floor flat";
+ }
+
+ 401
+ {
+ title = "Set Tagged Sector's Ceiling Height/Texture";
+ prefix = "(401)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 402
+ {
+ title = "Set Tagged Sector's Light Level";
+ prefix = "(402)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 409
+ {
+ title = "Change Tagged Sector's Tag";
+ prefix = "(409)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 410
+ {
+ title = "Change Front Sector's Tag";
+ prefix = "(410)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 416
+ {
+ title = "Start Adjustable Flickering Light";
+ prefix = "(416)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Second level from back";
+ }
+
+ 417
+ {
+ title = "Start Adjustable Pulsating Light";
+ prefix = "(417)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Second level from back";
+ }
+
+ 418
+ {
+ title = "Start Adjustable Blinking Light (unsynchronized)";
+ prefix = "(418)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Second level from back";
+ }
+
+ 419
+ {
+ title = "Start Adjustable Blinking Light (synchronized)";
+ prefix = "(419)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Second level from back";
+ }
+
+ 420
+ {
+ title = "Fade Light Level";
+ prefix = "(420)";
+ flags8text = "[3] Set delay by backside sector";
+ flags16text = "[4] Set params by X/Y offsets";
+ flags512text = "[9] Speed = Tic Duration";
+ flags1024text = "[10] Override existing fade";
+ }
+
+ 421
+ {
+ title = "Stop Lighting Effect";
+ prefix = "(421)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 435
+ {
+ title = "Change Plane Scroller Direction";
+ prefix = "(435)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+ }
+
+ linedefexecplane
+ {
+ title = "Linedef Executor (plane movement)";
+
+ 403
+ {
+ title = "Move Tagged Sector's Floor";
+ prefix = "(403)";
+ flags2text = "[1] Trigger linedef executor";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Change floor flat";
+ }
+
+ 404
+ {
+ title = "Move Tagged Sector's Ceiling";
+ prefix = "(404)";
+ flags2text = "[1] Trigger linedef executor";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Change ceiling flat";
+ }
+
+ 405
+ {
+ title = "Move Floor According to Front Texture Offsets";
+ prefix = "(405)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Move instantly";
+ }
+
+ 407
+ {
+ title = "Move Ceiling According to Front Texture Offsets";
+ prefix = "(407)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Move instantly";
+ }
+
+ 411
+ {
+ title = "Stop Plane Movement";
+ prefix = "(411)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 428
+ {
+ title = "Start Platform Movement";
+ prefix = "(428)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Move upwards at start";
+ }
+
+ 429
+ {
+ title = "Crush Ceiling Once";
+ prefix = "(429)";
+ flags8text = "[3] Set delay by backside sector";
+ flags512text = "[9] Double, constant speed";
+ }
+
+ 430
+ {
+ title = "Crush Floor Once";
+ prefix = "(430)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 431
+ {
+ title = "Crush Floor and Ceiling Once";
+ prefix = "(431)";
+ flags8text = "[3] Set delay by backside sector";
+ flags512text = "[9] Double, constant speed";
+ }
+ }
+
+ linedefexecplayer
+ {
+ title = "Linedef Executor (player/object)";
+
+ 412
+ {
+ title = "Teleporter";
+ prefix = "(412)";
+ flags2text = "[1] Silent";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Retain angle";
+ flags256text = "[8] Relative, silent";
+ flags512text = "[9] Retain momentum";
+ }
+
+ 425
+ {
+ title = "Change Object State";
+ prefix = "(425)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 426
+ {
+ title = "Stop Object";
+ prefix = "(426)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Teleport to sector center";
+ }
+
+ 427
+ {
+ title = "Award Score";
+ prefix = "(427)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 432
+ {
+ title = "Enable/Disable 2D Mode";
+ prefix = "(432)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Return to 3D";
+ }
+
+ 433
+ {
+ title = "Enable/Disable Gravity Flip";
+ prefix = "(433)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Return to normal";
+ }
+
+ 434
+ {
+ title = "Award Power-Up";
+ prefix = "(434)";
+ flags2text = "[1] Use back upper texture";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] No time limit";
+ }
+
+ 437
+ {
+ title = "Disable Player Control";
+ prefix = "(437)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Allow jumping";
+ }
+
+ 438
+ {
+ title = "Change Object Size";
+ prefix = "(438)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 442
+ {
+ title = "Change Object Type State";
+ prefix = "(442)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 457
+ {
+ title = "Track Object's Angle";
+ prefix = "(457)";
+ flags8text = "[3] Set delay by backside sector";
+ flags128text = "[7] Don't stop after first fail";
+ }
+
+ 458
+ {
+ title = "Stop Tracking Object's Angle";
+ prefix = "(458)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 460
+ {
+ title = "Award Rings";
+ prefix = "(460)";
+ }
+
+ 461
+ {
+ title = "Spawn Object";
+ prefix = "(461)";
+ flags64text = "[6] Spawn inside a range";
+ }
+ }
+
+ linedefexecmisc
+ {
+ title = "Linedef Executor (misc.)";
+
+ 413
+ {
+ title = "Change Music";
+ prefix = "(413)";
+ flags2text = "[1] Keep after death";
+ flags8text = "[3] Set delay by backside sector";
+ flags32text = "[5] Seek to current song position";
+ flags64text = "[6] For everyone";
+ flags128text = "[7] Fade to custom volume";
+ flags512text = "[9] Don't loop";
+ flags16384text = "[14] Force music reload";
+ }
+
+ 414
+ {
+ title = "Play Sound Effect";
+ prefix = "(414)";
+ flags2text = "[1] From calling sector";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] From nowhere for triggerer";
+ flags512text = "[9] For everyone";
+ flags1024text = "[10] From tagged sectors";
+ }
+
+ 415
+ {
+ title = "Run Script";
+ prefix = "(415)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 422
+ {
+ title = "Switch to Cut-Away View";
+ prefix = "(422)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Adjust pitch";
+ }
+
+ 423
+ {
+ title = "Change Sky";
+ prefix = "(423)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] For everyone";
+ }
+
+ 424
+ {
+ title = "Change Weather";
+ prefix = "(424)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] For everyone";
+ }
+
+ 436
+ {
+ title = "Shatter FOF";
+ prefix = "(436)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 439
+ {
+ title = "Change Tagged Linedef's Textures";
+ prefix = "(439)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Only existing";
+ }
+
+ 440
+ {
+ title = "Start Metal Sonic Race";
+ prefix = "(440)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 441
+ {
+ title = "Condition Set Trigger";
+ prefix = "(441)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 443
+ {
+ title = "Call Lua Function";
+ prefix = "(443)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 444
+ {
+ title = "Earthquake";
+ prefix = "(444)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+
+ 445
+ {
+ title = "Make FOF Disappear/Reappear";
+ prefix = "(445)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Reappear";
+ }
+
+ 446
+ {
+ title = "Make FOF Crumble";
+ prefix = "(446)";
+ flags2text = "[1] Flags determine respawn";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Don't respawn";
+ }
+
+ 447
+ {
+ title = "Change Tagged Sector's Colormap";
+ prefix = "(447)";
+ flags8text = "[3] Set delay by backside sector";
+ flags16text = "[4] Front X/Y = Alpha";
+ flags32text = "[5] Subtract Red value";
+ flags64text = "[6] Subtract Green value";
+ flags128text = "[7] Subtract Blue value";
+ flags256text = "[8] Calc relative values";
+ flags32768text = "[15] Use back side colormap";
+ }
+
+ 448
+ {
+ title = "Change Skybox";
+ prefix = "(448)";
+ flags2text = "[1] Change centerpoint";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] For everyone";
+ flags512text = "[9] Don't change viewpoint";
+ }
+
+ 450
+ {
+ title = "Execute Linedef Executor (specific tag)";
+ prefix = "(450)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 451
+ {
+ title = "Execute Linedef Executor (random tag in range)";
+ prefix = "(451)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 452
+ {
+ title = "Set FOF Translucency";
+ prefix = "(452)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Do not handle FF_TRANS";
+ flags256text = "[8] Set relative to current val";
+ }
+
+ 453
+ {
+ title = "Fade FOF";
+ prefix = "(453)";
+ flags2text = "[1] Do not handle FF_EXISTS";
+ flags8text = "[3] Set delay by backside sector";
+ flags32text = "[5] No collision during fade";
+ flags64text = "[6] Do not handle FF_TRANS";
+ flags128text = "[7] Do not handle lighting";
+ flags256text = "[8] Set relative to current val";
+ flags512text = "[9] Speed = Tic Duration";
+ flags1024text = "[10] Override existing fade";
+ flags16384text = "[14] Do not handle collision";
+ flags32768text = "[15] Use exact alpha in OGL";
+ }
+
+ 454
+ {
+ title = "Stop Fading FOF";
+ prefix = "(454)";
+ flags2text = "[1] Do not finalize collision";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 455
+ {
+ title = "Fade Tagged Sector's Colormap";
+ prefix = "(455)";
+ flags8text = "[3] Set delay by backside sector";
+ flags16text = "[4] Front X/Y = Alpha";
+ flags32text = "[5] Subtract Red value";
+ flags64text = "[6] Subtract Green value";
+ flags128text = "[7] Subtract Blue value";
+ flags256text = "[8] Calc relative values";
+ flags512text = "[9] Speed = Tic Duration";
+ flags1024text = "[10] Override existing fade";
+ flags16384text = "[14] Fade from invisible black";
+ flags32768text = "[15] Use back side colormap";
+ }
+
+ 456
+ {
+ title = "Stop Fading Tagged Sector's Colormap";
+ prefix = "(456)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 459
+ {
+ title = "Control Text Prompt";
+ prefix = "(459)";
+ flags2text = "[1] Close text prompt";
+ flags8text = "[3] Set delay by backside sector";
+ flags32text = "[5] Run executor tag on close";
+ flags64text = "[6] For everyone";
+ flags128text = "[7] Do not block controls";
+ flags256text = "[8] Do not freeze time";
+ flags32768text = "[15] Find prompt by name";
+ }
+ }
+
+ linedefexecpoly
+ {
+ title = "Linedef Executor (polyobject)";
+
+ 480
+ {
+ title = "Door Slide";
+ prefix = "(480)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 481
+ {
+ title = "Door Swing";
+ prefix = "(481)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 482
+ {
+ title = "Move";
+ prefix = "(482)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 483
+ {
+ title = "Move, Override";
+ prefix = "(483)";
+ flags8text = "[3] Set delay by backside sector";
+ }
+
+ 484
+ {
+ title = "Rotate Right";
+ prefix = "(484)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Don't turn players";
+ flags512text = "[9] Turn all objects";
+ }
+
+ 485
+ {
+ title = "Rotate Right, Override";
+ prefix = "(485)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Don't turn players";
+ flags512text = "[9] Turn all objects";
+ }
+
+ 486
+ {
+ title = "Rotate Left";
+ prefix = "(486)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Don't turn players";
+ flags512text = "[9] Turn all objects";
+ }
+
+ 487
+ {
+ title = "Rotate Left, Override";
+ prefix = "(487)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Don't turn players";
+ flags512text = "[9] Turn all objects";
+ }
+
+ 488
+ {
+ title = "Move by Waypoints";
+ prefix = "(488)";
+ flags8text = "[3] Set delay by backside sector";
+ flags32text = "[5] Reverse order";
+ flags128text = "[7] There and back";
+ flags256text = "[8] Return when done";
+ flags512text = "[9] Loop movement";
+ }
+
+ 489
+ {
+ title = "Turn Invisible, Intangible";
+ prefix = "(489)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Only invisible";
+ }
+
+ 490
+ {
+ title = "Turn Visible, Tangible";
+ prefix = "(490)";
+ flags8text = "[3] Set delay by backside sector";
+ flags64text = "[6] Only visible";
+ }
+
+ 491
+ {
+ title = "Set Translucency";
+ prefix = "(491)";
+ flags8text = "[3] Set delay by backside sector";
+ flags16text = "[4] Set raw alpha by Front X";
+ flags256text = "[8] Calc relative values";
+ }
+
+ 492
+ {
+ title = "Fade Translucency";
+ prefix = "(492)";
+ flags8text = "[3] Set delay by backside sector";
+ flags16text = "[4] Set raw alpha by Front X";
+ flags32text = "[5] No collision during fade";
+ flags256text = "[8] Calc relative values";
+ flags512text = "[9] Speed = Tic Duration";
+ flags1024text = "[10] Override existing fade";
+ flags16384text = "[14] Do not handle collision";
+ }
+ }
+
+ wallscroll
+ {
+ title = "Wall Scrolling";
+
+ 500
+ {
+ title = "Scroll Wall Front Side Left";
+ prefix = "(500)";
+ }
+
+ 501
+ {
+ title = "Scroll Wall Front Side Right";
+ prefix = "(501)";
+ }
+
+ 502
+ {
+ title = "Scroll Wall According to Linedef";
+ prefix = "(502)";
+ }
+
+ 503
+ {
+ title = "Scroll Wall According to Linedef (Accelerative)";
+ prefix = "(503)";
+ }
+
+ 504
+ {
+ title = "Scroll Wall According to Linedef (Displacement)";
+ prefix = "(504)";
+ }
+
+ 505
+ {
+ title = "Scroll Texture by Front Side Offsets";
+ prefix = "(505)";
+ }
+
+ 506
+ {
+ title = "Scroll Texture by Back Side Offsets";
+ prefix = "(506)";
+ }
+ }
+
+ planescroll
+ {
+ title = "Plane Scrolling";
+
+ 510
+ {
+ title = "Scroll Floor Texture";
+ prefix = "(510)";
+ }
+
+ 511
+ {
+ title = "Scroll Floor Texture (Accelerative)";
+ prefix = "(511)";
+ }
+
+ 512
+ {
+ title = "Scroll Floor Texture (Displacement)";
+ prefix = "(512)";
+ }
+
+ 513
+ {
+ title = "Scroll Ceiling Texture";
+ prefix = "(513)";
+ }
+
+ 514
+ {
+ title = "Scroll Ceiling Texture (Accelerative)";
+ prefix = "(514)";
+ }
+
+ 515
+ {
+ title = "Scroll Ceiling Texture (Displacement)";
+ prefix = "(515)";
+ }
+
+ 520
+ {
+ title = "Carry Objects on Floor";
+ prefix = "(520)";
+ }
+
+ 521
+ {
+ title = "Carry Objects on Floor (Accelerative)";
+ prefix = "(521)";
+ flags64text = "[6] Even across edges";
+ }
+
+ 522
+ {
+ title = "Carry Objects on Floor (Displacement)";
+ prefix = "(522)";
+ }
+
+ 523
+ {
+ title = "Carry Objects on Ceiling";
+ prefix = "(523)";
+ flags64text = "[6] Even across edges";
+ }
+
+ 524
+ {
+ title = "Carry Objects on Ceiling (Accelerative)";
+ prefix = "(524)";
+ }
+
+ 525
+ {
+ title = "Carry Objects on Ceiling (Displacement)";
+ prefix = "(525)";
+ }
+
+ 530
+ {
+ title = "Scroll Floor Texture and Carry Objects";
+ prefix = "(530)";
+ flags64text = "[6] Even across edges";
+ }
+
+ 531
+ {
+ title = "Scroll Floor Texture and Carry Objects (Accelerative)";
+ prefix = "(531)";
+ }
+
+ 532
+ {
+ title = "Scroll Floor Texture and Carry Objects (Displacement)";
+ prefix = "(532)";
+ }
+
+ 533
+ {
+ title = "Scroll Ceiling Texture and Carry Objects";
+ prefix = "(533)";
+ flags64text = "[6] Even across edges";
+ }
+
+ 534
+ {
+ title = "Scroll Ceiling Texture and Carry Objects (Accelerative)";
+ prefix = "(534)";
+ }
+
+ 535
+ {
+ title = "Scroll Ceiling Texture and Carry Objects (Displacement)";
+ prefix = "(535)";
+ }
+ }
+
+ pusher
+ {
+ title = "Pusher";
+
+ 541
+ {
+ title = "Wind";
+ prefix = "(541)";
+ flags512text = "[9] Player slides";
+ flags64text = "[6] Even across edges";
+ }
+
+ 542
+ {
+ title = "Upwards Wind";
+ prefix = "(542)";
+ flags512text = "[9] Player slides";
+ flags64text = "[6] Even across edges";
+ }
+
+ 543
+ {
+ title = "Downwards Wind";
+ prefix = "(543)";
+ flags512text = "[9] Player slides";
+ flags64text = "[6] Even across edges";
+ }
+
+ 544
+ {
+ title = "Current";
+ prefix = "(544)";
+ flags512text = "[9] Player slides";
+ flags64text = "[6] Even across edges";
+ }
+
+ 545
+ {
+ title = "Upwards Current";
+ prefix = "(545)";
+ flags512text = "[9] Player slides";
+ flags64text = "[6] Even across edges";
+ }
+
+ 546
+ {
+ title = "Downwards Current";
+ prefix = "(546)";
+ flags512text = "[9] Player slides";
+ flags64text = "[6] Even across edges";
+ }
+
+ 547
+ {
+ title = "Push/Pull";
+ prefix = "(547)";
+ }
+ }
+
+ light
+ {
+ title = "Lighting";
+
+ 600
+ {
+ title = "Floor Lighting";
+ prefix = "(600)";
+ }
+
+ 601
+ {
+ title = "Ceiling Lighting";
+ prefix = "(601)";
+ }
+
+ 602
+ {
+ title = "Adjustable Pulsating Light";
+ prefix = "(602)";
+ }
+
+ 603
+ {
+ title = "Adjustable Flickering Light";
+ prefix = "(603)";
+ }
+
+ 604
+ {
+ title = "Adjustable Blinking Light (unsynchronized)";
+ prefix = "(604)";
+ }
+
+ 605
+ {
+ title = "Adjustable Blinking Light (synchronized)";
+ prefix = "(605)";
+ }
+
+ 606
+ {
+ title = "Colormap";
+ prefix = "(606)";
+ }
+ }
+
+ slope
+ {
+ title = "Slope";
+
+ 700
+ {
+ title = "Slope Frontside Floor";
+ prefix = "(700)";
+ flags2048text = "[11] No physics";
+ flags4096text = "[12] Dynamic";
+ slope = "regular";
+ slopeargs = 1;
+ }
+
+ 701
+ {
+ title = "Slope Frontside Ceiling";
+ prefix = "(701)";
+ flags2048text = "[11] No physics";
+ flags4096text = "[12] Dynamic";
+ slope = "regular";
+ slopeargs = 2;
+ }
+
+ 702
+ {
+ title = "Slope Frontside Floor and Ceiling";
+ prefix = "(702)";
+ flags2048text = "[11] No physics";
+ flags4096text = "[12] Dynamic";
+ slope = "regular";
+ slopeargs = 3;
+ }
+
+ 703
+ {
+ title = "Slope Frontside Floor and Backside Ceiling";
+ prefix = "(703)";
+ flags2048text = "[11] No physics";
+ flags4096text = "[12] Dynamic";
+ slope = "regular";
+ slopeargs = 9;
+ }
+
+ 704
+ {
+ title = "Slope Frontside Floor by 3 Tagged Vertex Things";
+ prefix = "(704)";
+ flags2048text = "[11] No physics";
+ flags4096text = "[12] Dynamic";
+ flags8192text = "[13] Use tag and offsets";
+ slope = "vertex";
+ slopeargs = 0;
+ }
+
+ 705
+ {
+ title = "Slope Frontside Ceiling by 3 Tagged Vertex Things";
+ prefix = "(705)";
+ flags2048text = "[11] No physics";
+ flags4096text = "[12] Dynamic";
+ flags8192text = "[13] Use tag and offsets";
+ slope = "vertex";
+ slopeargs = 1;
+ }
+
+ 710
+ {
+ title = "Slope Backside Floor";
+ prefix = "(710)";
+ flags2048text = "[11] No physics";
+ flags4096text = "[12] Dynamic";
+ slope = "regular";
+ slopeargs = 4;
+ }
+
+ 711
+ {
+ title = "Slope Backside Ceiling";
+ prefix = "(711)";
+ flags2048text = "[11] No physics";
+ flags4096text = "[12] Dynamic";
+ slope = "regular";
+ slopeargs = 8;
+ }
+
+ 712
+ {
+ title = "Slope Backside Floor and Ceiling";
+ prefix = "(712)";
+ flags2048text = "[11] No physics";
+ flags4096text = "[12] Dynamic";
+ slope = "regular";
+ slopeargs = 12;
+ }
+
+ 713
+ {
+ title = "Slope Backside Floor and Frontside Ceiling";
+ prefix = "(713)";
+ flags2048text = "[11] No physics";
+ flags4096text = "[12] Dynamic";
+ slope = "regular";
+ slopeargs = 6;
+ }
+
+ 714
+ {
+ title = "Slope Backside Floor by 3 Tagged Vertex Things";
+ prefix = "(714)";
+ flags2048text = "[11] No physics";
+ flags4096text = "[12] Dynamic";
+ flags8192text = "[13] Use tag and offsets";
+ slope = "vertex";
+ slopeargs = 2;
+ }
+
+ 715
+ {
+ title = "Slope Backside Ceiling by 3 Tagged Vertex Things";
+ prefix = "(715)";
+ flags2048text = "[11] No physics";
+ flags4096text = "[12] Dynamic";
+ flags8192text = "[13] Use tag and offsets";
+ slope = "vertex";
+ slopeargs = 3;
+ }
+
+ 720
+ {
+ title = "Copy Frontside Floor Slope from Line Tag";
+ prefix = "(720)";
+ slope = "copy";
+ slopeargs = 1;
+ }
+
+ 721
+ {
+ title = "Copy Frontside Ceiling Slope from Line Tag";
+ prefix = "(721)";
+ slope = "copy";
+ slopeargs = 2;
+ }
+
+ 722
+ {
+ title = "Copy Frontside Floor and Ceiling Slope from Line Tag";
+ prefix = "(722)";
+ slope = "copy";
+ slopeargs = 3;
+ }
+
+ 799
+ {
+ title = "Set Tagged Dynamic Slope Vertex to Front Sector Height";
+ prefix = "(799)";
+ }
+ }
+
+ transwall
+ {
+ title = "Translucent Wall";
+
+ 900
+ {
+ title = "90% Opaque";
+ prefix = "(900)";
+ }
+
+ 901
+ {
+ title = "80% Opaque";
+ prefix = "(901)";
+ }
+
+ 902
+ {
+ title = "70% Opaque";
+ prefix = "(902)";
+ }
+
+ 903
+ {
+ title = "60% Opaque";
+ prefix = "(903)";
+ }
+
+ 904
+ {
+ title = "50% Opaque";
+ prefix = "(904)";
+ }
+
+ 905
+ {
+ title = "40% Opaque";
+ prefix = "(905)";
+ }
+
+ 906
+ {
+ title = "30% Opaque";
+ prefix = "(906)";
+ }
+
+ 907
+ {
+ title = "20% Opaque";
+ prefix = "(907)";
+ }
+
+ 908
+ {
+ title = "10% Opaque";
+ prefix = "(908)";
+ }
+
+ 909
+ {
+ title = "Fog Wall";
+ prefix = "(909)";
+ }
+ }
+}
+
+
+// THING FLAGS
+thingflags
+{
+ 1 = "[1] Extra";
+ 2 = "[2] Flip";
+ 4 = "[4] Special";
+ 8 = "[8] Ambush";
+}
+
+// Thing flags UDMF translation table
+// This is needed for copy/paste and prefabs to work properly
+// When the UDMF field name is prefixed with ! it is inverted
+thingflagstranslation
+{
+ 1 = "skill1";
+ 2 = "skill2";
+ 4 = "skill3";
+ 8 = "ambush";
+}
+
+// THING FLAGS ERROR MASK
+// Mask for the thing flags which indicates the options
+// that make the same thing appear in the same modes
+thingflagsmask1 = 7; // 1 + 2 + 4
+thingflagsmask2 = 0;
+
+
+// THING TYPES------------------------------------------------------------------
+// Color values: 1-Dark_Blue 2-Dark_Green 3-Turqoise 4-Dark_Red 5-Purple 6-Brown 7-Gray
+// 8-Dark_Gray 9-Blue 10-Green 11-Cyan 12-Red 13-Magenta
+// 14-Yellow 15-White 16-Pink 17-Orange 18-Gold 19-Cream
+thingtypes
+{
+ editor
+ {
+ color = 15; // White
+ arrow = 1;
+ title = "<Editor Things>";
+ error = -1;
+ width = 8;
+ height = 16;
+ sort = 1;
+
+ 3328 = "3D Mode Start";
+ }
+
+ starts
+ {
+ color = 1; // Blue
+ arrow = 1;
+ title = "Player Starts";
+ width = 16;
+ height = 48;
+ flags8text = "[8] Spawn on ceiling";
+ sprite = "PLAYA0";
+
+ 1
+ {
+ title = "Player 01 Start";
+ sprite = "PLAYA0";
+ }
+ 2
+ {
+ title = "Player 02 Start";
+ sprite = "PLAYA0";
+ }
+ 3
+ {
+ title = "Player 03 Start";
+ sprite = "PLAYA0";
+ }
+ 4
+ {
+ title = "Player 04 Start";
+ sprite = "PLAYA0";
+ }
+ 5
+ {
+ title = "Player 05 Start";
+ sprite = "PLAYA0";
+ }
+ 6
+ {
+ title = "Player 06 Start";
+ sprite = "PLAYA0";
+ }
+ 7
+ {
+ title = "Player 07 Start";
+ sprite = "PLAYA0";
+ }
+ 8
+ {
+ title = "Player 08 Start";
+ sprite = "PLAYA0";
+ }
+ 9
+ {
+ title = "Player 09 Start";
+ sprite = "PLAYA0";
+ }
+ 10
+ {
+ title = "Player 10 Start";
+ sprite = "PLAYA0";
+ }
+ 11
+ {
+ title = "Player 11 Start";
+ sprite = "PLAYA0";
+ }
+ 12
+ {
+ title = "Player 12 Start";
+ sprite = "PLAYA0";
+ }
+ 13
+ {
+ title = "Player 13 Start";
+ sprite = "PLAYA0";
+ }
+ 14
+ {
+ title = "Player 14 Start";
+ sprite = "PLAYA0";
+ }
+ 15
+ {
+ title = "Player 15 Start";
+ sprite = "PLAYA0";
+ }
+ 16
+ {
+ title = "Player 16 Start";
+ sprite = "PLAYA0";
+ }
+ 17
+ {
+ title = "Player 17 Start";
+ sprite = "PLAYA0";
+ }
+ 18
+ {
+ title = "Player 18 Start";
+ sprite = "PLAYA0";
+ }
+ 19
+ {
+ title = "Player 19 Start";
+ sprite = "PLAYA0";
+ }
+ 20
+ {
+ title = "Player 20 Start";
+ sprite = "PLAYA0";
+ }
+ 21
+ {
+ title = "Player 21 Start";
+ sprite = "PLAYA0";
+ }
+ 22
+ {
+ title = "Player 22 Start";
+ sprite = "PLAYA0";
+ }
+ 23
+ {
+ title = "Player 23 Start";
+ sprite = "PLAYA0";
+ }
+ 24
+ {
+ title = "Player 24 Start";
+ sprite = "PLAYA0";
+ }
+ 25
+ {
+ title = "Player 25 Start";
+ sprite = "PLAYA0";
+ }
+ 26
+ {
+ title = "Player 26 Start";
+ sprite = "PLAYA0";
+ }
+ 27
+ {
+ title = "Player 27 Start";
+ sprite = "PLAYA0";
+ }
+ 28
+ {
+ title = "Player 28 Start";
+ sprite = "PLAYA0";
+ }
+ 29
+ {
+ title = "Player 29 Start";
+ sprite = "PLAYA0";
+ }
+ 30
+ {
+ title = "Player 30 Start";
+ sprite = "PLAYA0";
+ }
+ 31
+ {
+ title = "Player 31 Start";
+ sprite = "PLAYA0";
+ }
+ 32
+ {
+ title = "Player 32 Start";
+ sprite = "PLAYA0";
+ }
+ 33
+ {
+ title = "Match Start";
+ sprite = "NDRNA2A8";
+ }
+ 34
+ {
+ title = "CTF Red Team Start";
+ sprite = "SIGNG0";
+ }
+ 35
+ {
+ title = "CTF Blue Team Start";
+ sprite = "SIGNE0";
+ }
+ }
+
+ enemies
+ {
+ color = 9; // Light_Blue
+ arrow = 1;
+ title = "Enemies";
+
+ 100
+ {
+ title = "Crawla (Blue)";
+ sprite = "POSSA1";
+ width = 24;
+ height = 32;
+ }
+ 101
+ {
+ title = "Crawla (Red)";
+ sprite = "SPOSA1";
+ width = 24;
+ height = 32;
+ }
+ 102
+ {
+ title = "Stupid Dumb Unnamed RoboFish";
+ sprite = "FISHA0";
+ width = 8;
+ height = 28;
+ angletext = "Jump strength";
+ }
+ 103
+ {
+ title = "Buzz (Gold)";
+ sprite = "BUZZA1";
+ width = 28;
+ height = 40;
+ flags8text = "[8] Cannot move";
+ }
+ 104
+ {
+ title = "Buzz (Red)";
+ sprite = "RBUZA1";
+ width = 28;
+ height = 40;
+ flags8text = "[8] Cannot move";
+ }
+ 108
+ {
+ title = "Deton";
+ sprite = "DETNA1";
+ width = 20;
+ height = 32;
+ }
+ 110
+ {
+ title = "Turret";
+ sprite = "TRETA1";
+ width = 16;
+ height = 32;
+ }
+ 111
+ {
+ title = "Pop-up Turret";
+ sprite = "TURRI1";
+ width = 12;
+ height = 64;
+ angletext = "Firing delay";
+ }
+ 122
+ {
+ title = "Spring Shell (Green)";
+ sprite = "SSHLA1";
+ width = 24;
+ height = 40;
+ }
+ 125
+ {
+ title = "Spring Shell (Yellow)";
+ sprite = "SSHLI1";
+ width = 24;
+ height = 40;
+ }
+ 109
+ {
+ title = "Skim";
+ sprite = "SKIMA1";
+ width = 16;
+ height = 24;
+ }
+ 113
+ {
+ title = "Jet Jaw";
+ sprite = "JJAWA3A7";
+ width = 12;
+ height = 20;
+ }
+ 126
+ {
+ title = "Crushstacean";
+ sprite = "CRABA0";
+ width = 24;
+ height = 32;
+ flags8text = "[8] Move left from spawn";
+ }
+ 138
+ {
+ title = "Banpyura";
+ sprite = "CR2BA0";
+ width = 24;
+ height = 32;
+ flags8text = "[8] Move left from spawn";
+ }
+ 117
+ {
+ title = "Robo-Hood";
+ sprite = "ARCHA1";
+ width = 24;
+ height = 32;
+ }
+ 118
+ {
+ title = "CastleBot FaceStabber";
+ sprite = "CBFSA1";
+ width = 32;
+ height = 72;
+ }
+ 1113
+ {
+ title = "Suspicious FaceStabber Statue";
+ sprite = "CBBSA1";
+ width = 32;
+ height = 72;
+ }
+ 119
+ {
+ title = "Egg Guard";
+ sprite = "ESHIA1";
+ width = 16;
+ height = 48;
+ flags1text = "[1] 90 degrees counter-clockwise";
+ flags4text = "[4] 90 degrees clockwise";
+ flags8text = "[8] Double speed";
+ }
+ 115
+ {
+ title = "Bird Aircraft Strike Hazard";
+ sprite = "VLTRF1";
+ width = 12;
+ height = 24;
+ }
+ 120
+ {
+ title = "Green Snapper";
+ sprite = "GSNPA1";
+ width = 24;
+ height = 24;
+ }
+ 121
+ {
+ title = "Minus";
+ sprite = "MNUSA1";
+ width = 24;
+ height = 32;
+ }
+ 134
+ {
+ title = "Canarivore";
+ sprite = "CANAA0";
+ width = 12;
+ height = 80;
+ hangs = 1;
+ }
+ 123
+ {
+ title = "Unidus";
+ sprite = "UNIDA1";
+ width = 18;
+ height = 36;
+ }
+ 135
+ {
+ title = "Pterabyte Spawner";
+ sprite = "PTERA2A8";
+ width = 16;
+ height = 16;
+ parametertext = "No. Pterabytes";
+ }
+ 136
+ {
+ title = "Pyre Fly";
+ sprite = "PYREA0";
+ width = 24;
+ height = 34;
+ flags8text = "[8] Start on fire";
+ }
+ 105
+ {
+ title = "Jetty-Syn Bomber";
+ sprite = "JETBB1";
+ width = 20;
+ height = 50;
+ flags8text = "[8] Cannot move";
+ }
+ 106
+ {
+ title = "Jetty-Syn Gunner";
+ sprite = "JETGB1";
+ width = 20;
+ height = 48;
+ flags8text = "[8] Cannot move";
+ }
+ 112
+ {
+ title = "Spincushion";
+ sprite = "SHRPA1";
+ width = 16;
+ height = 24;
+ }
+ 114
+ {
+ title = "Snailer";
+ sprite = "SNLRA3A7";
+ width = 24;
+ height = 48;
+ }
+ 129
+ {
+ title = "Penguinator";
+ sprite = "PENGA1";
+ width = 24;
+ height = 32;
+ }
+ 130
+ {
+ title = "Pophat";
+ sprite = "POPHA1";
+ width = 24;
+ height = 32;
+ }
+ 107
+ {
+ title = "Crawla Commander";
+ sprite = "CCOMA1";
+ width = 16;
+ height = 32;
+ }
+ 131
+ {
+ title = "Spinbobert";
+ sprite = "SBOBB0";
+ width = 32;
+ height = 32;
+ }
+ 132
+ {
+ title = "Cacolantern";
+ sprite = "CACOA0";
+ width = 32;
+ height = 32;
+ flags8text = "[8] Cannot move";
+ }
+ 133
+ {
+ title = "Hangster";
+ sprite = "HBATC1";
+ width = 24;
+ height = 24;
+ hangs = 1;
+ }
+ 127
+ {
+ title = "Hive Elemental";
+ sprite = "HIVEA0";
+ width = 32;
+ height = 80;
+ parametertext = "No. bees";
+ }
+ 128
+ {
+ title = "Bumblebore";
+ sprite = "BUMBA1";
+ width = 16;
+ height = 32;
+ }
+ 124
+ {
+ title = "Buggle";
+ sprite = "BBUZA1";
+ width = 20;
+ height = 24;
+ }
+ 116
+ {
+ title = "Pointy";
+ sprite = "PNTYA1";
+ width = 8;
+ height = 16;
+ }
+ }
+
+ bosses
+ {
+ color = 8; // Dark_Gray
+ arrow = 1;
+ title = "Bosses";
+
+ 200
+ {
+ title = "Egg Mobile";
+ sprite = "EGGMA1";
+ width = 24;
+ height = 76;
+ flags4text = "[4] End level on death";
+ flags8text = "[8] Alternate laser attack";
+ }
+ 201
+ {
+ title = "Egg Slimer";
+ sprite = "EGGNA1";
+ width = 24;
+ height = 76;
+ flags4text = "[4] End level on death";
+ flags8text = "[8] Speed up when hit";
+ }
+ 202
+ {
+ title = "Sea Egg";
+ sprite = "EGGOA1";
+ width = 32;
+ height = 116;
+ flags4text = "[4] End level on death";
+ }
+ 203
+ {
+ title = "Egg Colosseum";
+ sprite = "EGGPA1";
+ width = 24;
+ height = 76;
+ flags4text = "[4] End level on death";
+ }
+ 204
+ {
+ title = "Fang";
+ sprite = "FANGA1";
+ width = 24;
+ height = 60;
+ flags1text = "[1] Grayscale mode";
+ flags4text = "[4] End level on death";
+ }
+ 206
+ {
+ title = "Brak Eggman (Old)";
+ sprite = "BRAKB1";
+ width = 48;
+ height = 160;
+ flags4text = "[4] End level on death";
+ }
+ 207
+ {
+ title = "Metal Sonic (Race)";
+ sprite = "METLI1";
+ width = 16;
+ height = 48;
+ flags1text = "[1] Grayscale mode";
+ }
+ 208
+ {
+ title = "Metal Sonic (Battle)";
+ sprite = "METLC1";
+ width = 16;
+ height = 48;
+ flags1text = "[1] Grayscale mode";
+ flags4text = "[4] End level on death";
+ }
+ 209
+ {
+ title = "Brak Eggman";
+ sprite = "BRAK01";
+ width = 48;
+ height = 160;
+ flags4text = "[4] End level on death";
+ flags8text = "[8] Electric barrier";
+ }
+ 290
+ {
+ arrow = 0;
+ title = "Boss Escape Point";
+ width = 8;
+ height = 16;
+ sprite = "internal:eggmanend";
+ }
+ 291
+ {
+ arrow = 0;
+ title = "Egg Capsule Center";
+ width = 8;
+ height = 16;
+ sprite = "internal:capsule";
+ }
+ 292
+ {
+ arrow = 0;
+ title = "Boss Waypoint";
+ width = 8;
+ height = 16;
+ flags8text = "[8] Sea Egg shooting point";
+ sprite = "internal:eggmanway";
+ angletext = "No. (Sea Egg)";
+ flagsvaluetext = "No. (Brak)";
+ parametertext = "Next";
+ }
+ 293
+ {
+ title = "Metal Sonic Gather Point";
+ sprite = "internal:metal";
+ width = 8;
+ height = 16;
+ }
+ 294
+ {
+ title = "Fang Waypoint";
+ flags8text = "[8] Center waypoint";
+ sprite = "internal:eggmanway";
+ width = 8;
+ height = 16;
+ }
+ }
+
+ rings
+ {
+ color = 14; // Yellow
+ title = "Rings and Weapon Panels";
+ width = 24;
+ height = 24;
+ flags8height = 24;
+ flags8text = "[8] Float";
+ sprite = "RINGA0";
+
+ 300
+ {
+ title = "Ring";
+ sprite = "RINGA0";
+ width = 16;
+ }
+ 301
+ {
+ title = "Bounce Ring";
+ sprite = "internal:RNGBA0";
+ }
+ 302
+ {
+ title = "Rail Ring";
+ sprite = "internal:RNGRA0";
+ }
+ 303
+ {
+ title = "Infinity Ring";
+ sprite = "internal:RNGIA0";
+ }
+ 304
+ {
+ title = "Automatic Ring";
+ sprite = "internal:RNGAA0";
+ }
+ 305
+ {
+ title = "Explosion Ring";
+ sprite = "internal:RNGEA0";
+ }
+ 306
+ {
+ title = "Scatter Ring";
+ sprite = "internal:RNGSA0";
+ }
+ 307
+ {
+ title = "Grenade Ring";
+ sprite = "internal:RNGGA0";
+ }
+ 308
+ {
+ title = "CTF Team Ring (Red)";
+ sprite = "internal:RRNGA0";
+ width = 16;
+ }
+ 309
+ {
+ title = "CTF Team Ring (Blue)";
+ sprite = "internal:BRNGA0";
+ width = 16;
+ }
+ 330
+ {
+ title = "Bounce Ring Panel";
+ sprite = "internal:PIKBA0";
+ }
+ 331
+ {
+ title = "Rail Ring Panel";
+ sprite = "internal:PIKRA0";
+ }
+ 332
+ {
+ title = "Automatic Ring Panel";
+ sprite = "internal:PIKAA0";
+ }
+ 333
+ {
+ title = "Explosion Ring Panel";
+ sprite = "internal:PIKEA0";
+ }
+ 334
+ {
+ title = "Scatter Ring Panel";
+ sprite = "internal:PIKSA0";
+ }
+ 335
+ {
+ title = "Grenade Ring Panel";
+ sprite = "internal:PIKGA0";
+ }
+ }
+
+ collectibles
+ {
+ color = 10; // Light_Green
+ title = "Other Collectibles";
+ width = 16;
+ height = 32;
+ sort = 1;
+ sprite = "CEMGA0";
+
+ 310
+ {
+ title = "CTF Red Flag";
+ sprite = "RFLGA0";
+ width = 24;
+ height = 64;
+ }
+ 311
+ {
+ title = "CTF Blue Flag";
+ sprite = "BFLGA0";
+ width = 24;
+ height = 64;
+ }
+ 312
+ {
+ title = "Emerald Token";
+ sprite = "TOKEA0";
+ width = 16;
+ height = 32;
+ flags8height = 24;
+ flags8text = "[8] Float";
+ }
+ 313
+ {
+ title = "Chaos Emerald 1 (Green)";
+ sprite = "CEMGA0";
+ }
+ 314
+ {
+ title = "Chaos Emerald 2 (Purple)";
+ sprite = "CEMGB0";
+ }
+ 315
+ {
+ title = "Chaos Emerald 3 (Blue)";
+ sprite = "CEMGC0";
+ }
+ 316
+ {
+ title = "Chaos Emerald 4 (Cyan)";
+ sprite = "CEMGD0";
+ }
+ 317
+ {
+ title = "Chaos Emerald 5 (Orange)";
+ sprite = "CEMGE0";
+ }
+ 318
+ {
+ title = "Chaos Emerald 6 (Red)";
+ sprite = "CEMGF0";
+ }
+ 319
+ {
+ title = "Chaos Emerald 7 (Gray)";
+ sprite = "CEMGG0";
+ }
+ 320
+ {
+ title = "Emerald Hunt Location";
+ sprite = "SHRDA0";
+ }
+ 321
+ {
+ title = "Match Chaos Emerald Spawn";
+ sprite = "CEMGA0";
+ flags8height = 24;
+ flags8text = "[8] Float";
+ }
+ 322
+ {
+ title = "Emblem";
+ sprite = "EMBMA0";
+ width = 16;
+ height = 30;
+ flags8height = 24;
+ flags8text = "[8] Float";
+ angletext = "Tag";
+ }
+ }
+
+ boxes
+ {
+ color = 7; // Gray
+ blocking = 2;
+ title = "Monitors";
+ width = 18;
+ height = 40;
+ flags1text = "[1] Run Linedef Executor on pop";
+ flags4text = "[4] Random (Strong)";
+ flags8text = "[8] Random (Weak)";
+
+ 400
+ {
+ title = "Super Ring (10 Rings)";
+ sprite = "TVRIA0";
+ }
+ 401
+ {
+ title = "Pity Shield";
+ sprite = "TVPIA0";
+ }
+ 402
+ {
+ title = "Attraction Shield";
+ sprite = "TVATA0";
+ }
+ 403
+ {
+ title = "Force Shield";
+ sprite = "TVFOA0";
+ }
+ 404
+ {
+ title = "Armageddon Shield";
+ sprite = "TVARA0";
+ }
+ 405
+ {
+ title = "Whirlwind Shield";
+ sprite = "TVWWA0";
+ }
+ 406
+ {
+ title = "Elemental Shield";
+ sprite = "TVELA0";
+ }
+ 407
+ {
+ title = "Super Sneakers";
+ sprite = "TVSSA0";
+ }
+ 408
+ {
+ title = "Invincibility";
+ sprite = "TVIVA0";
+ }
+ 409
+ {
+ title = "Extra Life";
+ sprite = "TV1UA0";
+ flags4text = "[4] Random (Strong) / 10k points";
+ flags8text = "[8] Random (Weak) / 10k points";
+ }
+ 410
+ {
+ title = "Eggman";
+ sprite = "TVEGA0";
+ flags4text = "[4] Special";
+ flags8text = "[8] Ambush";
+ }
+ 411
+ {
+ title = "Teleporter";
+ sprite = "TVMXA0";
+ }
+ 413
+ {
+ title = "Gravity Boots";
+ sprite = "TVGVA0";
+ flags4text = "[4] Special";
+ flags8text = "[8] Ambush";
+ }
+ 414
+ {
+ title = "CTF Team Ring Monitor (Red)";
+ sprite = "TRRIA0";
+ flags4text = "[4] Special";
+ flags8text = "[8] Ambush";
+ }
+ 415
+ {
+ title = "CTF Team Ring Monitor (Blue)";
+ sprite = "TBRIA0";
+ flags4text = "[4] Special";
+ flags8text = "[8] Ambush";
+ }
+ 416
+ {
+ title = "Recycler";
+ sprite = "TVRCA0";
+ }
+ 418
+ {
+ title = "Score (1,000 Points)";
+ sprite = "TV1KA0";
+ flags4text = "[4] Special";
+ flags8text = "[8] Ambush";
+ }
+ 419
+ {
+ title = "Score (10,000 Points)";
+ sprite = "TVTKA0";
+ flags4text = "[4] Special";
+ flags8text = "[8] Ambush";
+ }
+ 420
+ {
+ title = "Flame Shield";
+ sprite = "TVFLA0";
+ }
+ 421
+ {
+ title = "Water Shield";
+ sprite = "TVBBA0";
+ }
+ 422
+ {
+ title = "Lightning Shield";
+ sprite = "TVZPA0";
+ }
+ }
+
+ boxes2
+ {
+ color = 18; // Gold
+ blocking = 2;
+ title = "Monitors (Respawning)";
+ width = 20;
+ height = 44;
+ flags1text = "[1] Run Linedef Executor on pop";
+
+ 431
+ {
+ title = "Pity Shield (Respawn)";
+ sprite = "TVPIB0";
+ }
+ 432
+ {
+ title = "Attraction Shield (Respawn)";
+ sprite = "TVATB0";
+ }
+ 433
+ {
+ title = "Force Shield (Respawn)";
+ sprite = "TVFOB0";
+ }
+ 434
+ {
+ title = "Armageddon Shield (Respawn)";
+ sprite = "TVARB0";
+ }
+ 435
+ {
+ title = "Whirlwind Shield (Respawn)";
+ sprite = "TVWWB0";
+ }
+ 436
+ {
+ title = "Elemental Shield (Respawn)";
+ sprite = "TVELB0";
+ }
+ 437
+ {
+ title = "Super Sneakers (Respawn)";
+ sprite = "TVSSB0";
+ }
+ 438
+ {
+ title = "Invincibility (Respawn)";
+ sprite = "TVIVB0";
+ }
+ 440
+ {
+ title = "Eggman (Respawn)";
+ sprite = "TVEGB0";
+ }
+ 443
+ {
+ title = "Gravity Boots (Respawn)";
+ sprite = "TVGVB0";
+ }
+ 450
+ {
+ title = "Flame Shield (Respawn)";
+ sprite = "TVFLB0";
+ }
+ 451
+ {
+ title = "Water Shield (Respawn)";
+ sprite = "TVBBB0";
+ }
+ 452
+ {
+ title = "Lightning Shield (Respawn)";
+ sprite = "TVZPB0";
+ }
+ }
+
+ generic
+ {
+ color = 11; // Light_Cyan
+ title = "Generic Items & Hazards";
+
+ 500
+ {
+ title = "Air Bubble Patch";
+ sprite = "BUBLE0";
+ width = 8;
+ height = 16;
+ flags8text = "[8] No distance check";
+ }
+ 501
+ {
+ title = "Signpost";
+ sprite = "SIGND0";
+ width = 8;
+ height = 32;
+ }
+ 502
+ {
+ arrow = 1;
+ title = "Star Post";
+ sprite = "STPTA0M0";
+ width = 64;
+ height = 128;
+ angletext = "Angle/Order";
+ }
+ 520
+ {
+ title = "Bomb Sphere";
+ sprite = "SPHRD0";
+ width = 16;
+ height = 24;
+ flags8height = 24;
+ flags8text = "[8] Float";
+ unflippable = true;
+ }
+ 521
+ {
+ title = "Spikeball";
+ sprite = "SPIKA0";
+ width = 12;
+ height = 8;
+ flags8height = 24;
+ flags8text = "[8] Float";
+ }
+ 522
+ {
+ title = "Wall Spike";
+ sprite = "WSPKALAR";
+ width = 16;
+ height = 14;
+ flags1text = "[1] Start retracted";
+ flags4text = "[4] Retractable";
+ flags8text = "[8] Intangible";
+ parametertext = "Initial delay";
+ }
+ 523
+ {
+ title = "Spike";
+ sprite = "USPKA0";
+ width = 8;
+ height = 32;
+ flags1text = "[1] Start retracted";
+ flags4text = "[4] Retractable";
+ flags8text = "[8] Intangible";
+ angletext = "Retraction interval";
+ parametertext = "Initial delay";
+ }
+ 1130
+ {
+ title = "Small Mace";
+ sprite = "SMCEA0";
+ width = 17;
+ height = 34;
+ }
+ 1131
+ {
+ title = "Big Mace";
+ sprite = "BMCEA0";
+ width = 34;
+ height = 68;
+ }
+ 1136
+ {
+ title = "Small Fireball";
+ sprite = "SFBRA0";
+ width = 17;
+ height = 34;
+ }
+ 1137
+ {
+ title = "Large Fireball";
+ sprite = "BFBRA0";
+ width = 34;
+ height = 68;
+ }
+ }
+
+ springs
+ {
+ color = 12; // Light_Red
+ title = "Springs and Fans";
+ width = 20;
+ height = 16;
+ sprite = "RSPRD2";
+
+ 540
+ {
+ title = "Fan";
+ sprite = "FANSA0D0";
+ width = 16;
+ height = 8;
+ flags4text = "[4] Invisible";
+ flags8text = "[8] No distance check";
+ angletext = "Lift height";
+ }
+ 541
+ {
+ title = "Gas Jet";
+ sprite = "STEMD0";
+ flags8text = "[8] No sounds";
+ width = 32;
+ }
+ 542
+ {
+ title = "Bumper";
+ sprite = "BUMPA0";
+ width = 32;
+ height = 64;
+ angletext = "Strength";
+ }
+ 543
+ {
+ title = "Balloon";
+ sprite = "BLONA0";
+ width = 32;
+ height = 64;
+ flags8text = "[8] Respawn";
+ angletext = "Color";
+ }
+ 550
+ {
+ title = "Yellow Spring";
+ sprite = "SPRYA0";
+ }
+ 551
+ {
+ title = "Red Spring";
+ sprite = "SPRRA0";
+ }
+ 552
+ {
+ title = "Blue Spring";
+ sprite = "SPRBA0";
+ }
+ 555
+ {
+ arrow = 1;
+ title = "Diagonal Yellow Spring";
+ sprite = "YSPRD2";
+ width = 16;
+ flags4text = "[4] Ignore gravity";
+ flags8text = "[8] Rotate 22.5° CCW";
+ }
+ 556
+ {
+ arrow = 1;
+ title = "Diagonal Red Spring";
+ sprite = "RSPRD2";
+ width = 16;
+ flags4text = "[4] Ignore gravity";
+ flags8text = "[8] Rotate 22.5° CCW";
+ }
+ 557
+ {
+ arrow = 1;
+ title = "Diagonal Blue Spring";
+ sprite = "BSPRD2";
+ width = 16;
+ flags4text = "[4] Ignore gravity";
+ flags8text = "[8] Rotate 22.5° CCW";
+ }
+ 558
+ {
+ arrow = 1;
+ title = "Horizontal Yellow Spring";
+ sprite = "SSWYD2D8";
+ flags8height = 16;
+ flags8text = "[8] Float";
+ width = 16;
+ height = 32;
+ }
+ 559
+ {
+ arrow = 1;
+ title = "Horizontal Red Spring";
+ sprite = "SSWRD2D8";
+ flags8height = 16;
+ flags8text = "[8] Float";
+ width = 16;
+ height = 32;
+ }
+ 560
+ {
+ arrow = 1;
+ title = "Horizontal Blue Spring";
+ sprite = "SSWBD2D8";
+ flags8height = 16;
+ flags8text = "[8] Float";
+ width = 16;
+ height = 32;
+ }
+ 1134
+ {
+ title = "Yellow Spring Ball";
+ sprite = "YSPBA0";
+ width = 17;
+ height = 34;
+ }
+ 1135
+ {
+ title = "Red Spring Ball";
+ sprite = "RSPBA0";
+ width = 17;
+ height = 34;
+ }
+ 544
+ {
+ arrow = 1;
+ title = "Yellow Boost Panel";
+ sprite = "BSTYA0";
+ flags8text = "[8] Force spin";
+ width = 28;
+ height = 2;
+ }
+ 545
+ {
+ arrow = 1;
+ title = "Red Boost Panel";
+ sprite = "BSTRA0";
+ flags8text = "[8] Force spin";
+ width = 28;
+ height = 2;
+ }
+ }
+
+ patterns
+ {
+ color = 5; // Magenta
+ arrow = 1;
+ title = "Special Placement Patterns";
+ width = 16;
+ height = 384;
+ sprite = "RINGA0";
+
+ 600
+ {
+ arrow = 0;
+ title = "5 Vertical Rings (Yellow Spring)";
+ sprite = "RINGA0";
+ }
+ 601
+ {
+ arrow = 0;
+ title = "5 Vertical Rings (Red Spring)";
+ sprite = "RINGA0";
+ height = 1024;
+ }
+ 602
+ {
+ title = "5 Diagonal Rings (Yellow Spring)";
+ sprite = "RINGA0";
+ height = 32;
+ }
+ 603
+ {
+ title = "10 Diagonal Rings (Red Spring)";
+ sprite = "RINGA0";
+ height = 32;
+ }
+ 604
+ {
+ title = "Circle of Rings";
+ sprite = "RINGA0";
+ width = 96;
+ height = 192;
+ unflippable = true;
+ centerHitbox = true;
+ }
+ 605
+ {
+ title = "Circle of Rings (Big)";
+ sprite = "RINGA0";
+ width = 192;
+ unflippable = true;
+ centerHitbox = true;
+ }
+ 606
+ {
+ title = "Circle of Blue Spheres";
+ sprite = "SPHRA0";
+ width = 96;
+ height = 192;
+ unflippable = true;
+ centerHitbox = true;
+ }
+ 607
+ {
+ title = "Circle of Blue Spheres (Big)";
+ sprite = "SPHRA0";
+ width = 192;
+ unflippable = true;
+ centerHitbox = true;
+ }
+ 608
+ {
+ title = "Circle of Rings and Spheres";
+ sprite = "SPHRA0";
+ width = 96;
+ height = 192;
+ unflippable = true;
+ centerHitbox = true;
+ }
+ 609
+ {
+ title = "Circle of Rings and Spheres (Big)";
+ sprite = "SPHRA0";
+ width = 192;
+ unflippable = true;
+ centerHitbox = true;
+ }
+ }
+
+ invisible
+ {
+ color = 15; // White
+ title = "Misc. Invisible";
+ width = 8;
+ height = 16;
+ sprite = "UNKNA0";
+
+ 700
+ {
+ title = "Water Ambience A (Large)";
+ sprite = "internal:ambiance";
+ }
+
+ 701
+ {
+ title = "Water Ambience B (Large)";
+ sprite = "internal:ambiance";
+ }
+
+ 702
+ {
+ title = "Water Ambience C (Medium)";
+ sprite = "internal:ambiance";
+ }
+
+ 703
+ {
+ title = "Water Ambience D (Medium)";
+ sprite = "internal:ambiance";
+ }
+
+ 704
+ {
+ title = "Water Ambience E (Small)";
+ sprite = "internal:ambiance";
+ }
+
+ 705
+ {
+ title = "Water Ambience F (Small)";
+ sprite = "internal:ambiance";
+ }
+
+ 706
+ {
+ title = "Water Ambience G (Extra Large)";
+ sprite = "internal:ambiance";
+ }
+
+ 707
+ {
+ title = "Water Ambience H (Extra Large)";
+ sprite = "internal:ambiance";
+ }
+
+ 708
+ {
+ title = "Disco Ambience";
+ sprite = "internal:ambiance";
+ }
+
+ 709
+ {
+ title = "Volcano Ambience";
+ sprite = "internal:ambiance";
+ }
+
+ 710
+ {
+ title = "Machine Ambience";
+ sprite = "internal:ambiance";
+ }
+
+ 750
+ {
+ title = "Slope Vertex";
+ sprite = "internal:vertexslope";
+ angletext = "Tag";
+ }
+
+ 751
+ {
+ arrow = 1;
+ title = "Teleport Destination";
+ sprite = "internal:tele";
+ }
+
+ 752
+ {
+ arrow = 1;
+ title = "Alternate View Point";
+ sprite = "internal:view";
+ }
+
+ 753
+ {
+ title = "Zoom Tube Waypoint";
+ sprite = "internal:zoom";
+ angletext = "Order";
+ }
+
+ 754
+ {
+ title = "Push Point";
+ flags4text = "[4] Fades using XY";
+ flags8text = "[8] Push using XYZ";
+ sprite = "GWLGA0";
+ angletext = "Radius";
+ }
+ 755
+ {
+ title = "Pull Point";
+ flags4text = "[4] Fades using XY";
+ flags8text = "[8] Pull using XYZ";
+ sprite = "GWLRA0";
+ angletext = "Radius";
+ }
+ 756
+ {
+ title = "Blast Linedef Executor";
+ sprite = "TOADA0";
+ width = 32;
+ height = 16;
+ }
+ 757
+ {
+ title = "Fan Particle Generator";
+ sprite = "PRTLA0";
+ width = 8;
+ height = 16;
+ angletext = "Tag";
+ }
+ 758
+ {
+ title = "Object Angle Anchor";
+ sprite = "internal:view";
+ }
+ 760
+ {
+ title = "PolyObject Anchor";
+ sprite = "internal:polyanchor";
+ angletext = "ID";
+ }
+
+ 761
+ {
+ title = "PolyObject Spawn Point";
+ sprite = "internal:polycenter";
+ angletext = "ID";
+ }
+
+ 762
+ {
+ title = "PolyObject Spawn Point (Crush)";
+ sprite = "internal:polycentercrush";
+ angletext = "ID";
+ }
+ 780
+ {
+ title = "Skybox View Point";
+ sprite = "internal:skyb";
+ flags4text = "[4] In-map centerpoint";
+ parametertext = "ID";
+ }
+ }
+
+ greenflower
+ {
+ color = 10; // Green
+ title = "Greenflower";
+
+ 800
+ {
+ title = "GFZ Flower";
+ sprite = "FWR1A0";
+ width = 16;
+ height = 40;
+ }
+ 801
+ {
+ title = "Sunflower";
+ sprite = "FWR2A0";
+ width = 16;
+ height = 96;
+ }
+ 802
+ {
+ title = "Budding Flower";
+ sprite = "FWR3A0";
+ width = 8;
+ height = 32;
+ }
+ 803
+ {
+ title = "Blueberry Bush";
+ sprite = "BUS3A0";
+ width = 16;
+ height = 32;
+ }
+ 804
+ {
+ title = "Berry Bush";
+ sprite = "BUS1A0";
+ width = 16;
+ height = 32;
+ }
+ 805
+ {
+ title = "Bush";
+ sprite = "BUS2A0";
+ width = 16;
+ height = 32;
+ }
+ 806
+ {
+ title = "GFZ Tree";
+ sprite = "TRE1A0";
+ width = 20;
+ height = 128;
+ }
+ 807
+ {
+ title = "GFZ Berry Tree";
+ sprite = "TRE1B0";
+ width = 20;
+ height = 128;
+ }
+ 808
+ {
+ title = "GFZ Cherry Tree";
+ sprite = "TRE1C0";
+ width = 20;
+ height = 128;
+ }
+ 809
+ {
+ title = "Checkered Tree";
+ sprite = "TRE2A0";
+ width = 20;
+ height = 200;
+ }
+ 810
+ {
+ title = "Checkered Tree (Sunset)";
+ sprite = "TRE2B0";
+ width = 20;
+ height = 200;
+ }
+ 811
+ {
+ title = "Polygon Tree";
+ sprite = "TRE4A0";
+ width = 20;
+ height = 200;
+ }
+ 812
+ {
+ title = "Bush Tree";
+ sprite = "TRE5A0";
+ width = 20;
+ height = 200;
+ }
+ 813
+ {
+ title = "Red Bush Tree";
+ sprite = "TRE5B0";
+ width = 20;
+ height = 200;
+ }
+ }
+
+ technohill
+ {
+ color = 10; // Green
+ title = "Techno Hill";
+
+ 900
+ {
+ title = "THZ Steam Flower";
+ sprite = "THZPA0";
+ width = 8;
+ height = 32;
+ }
+ 901
+ {
+ title = "Alarm";
+ sprite = "ALRMA0";
+ width = 8;
+ height = 16;
+ hangs = 1;
+ }
+ 902
+ {
+ title = "THZ Spin Flower (Red)";
+ sprite = "FWR5A0";
+ width = 16;
+ height = 64;
+ }
+ 903
+ {
+ title = "THZ Spin Flower (Yellow)";
+ sprite = "FWR6A0";
+ width = 16;
+ height = 64;
+ }
+ 904
+ {
+ arrow = 1;
+ title = "Whistlebush";
+ sprite = "THZTA0";
+ width = 16;
+ height = 64;
+ }
+ }
+
+ deepsea
+ {
+ color = 10; // Green
+ title = "Deep Sea";
+
+ 1000
+ {
+ arrow = 1;
+ blocking = 2;
+ title = "Gargoyle";
+ sprite = "GARGA1";
+ width = 16;
+ height = 40;
+ flags4text = "[4] Slides when pushed";
+ flags8text = "[8] Not pushable";
+ }
+ 1009
+ {
+ arrow = 1;
+ blocking = 2;
+ title = "Gargoyle (Big)";
+ sprite = "GARGB1";
+ width = 32;
+ height = 80;
+ flags4text = "[4] Slides when pushed";
+ flags8text = "[8] Not pushable";
+ }
+ 1001
+ {
+ title = "Seaweed";
+ sprite = "SEWEA0";
+ width = 24;
+ height = 56;
+ }
+ 1002
+ {
+ title = "Dripping Water";
+ sprite = "DRIPD0";
+ width = 8;
+ height = 16;
+ hangs = 1;
+ angletext = "Dripping interval";
+ }
+ 1003
+ {
+ title = "Coral (Green)";
+ sprite = "CORLA0";
+ width = 29;
+ height = 40;
+ }
+ 1004
+ {
+ title = "Coral (Red)";
+ sprite = "CORLB0";
+ width = 30;
+ height = 53;
+ }
+ 1005
+ {
+ title = "Coral (Orange)";
+ sprite = "CORLC0";
+ width = 28;
+ height = 41;
+ }
+ 1006
+ {
+ title = "Blue Crystal";
+ sprite = "BCRYA1";
+ width = 8;
+ height = 16;
+ }
+ 1007
+ {
+ title = "Kelp";
+ sprite = "KELPA0";
+ width = 16;
+ height = 292;
+ flags4text = "[4] Double size";
+ }
+ 1008
+ {
+ title = "Stalagmite (DSZ1)";
+ sprite = "DSTGA0";
+ width = 8;
+ height = 116;
+ flags4text = "[4] Double size";
+ }
+ 1010
+ {
+ arrow = 1;
+ title = "Light Beam";
+ sprite = "LIBEARAL";
+ width = 16;
+ height = 16;
+ }
+ 1011
+ {
+ title = "Stalagmite (DSZ2)";
+ sprite = "DSTGA0";
+ width = 8;
+ height = 116;
+ flags4text = "[4] Double size";
+ }
+ 1012
+ {
+ arrow = 1;
+ title = "Big Floating Mine";
+ width = 28;
+ height = 56;
+ sprite = "BMNEA1";
+ }
+ 1013
+ {
+ title = "Animated Kelp";
+ sprite = "ALGAA0";
+ width = 48;
+ height = 120;
+ }
+ 1014
+ {
+ title = "Large Coral (Brown)";
+ sprite = "CORLD0";
+ width = 56;
+ height = 112;
+ }
+ 1015
+ {
+ title = "Large Coral (Beige)";
+ sprite = "CORLE0";
+ width = 56;
+ height = 112;
+ }
+ }
+
+ castleeggman
+ {
+ color = 10; // Green
+ title = "Castle Eggman";
+
+ 1100
+ {
+ title = "Chain (Decorative)";
+ sprite = "CHANA0";
+ width = 4;
+ height = 128;
+ hangs = 1;
+ }
+ 1101
+ {
+ title = "Torch";
+ sprite = "FLAMA0E0";
+ width = 8;
+ height = 32;
+ flags1text = "[1] Add corona";
+ }
+ 1102
+ {
+ arrow = 1;
+ blocking = 2;
+ title = "Eggman Statue";
+ sprite = "ESTAA1";
+ width = 32;
+ height = 240;
+ flags4text = "[4] Slides when pushed";
+ flags8text = "[8] Not pushable";
+ }
+ 1103
+ {
+ title = "CEZ Flower";
+ sprite = "FWR4A0";
+ width = 16;
+ height = 40;
+ }
+ 1104
+ {
+ title = "Mace Spawnpoint";
+ sprite = "SMCEA0";
+ width = 17;
+ height = 34;
+ flags4text = "[4] No sounds";
+ flags8text = "[8] Double size";
+ angletext = "Tag";
+ }
+ 1105
+ {
+ title = "Chain with Maces Spawnpoint";
+ sprite = "SMCEA0";
+ width = 17;
+ height = 34;
+ flags4text = "[4] No sounds";
+ flags8text = "[8] Double size";
+ angletext = "Tag";
+ }
+ 1106
+ {
+ title = "Chained Spring Spawnpoint";
+ sprite = "YSPBA0";
+ width = 17;
+ height = 34;
+ flags4text = "[4] No sounds";
+ flags8text = "[8] Red spring";
+ angletext = "Tag";
+ }
+ 1107
+ {
+ title = "Chain Spawnpoint";
+ sprite = "BMCHA0";
+ width = 17;
+ height = 34;
+ flags8text = "[8] Double size";
+ angletext = "Tag";
+ }
+ 1108
+ {
+ arrow = 1;
+ title = "Hidden Chain Spawnpoint";
+ sprite = "internal:chain3";
+ width = 17;
+ height = 34;
+ flags8text = "[8] Double size";
+ }
+ 1109
+ {
+ title = "Firebar Spawnpoint";
+ sprite = "BFBRA0";
+ width = 17;
+ height = 34;
+ flags4text = "[4] No sounds";
+ flags8text = "[8] Double size";
+ angletext = "Tag";
+ }
+ 1110
+ {
+ title = "Custom Mace Spawnpoint";
+ sprite = "SMCEA0";
+ width = 17;
+ height = 34;
+ flags4text = "[4] No sounds";
+ angletext = "Tag";
+ }
+ 1111
+ {
+ arrow = 1;
+ blocking = 2;
+ title = "Crawla Statue";
+ sprite = "CSTAA1";
+ width = 16;
+ height = 40;
+ flags4text = "[4] Slides when pushed";
+ flags8text = "[8] Not pushable";
+ }
+ 1112
+ {
+ arrow = 1;
+ blocking = 2;
+ title = "FaceStabber Statue";
+ sprite = "CBBSA1";
+ width = 32;
+ height = 72;
+ flags4text = "[4] Slides when pushed";
+ flags8text = "[8] Not pushable";
+ }
+ 1114
+ {
+ title = "Pine Tree";
+ sprite = "PINEA0";
+ width = 16;
+ height = 628;
+ }
+ 1115
+ {
+ title = "CEZ Shrub (Small)";
+ sprite = "CEZBA0";
+ width = 16;
+ height = 24;
+ }
+ 1116
+ {
+ title = "CEZ Shrub (Large)";
+ sprite = "CEZBB0";
+ width = 32;
+ height = 48;
+ }
+ 1117
+ {
+ arrow = 1;
+ title = "Pole Banner (Red)";
+ sprite = "BANRA0";
+ width = 40;
+ height = 224;
+ }
+ 1118
+ {
+ arrow = 1;
+ title = "Pole Banner (Blue)";
+ sprite = "BANRA0";
+ width = 40;
+ height = 224;
+ }
+ 1119
+ {
+ title = "Candle";
+ sprite = "CNDLA0";
+ width = 8;
+ height = 48;
+ flags1text = "[1] Add corona";
+ }
+ 1120
+ {
+ title = "Candle Pricket";
+ sprite = "CNDLB0";
+ width = 8;
+ height = 176;
+ flags1text = "[1] Add corona";
+ }
+ 1121
+ {
+ title = "Flame Holder";
+ sprite = "FLMHA0";
+ width = 24;
+ height = 80;
+ flags1text = "[1] Add corona";
+ flags4text = "[4] No flame";
+ }
+ 1122
+ {
+ title = "Fire Torch";
+ sprite = "CTRCA0";
+ width = 16;
+ height = 80;
+ }
+ 1123
+ {
+ title = "Cannonball Launcher";
+ sprite = "internal:cannonball";
+ width = 8;
+ height = 16;
+ }
+ 1124
+ {
+ blocking = 2;
+ title = "Cannonball";
+ sprite = "CBLLA0";
+ width = 20;
+ height = 40;
+ flags4text = "[4] Slides when pushed";
+ flags8text = "[8] Not pushable";
+ }
+ 1125
+ {
+ title = "Brambles";
+ sprite = "CABRALAR";
+ width = 48;
+ height = 32;
+ }
+ 1126
+ {
+ title = "Invisible Lockon Object";
+ sprite = "LCKNC0";
+ width = 16;
+ height = 32;
+ }
+ 1127
+ {
+ title = "Spectator Eggrobo";
+ sprite = "EGR1A1";
+ width = 20;
+ height = 72;
+ }
+ 1128
+ {
+ arrow = 1;
+ title = "Waving Flag (Red)";
+ sprite = "CFLGA0";
+ width = 8;
+ height = 208;
+ }
+ 1129
+ {
+ arrow = 1;
+ title = "Waving Flag (Blue)";
+ sprite = "CFLGA0";
+ width = 8;
+ height = 208;
+ }
+ }
+
+ aridcanyon
+ {
+ color = 10; // Green
+ title = "Arid Canyon";
+
+ 1200
+ {
+ title = "Tumbleweed (Big)";
+ sprite = "BTBLA0";
+ width = 24;
+ height = 48;
+ flags8text = "[8] Moves perpetually";
+ }
+ 1201
+ {
+ title = "Tumbleweed (Small)";
+ sprite = "STBLA0";
+ width = 12;
+ height = 24;
+ flags8text = "[8] Moves perpetually";
+ }
+ 1202
+ {
+ arrow = 1;
+ title = "Rock Spawner";
+ sprite = "ROIAA0";
+ width = 8;
+ height = 16;
+ angletext = "Tag";
+ }
+ 1203
+ {
+ title = "Tiny Red Flower Cactus";
+ sprite = "CACTA0";
+ width = 13;
+ height = 24;
+ }
+ 1204
+ {
+ title = "Small Red Flower Cactus";
+ sprite = "CACTB0";
+ width = 15;
+ height = 52;
+ }
+ 1205
+ {
+ title = "Tiny Blue Flower Cactus";
+ sprite = "CACTC0";
+ width = 13;
+ height = 24;
+ }
+ 1206
+ {
+ title = "Small Blue Flower Cactus";
+ sprite = "CACTD0";
+ width = 15;
+ height = 52;
+ }
+ 1207
+ {
+ title = "Prickly Pear";
+ sprite = "CACTE0";
+ width = 32;
+ height = 96;
+ }
+ 1208
+ {
+ title = "Barrel Cactus";
+ sprite = "CACTF0";
+ width = 20;
+ height = 128;
+ }
+ 1209
+ {
+ title = "Tall Barrel Cactus";
+ sprite = "CACTG0";
+ width = 24;
+ height = 224;
+ }
+ 1210
+ {
+ title = "Armed Cactus";
+ sprite = "CACTH0";
+ width = 24;
+ height = 256;
+ }
+ 1211
+ {
+ title = "Ball Cactus";
+ sprite = "CACTI0";
+ width = 48;
+ height = 96;
+ }
+ 1212
+ {
+ title = "Caution Sign";
+ sprite = "WWSGAR";
+ width = 22;
+ height = 64;
+ }
+ 1213
+ {
+ title = "Cacti Sign";
+ sprite = "WWS2AR";
+ width = 22;
+ height = 64;
+ }
+ 1214
+ {
+ title = "Sharp Turn Sign";
+ sprite = "WWS3ALAR";
+ width = 16;
+ height = 192;
+ }
+ 1215
+ {
+ title = "Mine Oil Lamp";
+ sprite = "OILLA0";
+ width = 22;
+ height = 64;
+ hangs = 1;
+ }
+ 1216
+ {
+ title = "TNT Barrel";
+ sprite = "BARRA1";
+ width = 24;
+ height = 63;
+ }
+ 1217
+ {
+ title = "TNT Proximity Shell";
+ sprite = "REMTA0";
+ width = 64;
+ height = 40;
+ }
+ 1218
+ {
+ title = "Dust Devil";
+ sprite = "TAZDCR";
+ width = 80;
+ height = 416;
+ }
+ 1219
+ {
+ title = "Minecart Spawner";
+ sprite = "MCRTCLFR";
+ width = 22;
+ height = 32;
+ }
+ 1220
+ {
+ title = "Minecart Stopper";
+ sprite = "MCRTIR";
+ width = 32;
+ height = 32;
+ }
+ 1221
+ {
+ title = "Minecart Saloon Door";
+ sprite = "SALDARAL";
+ width = 96;
+ height = 160;
+ flags8text = "[8] Allow non-minecart players";
+ }
+ 1222
+ {
+ title = "Train Cameo Spawner";
+ sprite = "TRAEBRBL";
+ width = 28;
+ height = 32;
+ }
+ 1223
+ {
+ title = "Train Dust Spawner";
+ sprite = "ADSTA0";
+ width = 4;
+ height = 4;
+ }
+ 1224
+ {
+ title = "Train Steam Spawner";
+ sprite = "STEAA0";
+ width = 4;
+ height = 4;
+ }
+ 1229
+ {
+ title = "Minecart Switch Point";
+ sprite = "internal:zoom";
+ width = 8;
+ height = 16;
+ flags8text = "[8] Enable switching";
+ }
+ 1230
+ {
+ title = "Tiny Cactus";
+ sprite = "CACTJ0";
+ width = 13;
+ height = 28;
+ }
+ 1231
+ {
+ title = "Small Cactus";
+ sprite = "CACTK0";
+ width = 15;
+ height = 60;
+ }
+ }
+
+ redvolcano
+ {
+ color = 10; // Green
+ title = "Red Volcano";
+
+ 1300
+ {
+ arrow = 1;
+ title = "Flame Jet (Horizontal)";
+ sprite = "internal:flameh";
+ width = 16;
+ height = 40;
+ flags8text = "[8] Waves vertically";
+ angletext = "On/Off time";
+ parametertext = "Strength";
+ }
+ 1301
+ {
+ title = "Flame Jet (Vertical)";
+ sprite = "internal:flamev";
+ width = 16;
+ height = 40;
+ flags8text = "[8] Shoot downwards";
+ angletext = "On/Off time";
+ parametertext = "Strength";
+ }
+ 1302
+ {
+ title = "Spinning Flame Jet (Counter-Clockwise)";
+ sprite = "internal:flame2";
+ width = 16;
+ height = 24;
+ }
+ 1303
+ {
+ title = "Spinning Flame Jet (Clockwise)";
+ sprite = "internal:flame1";
+ width = 16;
+ height = 24;
+ }
+ 1304
+ {
+ title = "Lavafall";
+ sprite = "LFALF0";
+ width = 30;
+ height = 32;
+ angletext = "Initial delay";
+ flags8text = "[8] Double size";
+ }
+ 1305
+ {
+ title = "Rollout Rock";
+ sprite = "PUMIA1A5";
+ width = 30;
+ height = 60;
+ flags8text = "[8] Non-buoyant";
+ }
+ 1306
+ {
+ title = "Big Fern";
+ sprite = "JPLAB0";
+ width = 32;
+ height = 48;
+ }
+ 1307
+ {
+ title = "Jungle Palm";
+ sprite = "JPLAC0";
+ width = 32;
+ height = 48;
+ }
+ 1308
+ {
+ title = "Torch Flower";
+ sprite = "TFLOA0";
+ width = 14;
+ height = 110;
+ }
+ 1309
+ {
+ title = "RVZ1 Wall Vine (Long)";
+ sprite = "WVINALAR";
+ width = 1;
+ height = 288;
+ }
+ 1310
+ {
+ title = "RVZ1 Wall Vine (Short)";
+ sprite = "WVINBLBR";
+ width = 1;
+ height = 288;
+ }
+ }
+
+ botanicserenity
+ {
+ color = 10; // Green
+ title = "Botanic Serenity";
+ width = 16;
+ height = 32;
+ sprite = "BSZ1A0";
+ 1400
+ {
+ title = "Tall Flower (Red)";
+ sprite = "BSZ1A0";
+ }
+ 1401
+ {
+ title = "Tall Flower (Purple)";
+ sprite = "BSZ1B0";
+ }
+ 1402
+ {
+ title = "Tall Flower (Blue)";
+ sprite = "BSZ1C0";
+ }
+ 1403
+ {
+ title = "Tall Flower (Cyan)";
+ sprite = "BSZ1D0";
+ }
+ 1404
+ {
+ title = "Tall Flower (Yellow)";
+ sprite = "BSZ1E0";
+ }
+ 1405
+ {
+ title = "Tall Flower (Orange)";
+ sprite = "BSZ1F0";
+ }
+ 1410
+ {
+ title = "Medium Flower (Red)";
+ sprite = "BSZ2A0";
+ }
+ 1411
+ {
+ title = "Medium Flower (Purple)";
+ sprite = "BSZ2B0";
+ }
+ 1412
+ {
+ title = "Medium Flower (Blue)";
+ sprite = "BSZ2C0";
+ }
+ 1413
+ {
+ title = "Medium Flower (Cyan)";
+ sprite = "BSZ2D0";
+ }
+ 1414
+ {
+ title = "Medium Flower (Yellow)";
+ sprite = "BSZ2E0";
+ }
+ 1415
+ {
+ title = "Medium Flower (Orange)";
+ sprite = "BSZ2F0";
+ }
+ 1420
+ {
+ title = "Short Flower (Red)";
+ sprite = "BSZ3A0";
+ }
+ 1421
+ {
+ title = "Short Flower (Purple)";
+ sprite = "BSZ3B0";
+ }
+ 1422
+ {
+ title = "Short Flower (Blue)";
+ sprite = "BSZ3C0";
+ }
+ 1423
+ {
+ title = "Short Flower (Cyan)";
+ sprite = "BSZ3D0";
+ }
+ 1424
+ {
+ title = "Short Flower (Yellow)";
+ sprite = "BSZ3E0";
+ }
+ 1425
+ {
+ title = "Short Flower (Orange)";
+ sprite = "BSZ3F0";
+ }
+ 1430
+ {
+ title = "Tulip (Red)";
+ sprite = "BST1A0";
+ }
+ 1431
+ {
+ title = "Tulip (Purple)";
+ sprite = "BST2A0";
+ }
+ 1432
+ {
+ title = "Tulip (Blue)";
+ sprite = "BST3A0";
+ }
+ 1433
+ {
+ title = "Tulip (Cyan)";
+ sprite = "BST4A0";
+ }
+ 1434
+ {
+ title = "Tulip (Yellow)";
+ sprite = "BST5A0";
+ }
+ 1435
+ {
+ title = "Tulip (Orange)";
+ sprite = "BST6A0";
+ }
+ 1440
+ {
+ title = "Cluster (Red)";
+ sprite = "BSZ5A0";
+ }
+ 1441
+ {
+ title = "Cluster (Purple)";
+ sprite = "BSZ5B0";
+ }
+ 1442
+ {
+ title = "Cluster (Blue)";
+ sprite = "BSZ5C0";
+ }
+ 1443
+ {
+ title = "Cluster (Cyan)";
+ sprite = "BSZ5D0";
+ }
+ 1444
+ {
+ title = "Cluster (Yellow)";
+ sprite = "BSZ5E0";
+ }
+ 1445
+ {
+ title = "Cluster (Orange)";
+ sprite = "BSZ5F0";
+ }
+ 1450
+ {
+ title = "Bush (Red)";
+ sprite = "BSZ6A0";
+ }
+ 1451
+ {
+ title = "Bush (Purple)";
+ sprite = "BSZ6B0";
+ }
+ 1452
+ {
+ title = "Bush (Blue)";
+ sprite = "BSZ6C0";
+ }
+ 1453
+ {
+ title = "Bush (Cyan)";
+ sprite = "BSZ6D0";
+ }
+ 1454
+ {
+ title = "Bush (Yellow)";
+ sprite = "BSZ6E0";
+ }
+ 1455
+ {
+ title = "Bush (Orange)";
+ sprite = "BSZ6F0";
+ }
+ 1460
+ {
+ title = "Vine (Red)";
+ sprite = "BSZ7A0";
+ }
+ 1461
+ {
+ title = "Vine (Purple)";
+ sprite = "BSZ7B0";
+ }
+ 1462
+ {
+ title = "Vine (Blue)";
+ sprite = "BSZ7C0";
+ }
+ 1463
+ {
+ title = "Vine (Cyan)";
+ sprite = "BSZ7D0";
+ }
+ 1464
+ {
+ title = "Vine (Yellow)";
+ sprite = "BSZ7E0";
+ }
+ 1465
+ {
+ title = "Vine (Orange)";
+ sprite = "BSZ7F0";
+ }
+ 1470
+ {
+ title = "BSZ Shrub";
+ sprite = "BSZ8A0";
+ }
+ 1471
+ {
+ title = "BSZ Clover";
+ sprite = "BSZ8B0";
+ }
+ 1473
+ {
+ title = "Palm Tree (Big)";
+ width = 16;
+ height = 160;
+ sprite = "BSZ8D0";
+ }
+ 1475
+ {
+ title = "Palm Tree (Small)";
+ width = 16;
+ height = 80;
+ sprite = "BSZ8F0";
+ }
+ }
+
+ azuretemple
+ {
+ color = 10; // Green
+ title = "Azure Temple";
+
+ 1500
+ {
+ arrow = 1;
+ blocking = 2;
+ title = "Glaregoyle";
+ sprite = "BGARA1";
+ width = 16;
+ height = 40;
+ flags4text = "[4] Slides when pushed";
+ flags8text = "[8] Not pushable";
+ }
+ 1501
+ {
+ arrow = 1;
+ blocking = 2;
+ title = "Glaregoyle (Up)";
+ sprite = "BGARA1";
+ width = 16;
+ height = 40;
+ flags4text = "[4] Slides when pushed";
+ flags8text = "[8] Not pushable";
+ }
+ 1502
+ {
+ arrow = 1;
+ blocking = 2;
+ title = "Glaregoyle (Down)";
+ sprite = "BGARA1";
+ width = 16;
+ height = 40;
+ flags4text = "[4] Slides when pushed";
+ flags8text = "[8] Not pushable";
+ }
+ 1503
+ {
+ arrow = 1;
+ blocking = 2;
+ title = "Glaregoyle (Long)";
+ sprite = "BGARA1";
+ width = 16;
+ height = 40;
+ flags4text = "[4] Slides when pushed";
+ flags8text = "[8] Not pushable";
+ }
+ 1504
+ {
+ title = "ATZ Target";
+ sprite = "RCRYB0";
+ width = 24;
+ height = 32;
+ }
+ }
+
+ dreamhill
+ {
+ color = 10; // Green
+ title = "Dream Hill";
+
+ 1600
+ {
+ title = "Spring Tree";
+ sprite = "TRE6A0";
+ width = 16;
+ height = 32;
+ }
+ 1601
+ {
+ title = "Shleep";
+ sprite = "SHLPA0";
+ width = 24;
+ height = 32;
+ }
+ 1602
+ {
+ title = "Pian";
+ sprite = "NTPNALAR";
+ width = 16;
+ height = 32;
+ }
+ }
+
+ nightstrk
+ {
+ color = 13; // Pink
+ title = "NiGHTS Track";
+ width = 8;
+ height = 4096;
+ sprite = "UNKNA0";
+
+ 1700
+ {
+ title = "Axis";
+ sprite = "internal:axis1";
+ circle = 1;
+ unflippable = true;
+ ignoreZ = true;
+ flagsvaluetext = "Order";
+ angletext = "Radius/Direction";
+ parametertext = "Mare";
+ }
+ 1701
+ {
+ title = "Axis Transfer";
+ sprite = "internal:axis2";
+ unflippable = true;
+ ignoreZ = true;
+ flagsvaluetext = "Order";
+ parametertext = "Mare";
+ }
+ 1702
+ {
+ title = "Axis Transfer Line";
+ sprite = "internal:axis3";
+ unflippable = true;
+ ignoreZ = true;
+ flagsvaluetext = "Order";
+ parametertext = "Mare";
+ }
+ 1710
+ {
+ title = "Ideya Capture";
+ sprite = "CAPSA0";
+ width = 72;
+ height = 144;
+ angletext = "Rings";
+ parametertext = "Mare";
+ }
+ }
+
+ nights
+ {
+ color = 13; // Pink
+ title = "NiGHTS Items";
+ width = 16;
+ height = 32;
+
+ 1703
+ {
+ title = "Ideya Drone";
+ sprite = "NDRNA1";
+ width = 16;
+ height = 56;
+ flags1text = "[1] Align player to middle";
+ flags4text = "[4] Align player to top";
+ flags8text = "[8] Die upon time up";
+ angletext = "Time limit";
+ parametertext = "Height";
+ }
+ 1704
+ {
+ arrow = 1;
+ title = "NiGHTS Bumper";
+ sprite = "NBMPG3G7";
+ width = 32;
+ height = 64;
+ unflippable = true;
+ flagsvaluetext = "Pitch";
+ angletext = "Yaw";
+ }
+ 1705
+ {
+ arrow = 1;
+ title = "Hoop (Generic)";
+ sprite = "HOOPA0";
+ width = 80;
+ height = 160;
+ unflippable = true;
+ centerHitbox = true;
+ flagsvaluetext = "Height";
+ angletext = "Pitch/Yaw";
+ }
+ 1706
+ {
+ title = "Blue Sphere";
+ sprite = "SPHRA0";
+ width = 16;
+ height = 24;
+ flags8height = 24;
+ flags8text = "[8] Float";
+ unflippable = true;
+ }
+ 1707
+ {
+ title = "Super Paraloop";
+ sprite = "NPRUA0";
+ flags4text = "[4] Bonus time only";
+ flags8text = "[8] Spawn immediately";
+ }
+ 1708
+ {
+ title = "Drill Refill";
+ sprite = "NPRUB0";
+ flags4text = "[4] Bonus time only";
+ flags8text = "[8] Spawn immediately";
+ }
+ 1709
+ {
+ title = "Nightopian Helper";
+ sprite = "NPRUC0";
+ flags4text = "[4] Bonus time only";
+ flags8text = "[8] Spawn immediately";
+ }
+ 1711
+ {
+ title = "Extra Time";
+ sprite = "NPRUD0";
+ flags4text = "[4] Bonus time only";
+ flags8text = "[8] Spawn immediately";
+ }
+ 1712
+ {
+ title = "Link Freeze";
+ sprite = "NPRUE0";
+ flags4text = "[4] Bonus time only";
+ flags8text = "[8] Spawn immediately";
+ }
+ 1713
+ {
+ arrow = 1;
+ title = "Hoop (Customizable)";
+ flags1text = "[1] Radius +16";
+ flags2text = "[2] Radius +32";
+ flags4text = "[4] Radius +64";
+ flags8text = "[8] Radius +128";
+ sprite = "HOOPA0";
+ width = 80;
+ height = 160;
+ unflippable = true;
+ centerHitbox = true;
+ }
+ 1714
+ {
+ title = "Ideya Anchor Point";
+ sprite = "internal:axis1";
+ width = 8;
+ height = 16;
+ parametertext = "Ideya";
+ }
+ }
+
+ mario
+ {
+ color = 6; // Brown
+ title = "Mario";
+
+ 1800
+ {
+ title = "Coin";
+ sprite = "COINA0";
+ width = 16;
+ height = 24;
+ flags8height = 24;
+ flags8text = "[8] Float";
+ }
+ 1801
+ {
+ arrow = 1;
+ title = "Goomba";
+ sprite = "GOOMA0";
+ width = 24;
+ height = 32;
+ }
+ 1802
+ {
+ arrow = 1;
+ title = "Goomba (Blue)";
+ sprite = "BGOMA0";
+ width = 24;
+ height = 32;
+ }
+ 1803
+ {
+ title = "Fire Flower";
+ sprite = "FFWRB0";
+ width = 16;
+ height = 32;
+ }
+ 1804
+ {
+ title = "Koopa Shell";
+ sprite = "SHLLA1";
+ width = 16;
+ height = 20;
+ }
+ 1805
+ {
+ title = "Puma (Jumping Fireball)";
+ sprite = "PUMAA0";
+ width = 8;
+ height = 16;
+ angletext = "Jump strength";
+ }
+ 1806
+ {
+ title = "King Bowser";
+ sprite = "KOOPA0";
+ width = 16;
+ height = 48;
+ }
+ 1807
+ {
+ title = "Axe";
+ sprite = "MAXEA0";
+ width = 8;
+ height = 16;
+ }
+ 1808
+ {
+ title = "Bush (Short)";
+ sprite = "MUS1A0";
+ width = 16;
+ height = 32;
+ }
+ 1809
+ {
+ title = "Bush (Tall)";
+ sprite = "MUS2A0";
+ width = 16;
+ height = 32;
+ }
+ 1810
+ {
+ title = "Toad";
+ sprite = "TOADA0";
+ width = 8;
+ height = 32;
+ }
+ }
+
+ christmasdisco
+ {
+ color = 10; // Green
+ title = "Christmas & Disco";
+
+ 1850
+ {
+ title = "Christmas Pole";
+ sprite = "XMS1A0";
+ width = 16;
+ height = 40;
+ }
+ 1851
+ {
+ title = "Candy Cane";
+ sprite = "XMS2A0";
+ width = 8;
+ height = 32;
+ }
+ 1852
+ {
+ blocking = 2;
+ title = "Snowman";
+ sprite = "XMS3A0";
+ width = 16;
+ height = 64;
+ flags4text = "[4] Slides when pushed";
+ flags8text = "[8] Not pushable";
+ }
+ 1853
+ {
+ blocking = 2;
+ title = "Snowman (With Hat)";
+ sprite = "XMS3B0";
+ width = 16;
+ height = 80;
+ flags4text = "[4] Slides when pushed";
+ flags8text = "[8] Not pushable";
+ }
+ 1854
+ {
+ title = "Lamp Post";
+ sprite = "XMS4A0";
+ width = 8;
+ height = 120;
+ }
+ 1855
+ {
+ title = "Lamp Post (Snow)";
+ sprite = "XMS4B0";
+ width = 8;
+ height = 120;
+ }
+ 1856
+ {
+ title = "Hanging Star";
+ sprite = "XMS5A0";
+ width = 4;
+ height = 80;
+ hangs = 1;
+ }
+ 1857
+ {
+ title = "Berry Bush (Snow)";
+ sprite = "BUS1B0";
+ width = 16;
+ height = 32;
+ }
+ 1858
+ {
+ title = "Bush (Snow)";
+ sprite = "BUS2B0";
+ width = 16;
+ height = 32;
+ }
+ 1859
+ {
+ title = "Blueberry Bush (Snow)";
+ sprite = "BUS3B0";
+ width = 16;
+ height = 32;
+ }
+ 1875
+ {
+ title = "Disco Ball";
+ sprite = "DBALA0";
+ width = 16;
+ height = 54;
+ hangs = 1;
+ }
+ 1876
+ {
+ arrow = 1;
+ blocking = 2;
+ title = "Eggman Disco Statue";
+ sprite = "ESTAB1";
+ width = 20;
+ height = 96;
+ flags4text = "[4] Slides when pushed";
+ flags8text = "[8] Not pushable";
+ }
+ }
+
+ stalagmites
+ {
+ color = 10; // Green
+ title = "Stalagmites";
+ width = 16;
+ height = 40;
+
+ 1900
+ {
+ title = "Brown Stalagmite (Tall)";
+ sprite = "STLGA0";
+ width = 16;
+ height = 40;
+ }
+ 1901
+ {
+ title = "Brown Stalagmite";
+ sprite = "STLGB0";
+ width = 16;
+ height = 40;
+ }
+ 1902
+ {
+ title = "Orange Stalagmite (Tall)";
+ sprite = "STLGC0";
+ width = 16;
+ height = 40;
+ }
+ 1903
+ {
+ title = "Orange Stalagmite";
+ sprite = "STLGD0";
+ width = 16;
+ height = 40;
+ }
+ 1904
+ {
+ title = "Red Stalagmite (Tall)";
+ sprite = "STLGE0";
+ width = 16;
+ height = 40;
+ }
+ 1905
+ {
+ title = "Red Stalagmite";
+ sprite = "STLGF0";
+ width = 16;
+ height = 40;
+ }
+ 1906
+ {
+ title = "Gray Stalagmite (Tall)";
+ sprite = "STLGG0";
+ width = 24;
+ height = 96;
+ }
+ 1907
+ {
+ title = "Gray Stalagmite";
+ sprite = "STLGH0";
+ width = 16;
+ height = 40;
+ }
+ 1908
+ {
+ title = "Blue Stalagmite (Tall)";
+ sprite = "STLGI0";
+ width = 16;
+ height = 40;
+ }
+ 1909
+ {
+ title = "Blue Stalagmite";
+ sprite = "STLGJ0";
+ width = 16;
+ height = 40;
+ }
+ }
+
+ hauntedheights
+ {
+ color = 10; // Green
+ title = "Haunted Heights";
+
+ 2000
+ {
+ title = "Smashing Spikeball";
+ sprite = "FMCEA0";
+ width = 18;
+ height = 28;
+ angletext = "Initial delay";
+ }
+ 2001
+ {
+ title = "HHZ Grass";
+ sprite = "HHZMA0";
+ width = 16;
+ height = 40;
+ }
+ 2002
+ {
+ title = "HHZ Tentacle 1";
+ sprite = "HHZMB0";
+ width = 16;
+ height = 40;
+ }
+ 2003
+ {
+ title = "HHZ Tentacle 2";
+ sprite = "HHZMC0";
+ width = 16;
+ height = 40;
+ }
+ 2004
+ {
+ title = "HHZ Stalagmite (Tall)";
+ sprite = "HHZME0";
+ width = 16;
+ height = 40;
+ }
+ 2005
+ {
+ title = "HHZ Stalagmite (Short)";
+ sprite = "HHZMF0";
+ width = 16;
+ height = 40;
+ }
+ 2006
+ {
+ title = "Jack-o'-lantern 1";
+ sprite = "PUMKA0";
+ width = 16;
+ height = 40;
+ flags1text = "Don't flicker";
+ }
+ 2007
+ {
+ title = "Jack-o'-lantern 2";
+ sprite = "PUMKB0";
+ width = 16;
+ height = 40;
+ flags1text = "Don't flicker";
+ }
+ 2008
+ {
+ title = "Jack-o'-lantern 3";
+ sprite = "PUMKC0";
+ width = 16;
+ height = 40;
+ flags1text = "Don't flicker";
+ }
+ 2009
+ {
+ title = "Purple Mushroom";
+ sprite = "SHRMD0";
+ width = 16;
+ height = 48;
+ }
+ 2010
+ {
+ title = "HHZ Tree";
+ sprite = "HHPLC0";
+ width = 12;
+ height = 40;
+ }
+ }
+
+ frozenhillside
+ {
+ color = 10; // Green
+ title = "Frozen Hillside";
+
+ 2100
+ {
+ title = "Ice Shard (Small)";
+ sprite = "FHZIA0";
+ width = 8;
+ height = 32;
+ }
+ 2101
+ {
+ title = "Ice Shard (Large)";
+ sprite = "FHZIB0";
+ width = 8;
+ height = 32;
+ }
+ 2102
+ {
+ title = "Crystal Tree (Aqua)";
+ sprite = "TRE3A0";
+ width = 20;
+ height = 200;
+ }
+ 2103
+ {
+ title = "Crystal Tree (Pink)";
+ sprite = "TRE3B0";
+ width = 20;
+ height = 200;
+ }
+ 2104
+ {
+ title = "Amy Cameo";
+ sprite = "ROSYA1";
+ width = 16;
+ height = 48;
+ flags1text = "[1] Grayscale mode";
+ }
+ 2105
+ {
+ title = "Mistletoe";
+ sprite = "XMS6A0";
+ width = 52;
+ height = 106;
+ }
+ }
+
+ flickies
+ {
+ color = 10; // Green
+ title = "Flickies";
+ width = 8;
+ height = 20;
+ flags1text = "[1] Move aimlessly";
+ flags4text = "[4] No movement";
+ flags8text = "[8] Hop";
+ angletext = "Radius";
+
+ 2200
+ {
+ title = "Bluebird";
+ sprite = "FL01A1";
+ }
+ 2201
+ {
+ title = "Rabbit";
+ sprite = "FL02A1";
+ }
+ 2202
+ {
+ title = "Chicken";
+ sprite = "FL03A1";
+ }
+ 2203
+ {
+ title = "Seal";
+ sprite = "FL04A1";
+ }
+ 2204
+ {
+ title = "Pig";
+ sprite = "FL05A1";
+ }
+ 2205
+ {
+ title = "Chipmunk";
+ sprite = "FL06A1";
+ }
+ 2206
+ {
+ title = "Penguin";
+ sprite = "FL07A1";
+ }
+ 2207
+ {
+ title = "Fish";
+ sprite = "FL08A1";
+ parametertext = "Color";
+ }
+ 2208
+ {
+ title = "Ram";
+ sprite = "FL09A1";
+ }
+ 2209
+ {
+ title = "Puffin";
+ sprite = "FL10A1";
+ }
+ 2210
+ {
+ title = "Cow";
+ sprite = "FL11A1";
+ }
+ 2211
+ {
+ title = "Rat";
+ sprite = "FL12A1";
+ }
+ 2212
+ {
+ title = "Bear";
+ sprite = "FL13A1";
+ }
+ 2213
+ {
+ title = "Dove";
+ sprite = "FL14A1";
+ }
+ 2214
+ {
+ title = "Cat";
+ sprite = "FL15A1";
+ }
+ 2215
+ {
+ title = "Canary";
+ sprite = "FL16A1";
+ }
+ 2216
+ {
+ title = "Spider";
+ sprite = "FS01A1";
+ }
+ 2217
+ {
+ title = "Bat";
+ sprite = "FS02A0";
+ }
+ }
+}
+
+//Default things filters
+thingsfilters
+{
+
+ filter0
+ {
+ name = "Player starts";
+ category = "starts";
+ type = -1;
+ }
+
+
+ filter1
+ {
+ name = "Enemies";
+ category = "enemies";
+ type = -1;
+
+ }
+
+
+ filter2
+ {
+ name = "NiGHTS Track";
+ category = "nightstrk";
+ type = -1;
+
+ }
+
+
+ filter3
+ {
+ name = "Normal Gravity";
+ category = "";
+ type = -1;
+
+ fields
+ {
+ 2 = false;
+ }
+
+ }
+
+
+ filter4
+ {
+ name = "Reverse Gravity";
+ category = "";
+ type = -1;
+
+ fields
+ {
+ 2 = true;
+ }
+
+ }
+}
diff --git a/libs/libopenmpt/SRB2NOTE.md b/libs/libopenmpt/SRB2NOTE.md
index d664ddd7e49930e69cdf6c81d7981568fb2e3d78..7eac9183bc1fbac89647e64404c04458ae10255a 100644
--- a/libs/libopenmpt/SRB2NOTE.md
+++ b/libs/libopenmpt/SRB2NOTE.md
@@ -1,6 +1,6 @@
# libopenmpt mingw-w64 binary info
-Current built version as of 2019/05/23 is 0.4.4+r11531.pkg
+Current built version as of 2019/09/27 is 0.4.7+r12088.pkg
* mingw binaries (.dll): `bin/[x86 or x86_64]/mingw`
* mingw import libraries (.dll.a): `lib/[x86 or x86_64]/mingw`
diff --git a/libs/libopenmpt/bin/x86/libopenmpt.dll b/libs/libopenmpt/bin/x86/libopenmpt.dll
index 0fc9e7656d5681b59df4a605b5f39ffe59fd55a9..8ad64fdfd94a9ca0008c3760dd8f57904beb14a6 100644
Binary files a/libs/libopenmpt/bin/x86/libopenmpt.dll and b/libs/libopenmpt/bin/x86/libopenmpt.dll differ
diff --git a/libs/libopenmpt/bin/x86/mingw/libopenmpt.dll b/libs/libopenmpt/bin/x86/mingw/libopenmpt.dll
index 5fa3642566039530a3ddf633d45617ef9d93f9bd..945b475e62878802d824f500b127185a8be6498e 100644
Binary files a/libs/libopenmpt/bin/x86/mingw/libopenmpt.dll and b/libs/libopenmpt/bin/x86/mingw/libopenmpt.dll differ
diff --git a/libs/libopenmpt/bin/x86/openmpt-mpg123.dll b/libs/libopenmpt/bin/x86/openmpt-mpg123.dll
index 79148a40ef3cef8e0f745ff14d1ccc1ac4aab025..b068ddd0c8d7d56bcbac4ea727cdeda8b6a5de03 100644
Binary files a/libs/libopenmpt/bin/x86/openmpt-mpg123.dll and b/libs/libopenmpt/bin/x86/openmpt-mpg123.dll differ
diff --git a/libs/libopenmpt/bin/x86/openmpt-ogg.dll b/libs/libopenmpt/bin/x86/openmpt-ogg.dll
index 6b5a42e8f1fd11353588880cd36c649993eebe9e..a5b4600637793a541e61f866734ec3720fcf664a 100644
Binary files a/libs/libopenmpt/bin/x86/openmpt-ogg.dll and b/libs/libopenmpt/bin/x86/openmpt-ogg.dll differ
diff --git a/libs/libopenmpt/bin/x86/openmpt-vorbis.dll b/libs/libopenmpt/bin/x86/openmpt-vorbis.dll
index 486b30731c234696ad1feb3ca9740eebbd390668..1ebed9b0e2401648f7f85c5adb7f8fca854b0832 100644
Binary files a/libs/libopenmpt/bin/x86/openmpt-vorbis.dll and b/libs/libopenmpt/bin/x86/openmpt-vorbis.dll differ
diff --git a/libs/libopenmpt/bin/x86/openmpt-zlib.dll b/libs/libopenmpt/bin/x86/openmpt-zlib.dll
index b6e028ab4f31b40c620983e73b76b747f9f3249e..41bc22d2f554108782fee07ff564812aa705dca7 100644
Binary files a/libs/libopenmpt/bin/x86/openmpt-zlib.dll and b/libs/libopenmpt/bin/x86/openmpt-zlib.dll differ
diff --git a/libs/libopenmpt/bin/x86_64/libopenmpt.dll b/libs/libopenmpt/bin/x86_64/libopenmpt.dll
index 536492798e9167241fc526d010f6ed25e9d0686e..ffbb4b19a0224601264f85de933893aad9aae860 100644
Binary files a/libs/libopenmpt/bin/x86_64/libopenmpt.dll and b/libs/libopenmpt/bin/x86_64/libopenmpt.dll differ
diff --git a/libs/libopenmpt/bin/x86_64/mingw/libopenmpt.dll b/libs/libopenmpt/bin/x86_64/mingw/libopenmpt.dll
index 3f6bea95f72b0a8ee68a41128f8bb700918d568d..018ae827657b1c1b550d58129a09d495cbcddfd4 100644
Binary files a/libs/libopenmpt/bin/x86_64/mingw/libopenmpt.dll and b/libs/libopenmpt/bin/x86_64/mingw/libopenmpt.dll differ
diff --git a/libs/libopenmpt/bin/x86_64/openmpt-mpg123.dll b/libs/libopenmpt/bin/x86_64/openmpt-mpg123.dll
index f96d446f25c61df1368c4219324e3a2bf6138723..9a0fca8745a180ffe92ea8c05bff042665092bd4 100644
Binary files a/libs/libopenmpt/bin/x86_64/openmpt-mpg123.dll and b/libs/libopenmpt/bin/x86_64/openmpt-mpg123.dll differ
diff --git a/libs/libopenmpt/bin/x86_64/openmpt-ogg.dll b/libs/libopenmpt/bin/x86_64/openmpt-ogg.dll
index 3fd9514147973966faf77c7c2e08fb61c3fa4878..4bc1a336b89cf18fcf45b361bbabc7a13a7120f9 100644
Binary files a/libs/libopenmpt/bin/x86_64/openmpt-ogg.dll and b/libs/libopenmpt/bin/x86_64/openmpt-ogg.dll differ
diff --git a/libs/libopenmpt/bin/x86_64/openmpt-vorbis.dll b/libs/libopenmpt/bin/x86_64/openmpt-vorbis.dll
index 56047c82fbf4ff4eecc148718ed2b9fc1882a9da..ebe8ef9b3c05737e2d8bf626bd8a420a037ea29b 100644
Binary files a/libs/libopenmpt/bin/x86_64/openmpt-vorbis.dll and b/libs/libopenmpt/bin/x86_64/openmpt-vorbis.dll differ
diff --git a/libs/libopenmpt/bin/x86_64/openmpt-zlib.dll b/libs/libopenmpt/bin/x86_64/openmpt-zlib.dll
index 562d8e6a9e89b933d2ea4ef30ae2d7e500e35c97..319b646ff393aa2bbf3137fde1518da2bb9faea4 100644
Binary files a/libs/libopenmpt/bin/x86_64/openmpt-zlib.dll and b/libs/libopenmpt/bin/x86_64/openmpt-zlib.dll differ
diff --git a/libs/libopenmpt/changelog.md b/libs/libopenmpt/changelog.md
index 9847be1197908bc6962277f54d7a68f0b7d95a79..0b727955878745b2b0fdafc28e6eed682f597e12 100644
--- a/libs/libopenmpt/changelog.md
+++ b/libs/libopenmpt/changelog.md
@@ -5,6 +5,44 @@ Changelog {#changelog}
For fully detailed change log, please see the source repository directly. This
is just a high-level summary.
+### libopenmpt 0.4.7 (2019-09-23)
+
+ * [**Bug**] Compilation fix for various platforms that do not provide
+ `std::aligned_alloc` in C++17 mode. The problematic dependency has been
+ removed. This should fix build problems on MinGW, OpenBSD, Haiku, and others
+ for good.
+
+ * J2B: Ignore notes with non-existing instrument (fixes Ending.j2b).
+
+ * mpg123: Update to v1.25.13 (2019-08-24).
+ * ogg: Update to v1.3.4. (2019-08-31).
+ * flac: Update to v1.3.3. (2019-08-04).
+
+### libopenmpt 0.4.6 (2019-08-10)
+
+ * [**Bug**] Compilation fix for OpenBSD.
+ * [**Bug**] Compilation fix for NO_PLUGINS being defined.
+
+ * in_openmpt: Correct documentation. `openmpt-mpg123.dll` must be placed into
+ the Winamp directory.
+
+ * Detect IT files unpacked with early UNMO3 versions.
+
+ * mpg123: Update to v1.25.11 (2019-07-18).
+ * minimp3: Update to commit 977514a6dfc4960d819a103f43b358e58ac6c28f
+ (2019-07-24).
+ * miniz: Update to v2.1.0 (2019-05-05).
+ * stb_vorbis: Update to v1.17 (2019-08-09).
+
+### libopenmpt 0.4.5 (2019-05-27)
+
+ * [**Sec**] Possible crash during playback due out-of-bounds read in XM and
+ MT2 files (r11608).
+
+ * Breaking out of a sustain loop through Note-Off sometimes didn't continue in
+ the regular sample loop.
+ * Seeking did not stop notes playing with XM Key Off (Kxx) effect.
+
### libopenmpt 0.4.4 (2019-04-07)
* [**Bug**] Channel VU meters were swapped.
diff --git a/libs/libopenmpt/inc/libopenmpt/libopenmpt_version.h b/libs/libopenmpt/inc/libopenmpt/libopenmpt_version.h
index 5ca7f21d0ff4a776d8011fc72b67d140aa237b9d..4bb90278c6c903d9d62e4dbf752b79846c950307 100644
--- a/libs/libopenmpt/inc/libopenmpt/libopenmpt_version.h
+++ b/libs/libopenmpt/inc/libopenmpt/libopenmpt_version.h
@@ -19,7 +19,7 @@
/*! \brief libopenmpt minor version number */
#define OPENMPT_API_VERSION_MINOR 4
/*! \brief libopenmpt patch version number */
-#define OPENMPT_API_VERSION_PATCH 4
+#define OPENMPT_API_VERSION_PATCH 7
/*! \brief libopenmpt pre-release tag */
#define OPENMPT_API_VERSION_PREREL ""
/*! \brief libopenmpt pre-release flag */
diff --git a/libs/libopenmpt/lib/x86/libopenmpt.lib b/libs/libopenmpt/lib/x86/libopenmpt.lib
index 3f814528acc851cec1e764547570756c24d65225..c81c4c4edc15454f65e9f36738e17591a4ec8d15 100644
Binary files a/libs/libopenmpt/lib/x86/libopenmpt.lib and b/libs/libopenmpt/lib/x86/libopenmpt.lib differ
diff --git a/libs/libopenmpt/lib/x86/mingw/libopenmpt.dll.a b/libs/libopenmpt/lib/x86/mingw/libopenmpt.dll.a
index e3fa0c58fcd082319ea3b6365cb566dd7a3efa24..1d76372535b4a432a259ab2fc3a539b3af803c2d 100644
Binary files a/libs/libopenmpt/lib/x86/mingw/libopenmpt.dll.a and b/libs/libopenmpt/lib/x86/mingw/libopenmpt.dll.a differ
diff --git a/libs/libopenmpt/lib/x86_64/libopenmpt.lib b/libs/libopenmpt/lib/x86_64/libopenmpt.lib
index 75e3849fac966542b457684ca6f55a41237211d3..216d93b45b32cc968decb30aa240839bef2c13d6 100644
Binary files a/libs/libopenmpt/lib/x86_64/libopenmpt.lib and b/libs/libopenmpt/lib/x86_64/libopenmpt.lib differ
diff --git a/libs/libopenmpt/lib/x86_64/mingw/libopenmpt.dll.a b/libs/libopenmpt/lib/x86_64/mingw/libopenmpt.dll.a
index 72940372211829f26b413075496f7e201d5fb357..c6eda119fecb39b7f19c5c43e2c43fbeb88a0716 100644
Binary files a/libs/libopenmpt/lib/x86_64/mingw/libopenmpt.dll.a and b/libs/libopenmpt/lib/x86_64/mingw/libopenmpt.dll.a differ
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 723407d86fa17529d138634c3e6b48f2338f2557..fb1bd8afb14c03f35ef3f891dad0761d3da8c88e 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -423,7 +423,11 @@ if(${SRB2_CONFIG_HWRENDER})
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_light.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2load.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md3load.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_model.c
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_trick.c
+ ${CMAKE_CURRENT_SOURCE_DIR}/hardware/u_list.c
)
set (SRB2_HWRENDER_HEADERS
@@ -437,6 +441,10 @@ if(${SRB2_CONFIG_HWRENDER})
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_light.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_main.h
${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md2load.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_md3load.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/hardware/hw_model.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/hardware/u_list.h
)
set(SRB2_R_OPENGL_SOURCES
diff --git a/src/Makefile b/src/Makefile
index 3015aa5d6b40bfa231e5faa08d7d997cb4986ecc..c5eb8b4a3ac2e7f69cb33b40e007125f448b88d1 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -86,10 +86,7 @@
D_DIR?=../bin/Resources
D_FILES=$(D_DIR)/srb2.pk3 \
$(D_DIR)/player.dta \
- $(D_DIR)/rings.wpn \
- $(D_DIR)/drill.dta \
- $(D_DIR)/soar.dta \
- $(D_DIR)/zones.dta \
+ $(D_DIR)/zones.pk3 \
$(D_DIR)/music.dta \
PKG_CONFIG?=pkg-config
@@ -229,7 +226,8 @@ else
#OPTS+=-DUSE_PALETTED_TEXTURE
OPTS+=-DHWRENDER
OBJS+=$(OBJDIR)/hw_bsp.o $(OBJDIR)/hw_draw.o $(OBJDIR)/hw_light.o \
- $(OBJDIR)/hw_main.o $(OBJDIR)/hw_clip.o $(OBJDIR)/hw_md2.o $(OBJDIR)/hw_cache.o $(OBJDIR)/hw_trick.o
+ $(OBJDIR)/hw_main.o $(OBJDIR)/hw_clip.o $(OBJDIR)/hw_md2.o $(OBJDIR)/hw_cache.o $(OBJDIR)/hw_trick.o \
+ $(OBJDIR)/hw_md2load.o $(OBJDIR)/hw_md3load.o $(OBJDIR)/hw_model.o $(OBJDIR)/u_list.o
endif
ifdef NOHS
@@ -649,16 +647,18 @@ ifdef MINGW
$(OBJDIR)/r_opengl.o: hardware/r_opengl/r_opengl.c hardware/r_opengl/r_opengl.h \
doomdef.h doomtype.h g_state.h m_swap.h hardware/hw_drv.h screen.h \
command.h hardware/hw_data.h hardware/hw_glide.h hardware/hw_defs.h \
- hardware/hw_md2.h hardware/hw_glob.h hardware/hw_main.h hardware/hw_clip.h am_map.h \
- d_event.h d_player.h p_pspr.h m_fixed.h tables.h info.h d_think.h \
+ hardware/hw_md2.h hardware/hw_glob.h hardware/hw_main.h hardware/hw_clip.h \
+ hardware/hw_md2load.h hardware/hw_md3load.h hardware/hw_model.h hardware/u_list.h \
+ am_map.h d_event.h d_player.h p_pspr.h m_fixed.h tables.h info.h d_think.h \
p_mobj.h doomdata.h d_ticcmd.h r_defs.h hardware/hw_dll.h
$(CC) $(CFLAGS) $(WFLAGS) -c $< -o $@
else
$(OBJDIR)/r_opengl.o: hardware/r_opengl/r_opengl.c hardware/r_opengl/r_opengl.h \
doomdef.h doomtype.h g_state.h m_swap.h hardware/hw_drv.h screen.h \
command.h hardware/hw_data.h hardware/hw_glide.h hardware/hw_defs.h \
- hardware/hw_md2.h hardware/hw_glob.h hardware/hw_main.h hardware/hw_clip.h am_map.h \
- d_event.h d_player.h p_pspr.h m_fixed.h tables.h info.h d_think.h \
+ hardware/hw_md2.h hardware/hw_glob.h hardware/hw_main.h hardware/hw_clip.h \
+ hardware/hw_md2load.h hardware/hw_md3load.h hardware/hw_model.h hardware/u_list.h \
+ am_map.h d_event.h d_player.h p_pspr.h m_fixed.h tables.h info.h d_think.h \
p_mobj.h doomdata.h d_ticcmd.h r_defs.h hardware/hw_dll.h
$(CC) $(CFLAGS) $(WFLAGS) -I/usr/X11R6/include -c $< -o $@
endif
@@ -736,16 +736,18 @@ ifndef NOHW
$(OBJDIR)/r_opengl.o: hardware/r_opengl/r_opengl.c hardware/r_opengl/r_opengl.h \
doomdef.h doomtype.h g_state.h m_swap.h hardware/hw_drv.h screen.h \
command.h hardware/hw_data.h hardware/hw_glide.h hardware/hw_defs.h \
- hardware/hw_md2.h hardware/hw_glob.h hardware/hw_main.h hardware/hw_clip.h am_map.h \
- d_event.h d_player.h p_pspr.h m_fixed.h tables.h info.h d_think.h \
+ hardware/hw_md2.h hardware/hw_glob.h hardware/hw_main.h hardware/hw_clip.h \
+ hardware/hw_md2load.h hardware/hw_md3load.h hardware/hw_model.h hardware/u_list.h \
+ am_map.h d_event.h d_player.h p_pspr.h m_fixed.h tables.h info.h d_think.h \
p_mobj.h doomdata.h d_ticcmd.h r_defs.h hardware/hw_dll.h
$(CC) $(CFLAGS) $(WFLAGS) -D_WINDOWS -mwindows -c $< -o $@
$(OBJDIR)/ogl_win.o: hardware/r_opengl/ogl_win.c hardware/r_opengl/r_opengl.h \
doomdef.h doomtype.h g_state.h m_swap.h hardware/hw_drv.h screen.h \
command.h hardware/hw_data.h hardware/hw_glide.h hardware/hw_defs.h \
- hardware/hw_md2.h hardware/hw_glob.h hardware/hw_main.h hardware/hw_clip.h am_map.h \
- d_event.h d_player.h p_pspr.h m_fixed.h tables.h info.h d_think.h \
+ hardware/hw_md2.h hardware/hw_glob.h hardware/hw_main.h hardware/hw_clip.h \
+ hardware/hw_md2load.h hardware/hw_md3load.h hardware/hw_model.h hardware/u_list.h \
+ am_map.h d_event.h d_player.h p_pspr.h m_fixed.h tables.h info.h d_think.h \
p_mobj.h doomdata.h d_ticcmd.h r_defs.h hardware/hw_dll.h
$(CC) $(CFLAGS) $(WFLAGS) -D_WINDOWS -mwindows -c $< -o $@
endif
diff --git a/src/b_bot.c b/src/b_bot.c
index 17211b3532d2ace7448fd3a7f1cafac82a1bef9e..651aeb03d6f1911be09114118ff034b54367d8c2 100644
--- a/src/b_bot.c
+++ b/src/b_bot.c
@@ -140,6 +140,9 @@ void B_BuildTiccmd(player_t *player, ticcmd_t *cmd)
void B_KeysToTiccmd(mobj_t *mo, ticcmd_t *cmd, boolean forward, boolean backward, boolean left, boolean right, boolean strafeleft, boolean straferight, boolean jump, boolean spin)
{
+ // don't try to do stuff if your sonic is in a minecart or something
+ if (players[consoleplayer].powers[pw_carry])
+ return;
// Turn the virtual keypresses into ticcmd_t.
if (twodlevel || mo->flags2 & MF2_TWOD) {
if (players[consoleplayer].climbing
@@ -218,7 +221,12 @@ boolean B_CheckRespawn(player_t *player)
return false;
// Low ceiling, do not want!
- if (sonic->ceilingz - sonic->z < 2*sonic->height)
+ if (sonic->eflags & MFE_VERTICALFLIP)
+ {
+ if (sonic->z - sonic->floorz < (sonic->player->exiting ? 5 : 2)*sonic->height)
+ return false;
+ }
+ else if (sonic->ceilingz - sonic->z < (sonic->player->exiting ? 6 : 3)*sonic->height)
return false;
// If you're dead, wait a few seconds to respawn.
@@ -252,11 +260,11 @@ void B_RespawnBot(INT32 playernum)
y = sonic->y;
if (sonic->eflags & MFE_VERTICALFLIP) {
tails->eflags |= MFE_VERTICALFLIP;
- z = sonic->z - FixedMul(512*FRACUNIT,sonic->scale);
+ z = sonic->z - (512*sonic->scale);
if (z < sonic->floorz)
z = sonic->floorz;
} else {
- z = sonic->z + sonic->height + FixedMul(512*FRACUNIT,sonic->scale);
+ z = sonic->z + sonic->height + (512*sonic->scale);
if (z > sonic->ceilingz - sonic->height)
z = sonic->ceilingz - sonic->height;
}
diff --git a/src/command.c b/src/command.c
index cfb36f02fbf8e0d56694c856e51b5ed2641dd7e4..d39730f98e74ab976b0a529b373f46f8f869b41e 100644
--- a/src/command.c
+++ b/src/command.c
@@ -49,6 +49,7 @@ static void COM_Exec_f(void);
static void COM_Wait_f(void);
static void COM_Help_f(void);
static void COM_Toggle_f(void);
+static void COM_Add_f(void);
static void CV_EnforceExecVersion(void);
static boolean CV_FilterVarByVersion(consvar_t *v, const char *valstr);
@@ -291,6 +292,7 @@ void COM_Init(void)
COM_AddCommand("wait", COM_Wait_f);
COM_AddCommand("help", COM_Help_f);
COM_AddCommand("toggle", COM_Toggle_f);
+ COM_AddCommand("add", COM_Add_f);
RegisterNetXCmd(XD_NETVAR, Got_NetVar);
}
@@ -709,15 +711,21 @@ static void COM_Help_f(void)
if (COM_Argc() > 1)
{
- cvar = CV_FindVar(COM_Argv(1));
+ const char *help = COM_Argv(1);
+ cvar = CV_FindVar(help);
if (cvar)
{
- CONS_Printf(M_GetText("Variable %s:\n"), cvar->name);
+ boolean floatmode = false;
+ const char *cvalue = NULL;
+ CONS_Printf("\x82""Variable %s:\n", cvar->name);
CONS_Printf(M_GetText(" flags :"));
if (cvar->flags & CV_SAVE)
CONS_Printf("AUTOSAVE ");
if (cvar->flags & CV_FLOAT)
+ {
CONS_Printf("FLOAT ");
+ floatmode = true;
+ }
if (cvar->flags & CV_NETVAR)
CONS_Printf("NETVAR ");
if (cvar->flags & CV_CALL)
@@ -727,59 +735,113 @@ static void COM_Help_f(void)
CONS_Printf("\n");
if (cvar->PossibleValue)
{
- if (stricmp(cvar->PossibleValue[0].strvalue, "MIN") == 0)
- {
- for (i = 1; cvar->PossibleValue[i].strvalue != NULL; i++)
- if (!stricmp(cvar->PossibleValue[i].strvalue, "MAX"))
- break;
- CONS_Printf(M_GetText(" range from %d to %d\n"), cvar->PossibleValue[0].value,
- cvar->PossibleValue[i].value);
- CONS_Printf(M_GetText(" Current value: %d\n"), cvar->value);
- }
+ CONS_Printf(" Possible values:\n");
+ if (cvar->PossibleValue == CV_YesNo)
+ CONS_Printf(" Yes or No (On or Off, 1 or 0)\n");
+ else if (cvar->PossibleValue == CV_OnOff)
+ CONS_Printf(" On or Off (Yes or No, 1 or 0)\n");
else
{
- const char *cvalue = NULL;
- CONS_Printf(M_GetText(" possible value : %s\n"), cvar->name);
+#define MINVAL 0
+#define MAXVAL 1
+ if (!stricmp(cvar->PossibleValue[MINVAL].strvalue, "MIN"))
+ {
+ if (floatmode)
+ CONS_Printf(" range from %f to %f\n", FIXED_TO_FLOAT(cvar->PossibleValue[MINVAL].value),
+ FIXED_TO_FLOAT(cvar->PossibleValue[MAXVAL].value));
+ else
+ CONS_Printf(" range from %d to %d\n", cvar->PossibleValue[MINVAL].value,
+ cvar->PossibleValue[MAXVAL].value);
+ i = MAXVAL+1;
+ }
+#undef MINVAL
+#undef MAXVAL
+
+ //CONS_Printf(M_GetText(" possible value : %s\n"), cvar->name);
while (cvar->PossibleValue[i].strvalue)
{
- CONS_Printf(" %-2d : %s\n", cvar->PossibleValue[i].value,
- cvar->PossibleValue[i].strvalue);
+ if (floatmode)
+ CONS_Printf(" %-2f : %s\n", FIXED_TO_FLOAT(cvar->PossibleValue[i].value),
+ cvar->PossibleValue[i].strvalue);
+ else
+ CONS_Printf(" %-2d : %s\n", cvar->PossibleValue[i].value,
+ cvar->PossibleValue[i].strvalue);
if (cvar->PossibleValue[i].value == cvar->value)
cvalue = cvar->PossibleValue[i].strvalue;
i++;
}
- if (cvalue)
- CONS_Printf(M_GetText(" Current value: %s\n"), cvalue);
- else
- CONS_Printf(M_GetText(" Current value: %d\n"), cvar->value);
}
}
+
+ if (cvalue)
+ CONS_Printf(" Current value: %s\n", cvalue);
+ else if (cvar->string)
+ CONS_Printf(" Current value: %s\n", cvar->string);
else
- CONS_Printf(M_GetText(" Current value: %d\n"), cvar->value);
+ CONS_Printf(" Current value: %d\n", cvar->value);
}
else
- CONS_Printf(M_GetText("No help for this command/variable\n"));
+ {
+ for (cmd = com_commands; cmd; cmd = cmd->next)
+ {
+ if (strcmp(cmd->name, help))
+ continue;
+
+ CONS_Printf("\x82""Command %s:\n", cmd->name);
+ CONS_Printf(" help is not available for commands");
+ CONS_Printf("\x82""\nCheck wiki.srb2.org for more or try typing <name> without arguments\n");
+ return;
+ }
+
+ CONS_Printf("No exact match, searching...\n");
+
+ // variables
+ CONS_Printf("\x82""Variables:\n");
+ for (cvar = consvar_vars; cvar; cvar = cvar->next)
+ {
+ if ((cvar->flags & CV_NOSHOWHELP) || (!strstr(cvar->name, help)))
+ continue;
+ CONS_Printf("%s ", cvar->name);
+ i++;
+ }
+
+ // commands
+ CONS_Printf("\x82""\nCommands:\n");
+ for (cmd = com_commands; cmd; cmd = cmd->next)
+ {
+ if (!strstr(cmd->name, help))
+ continue;
+ CONS_Printf("%s ",cmd->name);
+ i++;
+ }
+
+ CONS_Printf("\x82""\nCheck wiki.srb2.org for more or type help <command or variable>\n");
+
+ CONS_Debug(DBG_GAMELOGIC, "\x87Total : %d\n", i);
+ }
+ return;
}
else
{
- // commands
- CONS_Printf("\x82%s", M_GetText("Commands\n"));
- for (cmd = com_commands; cmd; cmd = cmd->next)
+ // variables
+ CONS_Printf("\x82""Variables:\n");
+ for (cvar = consvar_vars; cvar; cvar = cvar->next)
{
- CONS_Printf("%s ",cmd->name);
+ if (cvar->flags & CV_NOSHOWHELP)
+ continue;
+ CONS_Printf("%s ", cvar->name);
i++;
}
- // variables
- CONS_Printf("\n\x82%s", M_GetText("Variables\n"));
- for (cvar = consvar_vars; cvar; cvar = cvar->next)
+ // commands
+ CONS_Printf("\x82""\nCommands:\n");
+ for (cmd = com_commands; cmd; cmd = cmd->next)
{
- if (!(cvar->flags & CV_NOSHOWHELP))
- CONS_Printf("%s ", cvar->name);
+ CONS_Printf("%s ",cmd->name);
i++;
}
- CONS_Printf("\n\x82%s", M_GetText("Read help file for more or type help <command or variable>\n"));
+ CONS_Printf("\x82""\nCheck wiki.srb2.org for more or type help <command or variable>\n");
CONS_Debug(DBG_GAMELOGIC, "\x82Total : %d\n", i);
}
@@ -816,6 +878,30 @@ static void COM_Toggle_f(void)
CV_AddValue(cvar, +1);
}
+/** Command variant of CV_AddValue
+ */
+static void COM_Add_f(void)
+{
+ consvar_t *cvar;
+
+ if (COM_Argc() != 3)
+ {
+ CONS_Printf(M_GetText("Add <cvar_name> <value>: Add to the value of a cvar. Negative values work too!\n"));
+ return;
+ }
+ cvar = CV_FindVar(COM_Argv(1));
+ if (!cvar)
+ {
+ CONS_Alert(CONS_NOTICE, M_GetText("%s is not a cvar\n"), COM_Argv(1));
+ return;
+ }
+
+ if (( cvar->flags & CV_FLOAT ))
+ CV_Set(cvar, va("%f", FIXED_TO_FLOAT (cvar->value) + atof(COM_Argv(2))));
+ else
+ CV_AddValue(cvar, atoi(COM_Argv(2)));
+}
+
// =========================================================================
// VARIABLE SIZE BUFFERS
// =========================================================================
@@ -1123,32 +1209,42 @@ static void Setvalue(consvar_t *var, const char *valstr, boolean stealth)
if (var->PossibleValue[0].strvalue && !stricmp(var->PossibleValue[0].strvalue, "MIN")) // bounded cvar
{
+#define MINVAL 0
+#define MAXVAL 1
INT32 i;
- // search for maximum
- for (i = 1; var->PossibleValue[i].strvalue; i++)
- if (!stricmp(var->PossibleValue[i].strvalue, "MAX"))
- break;
#ifdef PARANOIA
- if (!var->PossibleValue[i].strvalue)
+ if (!var->PossibleValue[MAXVAL].strvalue)
I_Error("Bounded cvar \"%s\" without maximum!\n", var->name);
#endif
- if ((v != INT32_MIN && v < var->PossibleValue[0].value) || !stricmp(valstr, "MIN"))
+ // search for other
+ for (i = MAXVAL+1; var->PossibleValue[i].strvalue; i++)
+ if (v == var->PossibleValue[i].value || !stricmp(var->PossibleValue[i].strvalue, valstr))
+ {
+ var->value = var->PossibleValue[i].value;
+ var->string = var->PossibleValue[i].strvalue;
+ goto finish;
+ }
+
+
+ if ((v != INT32_MIN && v < var->PossibleValue[MINVAL].value) || !stricmp(valstr, "MIN"))
{
- v = var->PossibleValue[0].value;
- valstr = var->PossibleValue[0].strvalue;
+ v = var->PossibleValue[MINVAL].value;
+ valstr = var->PossibleValue[MINVAL].strvalue;
override = true;
overrideval = v;
}
- else if ((v != INT32_MIN && v > var->PossibleValue[i].value) || !stricmp(valstr, "MAX"))
+ else if ((v != INT32_MIN && v > var->PossibleValue[MAXVAL].value) || !stricmp(valstr, "MAX"))
{
- v = var->PossibleValue[i].value;
- valstr = var->PossibleValue[i].strvalue;
+ v = var->PossibleValue[MAXVAL].value;
+ valstr = var->PossibleValue[MAXVAL].strvalue;
override = true;
overrideval = v;
}
if (v == INT32_MIN)
goto badinput;
+#undef MINVAL
+#undef MAXVAL
}
else
{
@@ -1515,6 +1611,9 @@ void CV_AddValue(consvar_t *var, INT32 increment)
{
INT32 newvalue, max;
+ if (!increment)
+ return;
+
// count pointlimit better
if (var == &cv_pointlimit && (gametype == GT_MATCH))
increment *= 50;
@@ -1538,13 +1637,11 @@ void CV_AddValue(consvar_t *var, INT32 increment)
if (var->PossibleValue)
{
-#define MINVAL 0
if (var == &cv_nextmap)
{
// Special case for the nextmap variable, used only directly from the menu
INT32 oldvalue = var->value - 1, gt;
gt = cv_newgametype.value;
- if (increment != 0) // Going up!
{
newvalue = var->value - 1;
do
@@ -1575,21 +1672,58 @@ void CV_AddValue(consvar_t *var, INT32 increment)
return;
}
}
+#define MINVAL 0
+#define MAXVAL 1
else if (var->PossibleValue[MINVAL].strvalue && !strcmp(var->PossibleValue[MINVAL].strvalue, "MIN"))
{
- // search the next to last
- for (max = 0; var->PossibleValue[max+1].strvalue; max++)
- ;
+#ifdef PARANOIA
+ if (!var->PossibleValue[MAXVAL].strvalue)
+ I_Error("Bounded cvar \"%s\" without maximum!\n", var->name);
+#endif
- if (newvalue < var->PossibleValue[MINVAL].value) // add the max+1
- newvalue += var->PossibleValue[max].value - var->PossibleValue[MINVAL].value + 1;
+ if (newvalue < var->PossibleValue[MINVAL].value || newvalue > var->PossibleValue[MAXVAL].value)
+ {
+ INT32 currentindice = -1, newindice;
+ for (max = MAXVAL+1; var->PossibleValue[max].strvalue; max++)
+ {
+ if (var->PossibleValue[max].value == newvalue)
+ {
+ increment = 0;
+ currentindice = max;
+ }
+ else if (var->PossibleValue[max].value == var->value)
+ currentindice = max;
+ }
- newvalue = var->PossibleValue[MINVAL].value + (newvalue - var->PossibleValue[MINVAL].value)
- % (var->PossibleValue[max].value - var->PossibleValue[MINVAL].value + 1);
+ if (increment)
+ {
+ increment = (increment > 0) ? 1 : -1;
+ if (currentindice == -1 && max != MAXVAL+1)
+ newindice = ((increment > 0) ? MAXVAL : max) + increment;
+ else
+ newindice = currentindice + increment;
- CV_SetValue(var, newvalue);
-#undef MINVAL
+ if (newindice >= max || newindice <= MAXVAL)
+ {
+ if (var == &cv_pointlimit && (gametype == GT_MATCH) && increment > 0)
+ CV_SetValue(var, 50);
+ else
+ {
+ newvalue = var->PossibleValue[((increment > 0) ? MINVAL : MAXVAL)].value;
+ CV_SetValue(var, newvalue);
+ }
+ }
+ else
+ CV_Set(var, var->PossibleValue[newindice].strvalue);
+ }
+ else
+ CV_Set(var, var->PossibleValue[currentindice].strvalue);
+ }
+ else
+ CV_SetValue(var, newvalue);
}
+#undef MINVAL
+#undef MAXVAL
else
{
INT32 currentindice = -1, newindice;
@@ -1599,8 +1733,6 @@ void CV_AddValue(consvar_t *var, INT32 increment)
if (var->PossibleValue[max].value == var->value)
currentindice = max;
- max--;
-
if (var == &cv_chooseskin)
{
// Special case for the chooseskin variable, used only directly from the menu
@@ -1632,7 +1764,7 @@ void CV_AddValue(consvar_t *var, INT32 increment)
var->value);
#endif
- newindice = (currentindice + increment + max + 1) % (max+1);
+ newindice = (currentindice + increment + max) % max;
CV_Set(var, var->PossibleValue[newindice].strvalue);
}
}
diff --git a/src/config.h.in b/src/config.h.in
index fc32aef823e27f61abf1e22859073112646158ef..58d07e26d2d875d688109b6895a3ceecd534eb53 100644
--- a/src/config.h.in
+++ b/src/config.h.in
@@ -13,7 +13,7 @@
#define ASSET_HASH_SRB2_PK3 "${SRB2_ASSET_srb2.pk3_HASH}"
#define ASSET_HASH_PLAYER_DTA "${SRB2_ASSET_player.dta_HASH}"
-#define ASSET_HASH_ZONES_DTA "${SRB2_ASSET_zones.dta_HASH}"
+#define ASSET_HASH_ZONES_PK3 "${SRB2_ASSET_zones.pk3_HASH}"
#ifdef USE_PATCH_DTA
#define ASSET_HASH_PATCH_PK3 "${SRB2_ASSET_patch.pk3_HASH}"
#endif
@@ -30,7 +30,7 @@
* Last updated 2018 / ?? / ?? - v2.2 - patch.pk3
*/
#define ASSET_HASH_SRB2_PK3 "c1b9577687f8a795104aef4600720ea7"
-#define ASSET_HASH_ZONES_DTA "303838c6c534d9540288360fa49cca60"
+#define ASSET_HASH_ZONES_PK3 "303838c6c534d9540288360fa49cca60"
#define ASSET_HASH_PLAYER_DTA "cfca0f1c73023cbbd8f844f45480f799"
#ifdef USE_PATCH_DTA
#define ASSET_HASH_PATCH_PK3 "dbbf8bc6121618ee3be2d5b14650429b"
diff --git a/src/console.c b/src/console.c
index db07c05d37bd00b41c3e08a7acebcc9cbaa2bffe..b68d8833d46304de3cceead28c1815c90d24f12f 100644
--- a/src/console.c
+++ b/src/console.c
@@ -176,11 +176,11 @@ static void CONS_Clear_f(void)
// Choose english keymap
//
-static void CONS_English_f(void)
+/*static void CONS_English_f(void)
{
shiftxform = english_shiftxform;
CONS_Printf(M_GetText("%s keymap.\n"), M_GetText("English"));
-}
+}*/
static char *bindtable[NUMINPUTS];
@@ -395,7 +395,7 @@ void CON_Init(void)
// register our commands
//
COM_AddCommand("cls", CONS_Clear_f);
- COM_AddCommand("english", CONS_English_f);
+ //COM_AddCommand("english", CONS_English_f);
// set console full screen for game startup MAKE SURE VID_Init() done !!!
con_destlines = vid.height;
con_curlines = vid.height;
diff --git a/src/d_clisrv.c b/src/d_clisrv.c
index 476bb1a1ea357b36c56894a36645e474e101ef73..8d6de765470f15b9c2c1c2029b2ea758347e46bd 100644
--- a/src/d_clisrv.c
+++ b/src/d_clisrv.c
@@ -83,11 +83,9 @@ tic_t jointimeout = (10*TICRATE);
static boolean sendingsavegame[MAXNETNODES]; // Are we sending the savegame?
static tic_t freezetimeout[MAXNETNODES]; // Until when can this node freeze the server before getting a timeout?
-#ifdef NEWPING
UINT16 pingmeasurecount = 1;
UINT32 realpingtable[MAXPLAYERS]; //the base table of ping where an average will be sent to everyone.
UINT32 playerpingtable[MAXPLAYERS]; //table of player latency values.
-#endif
SINT8 nodetoplayer[MAXNETNODES];
SINT8 nodetoplayer2[MAXNETNODES]; // say the numplayer for this node if any (splitscreen)
UINT8 playerpernode[MAXNETNODES]; // used specialy for scplitscreen
@@ -621,6 +619,10 @@ static inline void resynch_write_player(resynch_pak *rsp, const size_t i)
rsp->friction = LONG(players[i].mo->friction);
rsp->movefactor = LONG(players[i].mo->movefactor);
+ rsp->sprite = (spritenum_t)LONG(players[i].mo->sprite);
+ rsp->frame = LONG(players[i].mo->frame);
+ rsp->sprite2 = players[i].mo->sprite2;
+ rsp->anim_duration = SHORT(players[i].mo->anim_duration);
rsp->tics = LONG(players[i].mo->tics);
rsp->statenum = (statenum_t)LONG(players[i].mo->state-states); // :(
rsp->eflags = (UINT16)SHORT(players[i].mo->eflags);
@@ -767,8 +769,17 @@ static void resynch_read_player(resynch_pak *rsp)
players[i].mo->momy = LONG(rsp->momy);
players[i].mo->momz = LONG(rsp->momz);
players[i].mo->movefactor = LONG(rsp->movefactor);
+
+ // Don't use P_SetMobjStateNF to restore state, write/read all the values manually!
+ // This should stop those stupid console errors, hopefully.
+ // -- Monster Iestyn
+ players[i].mo->sprite = (spritenum_t)LONG(rsp->sprite);
+ players[i].mo->frame = LONG(rsp->frame);
+ players[i].mo->sprite2 = rsp->sprite2;
+ players[i].mo->anim_duration = SHORT(rsp->anim_duration);
players[i].mo->tics = LONG(rsp->tics);
- P_SetMobjStateNF(players[i].mo, LONG(rsp->statenum));
+ players[i].mo->state = &states[LONG(rsp->statenum)];
+
players[i].mo->x = LONG(rsp->x);
players[i].mo->y = LONG(rsp->y);
players[i].mo->z = LONG(rsp->z);
@@ -1253,7 +1264,8 @@ static boolean CL_SendJoin(void)
netbuffer->u.clientcfg.localplayers = localplayers;
netbuffer->u.clientcfg.version = VERSION;
netbuffer->u.clientcfg.subversion = SUBVERSION;
-
+ strncpy(netbuffer->u.clientcfg.names[0], cv_playername.zstring, MAXPLAYERNAME);
+ strncpy(netbuffer->u.clientcfg.names[1], cv_playername2.zstring, MAXPLAYERNAME);
return HSendPacket(servernode, true, 0, sizeof (clientconfig_pak));
}
@@ -1312,33 +1324,13 @@ static void SV_SendPlayerInfo(INT32 node)
continue;
}
- netbuffer->u.playerinfo[i].node = (UINT8)playernode[i];
+ netbuffer->u.playerinfo[i].node = i;
strncpy(netbuffer->u.playerinfo[i].name, (const char *)&player_names[i], MAXPLAYERNAME+1);
netbuffer->u.playerinfo[i].name[MAXPLAYERNAME] = '\0';
//fetch IP address
- {
- const char *claddress;
- UINT32 numericaddress[4];
-
- memset(netbuffer->u.playerinfo[i].address, 0, 4);
- if (playernode[i] == 0)
- {
- //127.0.0.1
- netbuffer->u.playerinfo[i].address[0] = 127;
- netbuffer->u.playerinfo[i].address[3] = 1;
- }
- else if (playernode[i] > 0 && I_GetNodeAddress && (claddress = I_GetNodeAddress(playernode[i])) != NULL)
- {
- if (sscanf(claddress, "%d.%d.%d.%d", &numericaddress[0], &numericaddress[1], &numericaddress[2], &numericaddress[3]) < 4)
- goto badaddress;
- netbuffer->u.playerinfo[i].address[0] = (UINT8)numericaddress[0];
- netbuffer->u.playerinfo[i].address[1] = (UINT8)numericaddress[1];
- netbuffer->u.playerinfo[i].address[2] = (UINT8)numericaddress[2];
- netbuffer->u.playerinfo[i].address[3] = (UINT8)numericaddress[3];
- }
- }
- badaddress:
+ //No, don't do that, you fuckface.
+ memset(netbuffer->u.playerinfo[i].address, 0, 4);
if (G_GametypeHasTeams())
{
@@ -2499,7 +2491,7 @@ static void CL_RemovePlayer(INT32 playernum, INT32 reason)
void CL_Reset(void)
{
if (metalrecording)
- G_StopMetalRecording();
+ G_StopMetalRecording(false);
if (metalplayback)
G_StopMetalDemo();
if (demorecording)
@@ -2870,12 +2862,10 @@ static void Got_KickCmd(UINT8 **p, INT32 playernum)
HU_AddChatText(va("\x82*%s has been kicked (Go away)", player_names[pnum]), false);
kickreason = KR_KICK;
break;
-#ifdef NEWPING
case KICK_MSG_PING_HIGH:
HU_AddChatText(va("\x82*%s left the game (Broke ping limit)", player_names[pnum]), false);
kickreason = KR_PINGLIMIT;
break;
-#endif
case KICK_MSG_CON_FAIL:
HU_AddChatText(va("\x82*%s left the game (Synch Failure)", player_names[pnum]), false);
kickreason = KR_SYNCH;
@@ -2948,10 +2938,8 @@ static void Got_KickCmd(UINT8 **p, INT32 playernum)
D_StartTitle();
if (msg == KICK_MSG_CON_FAIL)
M_StartMessage(M_GetText("Server closed connection\n(synch failure)\nPress ESC\n"), NULL, MM_NOTHING);
-#ifdef NEWPING
else if (msg == KICK_MSG_PING_HIGH)
M_StartMessage(M_GetText("Server closed connection\n(Broke ping limit)\nPress ESC\n"), NULL, MM_NOTHING);
-#endif
else if (msg == KICK_MSG_BANNED)
M_StartMessage(M_GetText("You have been banned by the server\n\nPress ESC\n"), NULL, MM_NOTHING);
else if (msg == KICK_MSG_CUSTOM_KICK)
@@ -2969,7 +2957,7 @@ consvar_t cv_allownewplayer = {"allowjoin", "On", CV_SAVE|CV_NETVAR, CV_OnOff, N
consvar_t cv_joinnextround = {"joinnextround", "Off", CV_SAVE|CV_NETVAR, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL}; /// \todo not done
static CV_PossibleValue_t maxplayers_cons_t[] = {{2, "MIN"}, {32, "MAX"}, {0, NULL}};
consvar_t cv_maxplayers = {"maxplayers", "8", CV_SAVE, maxplayers_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
-static CV_PossibleValue_t resynchattempts_cons_t[] = {{0, "MIN"}, {20, "MAX"}, {0, NULL}};
+static CV_PossibleValue_t resynchattempts_cons_t[] = {{1, "MIN"}, {20, "MAX"}, {0, "No"}, {0, NULL}};
consvar_t cv_resynchattempts = {"resynchattempts", "10", CV_SAVE, resynchattempts_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL };
consvar_t cv_blamecfail = {"blamecfail", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL };
@@ -3199,6 +3187,7 @@ static void Got_AddPlayer(UINT8 **p, INT32 playernum)
if (!splitscreen && !botingame)
CL_ClearPlayer(newplayernum);
playeringame[newplayernum] = true;
+ READSTRINGN(*p, player_names[newplayernum], MAXPLAYERNAME);
G_AddPlayer(newplayernum);
if (newplayernum+1 > doomcom->numslots)
doomcom->numslots = (INT16)(newplayernum+1);
@@ -3231,10 +3220,10 @@ static void Got_AddPlayer(UINT8 **p, INT32 playernum)
{
const char *address;
if (I_GetNodeAddress && (address = I_GetNodeAddress(node)) != NULL)
- HU_AddChatText(va("\x82*Player %d has joined the game (node %d) (%s)", newplayernum+1, node, address), false); // merge join notification + IP to avoid clogging console/chat.
+ HU_AddChatText(va("\x82*%s has joined the game (node %d) (%s)", player_names[newplayernum], node, address), false); // merge join notification + IP to avoid clogging console/chat.
}
else
- HU_AddChatText(va("\x82*Player %d has joined the game (node %d)", newplayernum+1, node), false); // if you don't wanna see the join address.
+ HU_AddChatText(va("\x82*%s has joined the game (node %d)", player_names[newplayernum], node), false); // if you don't wanna see the join address.
}
if (server && multiplayer && motd[0] != '\0')
@@ -3245,10 +3234,11 @@ static void Got_AddPlayer(UINT8 **p, INT32 playernum)
#endif
}
-static boolean SV_AddWaitingPlayers(void)
+static boolean SV_AddWaitingPlayers(const char *name, const char *name2)
{
INT32 node, n, newplayer = false;
- UINT8 buf[2];
+ UINT8 buf[2 + MAXPLAYERNAME];
+ UINT8 *p;
UINT8 newplayernum = 0;
// What is the reason for this? Why can't newplayernum always be 0?
@@ -3331,18 +3321,23 @@ static boolean SV_AddWaitingPlayers(void)
playernode[newplayernum] = (UINT8)node;
+ p = buf + 2;
buf[0] = (UINT8)node;
buf[1] = newplayernum;
if (playerpernode[node] < 1)
+ {
nodetoplayer[node] = newplayernum;
+ WRITESTRINGN(p, name, MAXPLAYERNAME);
+ }
else
{
nodetoplayer2[node] = newplayernum;
buf[1] |= 0x80;
+ WRITESTRINGN(p, name2, MAXPLAYERNAME);
}
playerpernode[node]++;
- SendNetXCmd(XD_ADDPLAYER, &buf, 2);
+ SendNetXCmd(XD_ADDPLAYER, &buf, p - buf);
DEBFILE(va("Server added player %d node %d\n", newplayernum, node));
// use the next free slot (we can't put playeringame[newplayernum] = true here)
@@ -3404,7 +3399,7 @@ boolean SV_SpawnServer(void)
else doomcom->numslots = 1;
}
- return SV_AddWaitingPlayers();
+ return SV_AddWaitingPlayers(cv_playername.zstring, cv_playername2.zstring);
}
void SV_StopServer(void)
@@ -3475,6 +3470,9 @@ static size_t TotalTextCmdPerTic(tic_t tic)
*/
static void HandleConnect(SINT8 node)
{
+ char names[MAXSPLITSCREENPLAYERS][MAXPLAYERNAME + 1];
+ INT32 i;
+
if (bannednode && bannednode[node])
SV_SendRefuse(node, M_GetText("You have been banned\nfrom the server"));
else if (netbuffer->u.clientcfg.version != VERSION
@@ -3494,6 +3492,16 @@ static void HandleConnect(SINT8 node)
boolean newnode = false;
#endif
+ for (i = 0; i < netbuffer->u.clientcfg.localplayers - playerpernode[node]; i++)
+ {
+ strlcpy(names[i], netbuffer->u.clientcfg.names[i], MAXPLAYERNAME + 1);
+ if (!EnsurePlayerNameIsGood(names[i], -1))
+ {
+ SV_SendRefuse(node, "Bad player name");
+ return;
+ }
+ }
+
// client authorised to join
nodewaiting[node] = (UINT8)(netbuffer->u.clientcfg.localplayers - playerpernode[node]);
if (!nodeingame[node])
@@ -3534,7 +3542,7 @@ static void HandleConnect(SINT8 node)
SV_SendSaveGame(node); // send a complete game state
DEBFILE("send savegame\n");
}
- SV_AddWaitingPlayers();
+ SV_AddWaitingPlayers(names[0], names[1]);
player_joining = true;
}
#else
@@ -3841,7 +3849,7 @@ static void HandlePacketFromPlayer(SINT8 node)
break;
// Ignore tics from those not synched
- if (resynch_inprogress[node])
+ if (resynch_inprogress[node] && nettics[node] == gametic)
break;
// To save bytes, only the low byte of tic numbers are sent
@@ -4175,7 +4183,6 @@ static void HandlePacketFromPlayer(SINT8 node)
resynch_local_inprogress = true;
CL_AcknowledgeResynch(&netbuffer->u.resynchpak);
break;
-#ifdef NEWPING
case PT_PING:
// Only accept PT_PING from the server.
if (node != servernode)
@@ -4203,7 +4210,6 @@ static void HandlePacketFromPlayer(SINT8 node)
}
break;
-#endif
case PT_SERVERCFG:
break;
case PT_FILEFRAGMENT:
@@ -4699,10 +4705,15 @@ void TryRunTics(tic_t realtics)
if (player_joining)
return;
- if (neededtic > gametic)
+ if (neededtic > gametic && !resynch_local_inprogress)
{
if (advancedemo)
- D_StartTitle();
+ {
+ if (timedemo_quit)
+ COM_ImmedExecute("quit");
+ else
+ D_StartTitle();
+ }
else
// run the count * tics
while (neededtic > gametic)
@@ -4717,7 +4728,6 @@ void TryRunTics(tic_t realtics)
}
}
-#ifdef NEWPING
static inline void PingUpdate(void)
{
INT32 i;
@@ -4775,7 +4785,6 @@ static inline void PingUpdate(void)
pingmeasurecount = 1; //Reset count
}
-#endif
void NetUpdate(void)
{
@@ -4800,7 +4809,6 @@ void NetUpdate(void)
gametime = nowtime;
-#ifdef NEWPING
if (server)
{
if (netgame && !(gametime % 255))
@@ -4811,7 +4819,6 @@ void NetUpdate(void)
realpingtable[i] += G_TicsToMilliseconds(GetLag(playernode[i]));
pingmeasurecount++;
}
-#endif
if (client)
maketic = neededtic;
@@ -4853,8 +4860,13 @@ void NetUpdate(void)
for (i = 0; i < MAXNETNODES; ++i)
if (resynch_inprogress[i])
{
- SV_SendResynch(i);
- counts = -666;
+ if (!nodeingame[i] || nettics[i] == gametic)
+ {
+ SV_SendResynch(i);
+ counts = -666;
+ }
+ else
+ counts = 0; // Let the client catch up with the server
}
// Do not make tics while resynching
diff --git a/src/d_clisrv.h b/src/d_clisrv.h
index d09d2aa48e024a5d7ce0451b26bf347663f83469..d7c210895ab5c2d0a376d384d31d586898925e6e 100644
--- a/src/d_clisrv.h
+++ b/src/d_clisrv.h
@@ -15,6 +15,7 @@
#include "d_ticcmd.h"
#include "d_netcmd.h"
+#include "d_net.h"
#include "tables.h"
#include "d_player.h"
@@ -73,9 +74,7 @@ typedef enum
PT_LOGIN, // Login attempt from the client.
-#ifdef NEWPING
PT_PING, // Packet sent to tell clients the other client's latency to server.
-#endif
NUMPACKETTYPE
} packettype_t;
@@ -265,6 +264,10 @@ typedef struct
fixed_t friction;
fixed_t movefactor;
+ spritenum_t sprite;
+ UINT32 frame;
+ UINT8 sprite2;
+ UINT16 anim_duration;
INT32 tics;
statenum_t statenum;
UINT32 flags;
@@ -322,6 +325,7 @@ typedef struct
UINT8 subversion; // Contains build version
UINT8 localplayers;
UINT8 mode;
+ char names[MAXSPLITSCREENPLAYERS][MAXPLAYERNAME];
} ATTRPACK clientconfig_pak;
#define MAXSERVERNAME 32
@@ -421,9 +425,7 @@ typedef struct
msaskinfo_pak msaskinfo; // 22 bytes
plrinfo playerinfo[MAXPLAYERS]; // 1152 bytes (I'd say 36~38)
plrconfig playerconfig[MAXPLAYERS]; // (up to) 896 bytes (welp they ARE)
-#ifdef NEWPING
UINT32 pingtable[MAXPLAYERS]; // 128 bytes
-#endif
} u; // This is needed to pack diff packet types data together
} ATTRPACK doomdata_t;
@@ -457,9 +459,7 @@ extern consvar_t cv_playbackspeed;
#define KICK_MSG_PLAYER_QUIT 3
#define KICK_MSG_TIMEOUT 4
#define KICK_MSG_BANNED 5
-#ifdef NEWPING
#define KICK_MSG_PING_HIGH 6
-#endif
#define KICK_MSG_CUSTOM_KICK 7
#define KICK_MSG_CUSTOM_BAN 8
@@ -484,11 +484,9 @@ extern SINT8 servernode;
void Command_Ping_f(void);
extern tic_t connectiontimeout;
extern tic_t jointimeout;
-#ifdef NEWPING
extern UINT16 pingmeasurecount;
extern UINT32 realpingtable[MAXPLAYERS];
extern UINT32 playerpingtable[MAXPLAYERS];
-#endif
extern consvar_t cv_joinnextround, cv_allownewplayer, cv_maxplayers, cv_resynchattempts, cv_blamecfail, cv_maxsend, cv_noticedownload, cv_downloadspeed;
diff --git a/src/d_main.c b/src/d_main.c
index 8dd6e2fbc946b4b52735f69bb094a45f2fc6d8cf..932a2d7627565972628bbc22f94437b371a9fa51 100644
--- a/src/d_main.c
+++ b/src/d_main.c
@@ -257,7 +257,14 @@ static void D_Display(void)
}
if (vid.recalc || setrenderstillneeded)
+ {
SCR_Recalc(); // NOTE! setsizeneeded is set by SCR_Recalc()
+#ifdef HWRENDER
+ // Shoot! The screen texture was flushed!
+ if ((rendermode == render_opengl) && (gamestate == GS_INTERMISSION))
+ usebuffer = false;
+#endif
+ }
// change the view size if needed
if (setsizeneeded || setrenderstillneeded)
@@ -317,11 +324,8 @@ static void D_Display(void)
switch (gamestate)
{
case GS_TITLESCREEN:
- if (!titlemapinaction || !curbghide) {
- F_TitleScreenDrawer();
- break;
- }
- /* FALLTHRU */
+ F_TitleScreenDrawer();
+ break;
case GS_LEVEL:
if (!gametic)
break;
@@ -392,75 +396,26 @@ static void D_Display(void)
// clean up border stuff
// see if the border needs to be initially drawn
- if (gamestate == GS_LEVEL || (gamestate == GS_TITLESCREEN && titlemapinaction && curbghide))
+ if (gamestate == GS_LEVEL)
{
// draw the view directly
- if (!automapactive && !dedicated && cv_renderview.value)
- {
- if (players[displayplayer].mo || players[displayplayer].playerstate == PST_DEAD)
- {
- topleft = screens[0] + viewwindowy*vid.width + viewwindowx;
- objectsdrawn = 0;
- #ifdef HWRENDER
- if (rendermode != render_soft)
- HWR_RenderPlayerView(0, &players[displayplayer]);
- else
- #endif
- if (rendermode != render_none)
- R_RenderPlayerView(&players[displayplayer]);
- }
-
- // render the second screen
- if (splitscreen && players[secondarydisplayplayer].mo)
- {
- #ifdef HWRENDER
- if (rendermode != render_soft)
- HWR_RenderPlayerView(1, &players[secondarydisplayplayer]);
- else
- #endif
- if (rendermode != render_none)
- {
- viewwindowy = vid.height / 2;
- M_Memcpy(ylookup, ylookup2, viewheight*sizeof (ylookup[0]));
-
- topleft = screens[0] + viewwindowy*vid.width + viewwindowx;
-
- R_RenderPlayerView(&players[secondarydisplayplayer]);
-
- viewwindowy = 0;
- M_Memcpy(ylookup, ylookup1, viewheight*sizeof (ylookup[0]));
- }
- }
-
- // Image postprocessing effect
- if (rendermode == render_soft)
- {
- if (postimgtype)
- V_DoPostProcessor(0, postimgtype, postimgparam);
- if (postimgtype2)
- V_DoPostProcessor(1, postimgtype2, postimgparam2);
- }
- }
+ D_Render();
if (lastdraw)
{
if (rendermode == render_soft)
{
VID_BlitLinearScreen(screens[0], screens[1], vid.width*vid.bpp, vid.height, vid.width*vid.bpp, vid.rowbytes);
+ Y_ConsiderScreenBuffer();
usebuffer = true;
}
lastdraw = false;
}
- if (gamestate == GS_LEVEL)
- {
- ST_Drawer();
- F_TextPromptDrawer();
- HU_Drawer();
- }
- else
- F_TitleScreenDrawer();
+ ST_Drawer();
+ F_TextPromptDrawer();
+ HU_Drawer();
}
}
@@ -516,6 +471,13 @@ static void D_Display(void)
F_RunWipe(wipetypepost, gamestate != GS_TIMEATTACK && gamestate != GS_TITLESCREEN);
}
+ // reset counters so timedemo doesn't count the wipe duration
+ if (timingdemo)
+ {
+ framecount = 0;
+ demostarttime = I_GetTime();
+ }
+
wipetypepost = -1;
}
else
@@ -575,6 +537,56 @@ void D_CheckRendererState(void)
R_ReloadHUDGraphics();
}
+void D_Render(void)
+{
+ if (!automapactive && !dedicated && cv_renderview.value)
+ {
+ if (players[displayplayer].mo || players[displayplayer].playerstate == PST_DEAD)
+ {
+ topleft = screens[0] + viewwindowy*vid.width + viewwindowx;
+ objectsdrawn = 0;
+#ifdef HWRENDER
+ if (rendermode != render_soft)
+ HWR_RenderPlayerView(0, &players[displayplayer]);
+ else
+#endif
+ if (rendermode != render_none)
+ R_RenderPlayerView(&players[displayplayer]);
+ }
+
+ // render the second screen
+ if (splitscreen && players[secondarydisplayplayer].mo)
+ {
+#ifdef HWRENDER
+ if (rendermode != render_soft)
+ HWR_RenderPlayerView(1, &players[secondarydisplayplayer]);
+ else
+#endif
+ if (rendermode != render_none)
+ {
+ viewwindowy = vid.height / 2;
+ M_Memcpy(ylookup, ylookup2, viewheight*sizeof (ylookup[0]));
+
+ topleft = screens[0] + viewwindowy*vid.width + viewwindowx;
+
+ R_RenderPlayerView(&players[secondarydisplayplayer]);
+
+ viewwindowy = 0;
+ M_Memcpy(ylookup, ylookup1, viewheight*sizeof (ylookup[0]));
+ }
+ }
+
+ // Image postprocessing effect
+ if (rendermode == render_soft)
+ {
+ if (postimgtype)
+ V_DoPostProcessor(0, postimgtype, postimgparam);
+ if (postimgtype2)
+ V_DoPostProcessor(1, postimgtype2, postimgparam2);
+ }
+ }
+}
+
// =========================================================================
// D_SRB2Loop
// =========================================================================
@@ -588,9 +600,6 @@ void D_SRB2Loop(void)
if (dedicated)
server = true;
- if (M_CheckParm("-voodoo")) // 256x256 Texture Limiter
- COM_BufAddText("gr_voodoocompatibility on\n");
-
// Pushing of + parameters is now done back in D_SRB2Main, not here.
CONS_Printf("I_StartupKeyboard()...\n");
@@ -903,7 +912,7 @@ static void IdentifyVersion(void)
// checking in D_SRB2Main
// Add the maps
- D_AddFile(va(pandf,srb2waddir,"zones.dta"));
+ D_AddFile(va(pandf,srb2waddir,"zones.pk3"));
// Add the players
D_AddFile(va(pandf,srb2waddir, "player.dta"));
@@ -1196,10 +1205,10 @@ void D_SRB2Main(void)
// Check MD5s of autoloaded files
W_VerifyFileMD5(mainwads++, ASSET_HASH_SRB2_PK3); // srb2.pk3
- W_VerifyFileMD5(mainwads++, ASSET_HASH_ZONES_DTA); // zones.dta
+ W_VerifyFileMD5(mainwads++, ASSET_HASH_ZONES_PK3); // zones.pk3
W_VerifyFileMD5(mainwads++, ASSET_HASH_PLAYER_DTA); // player.dta
#ifdef USE_PATCH_DTA
- W_VerifyFileMD5(mainwads++, ASSET_HASH_PATCH_DTA); // patch.dta
+ W_VerifyFileMD5(mainwads++, ASSET_HASH_PATCH_DTA); // patch.pk3
#endif
// don't check music.dta because people like to modify it, and it doesn't matter if they do
// ...except it does if they slip maps in there, and that's what W_VerifyNMUSlumps is for.
@@ -1208,7 +1217,7 @@ void D_SRB2Main(void)
#else
mainwads++; // srb2.pk3
- mainwads++; // zones.dta
+ mainwads++; // zones.pk3
mainwads++; // player.dta
#ifdef USE_PATCH_DTA
mainwads++; // patch.dta
@@ -1305,24 +1314,40 @@ void D_SRB2Main(void)
sound_disabled = true;
midi_disabled = digital_disabled = true;
}
- else
+ if (M_CheckParm("-noaudio")) // combines -nosound and -nomusic
{
- CONS_Printf("S_InitSfxChannels(): Setting up sound channels.\n");
- }
- if (M_CheckParm("-nosound"))
sound_disabled = true;
- if (M_CheckParm("-nomusic")) // combines -nomidimusic and -nodigmusic
- midi_disabled = digital_disabled = true;
+ digital_disabled = true;
+ midi_disabled = true;
+ }
else
{
- if (M_CheckParm("-nomidimusic"))
- midi_disabled = true; // WARNING: DOS version initmusic in I_StartupSound
- if (M_CheckParm("-nodigmusic"))
- digital_disabled = true; // WARNING: DOS version initmusic in I_StartupSound
+ if (M_CheckParm("-nosound"))
+ sound_disabled = true;
+ if (M_CheckParm("-nomusic")) // combines -nomidimusic and -nodigmusic
+ {
+ digital_disabled = true;
+ midi_disabled = true;
+ }
+ else
+ {
+ if (M_CheckParm("-nomidimusic"))
+ midi_disabled = true; // WARNING: DOS version initmusic in I_StartupSound
+ if (M_CheckParm("-nodigmusic"))
+ digital_disabled = true; // WARNING: DOS version initmusic in I_StartupSound
+ }
+ }
+ if (!( sound_disabled && digital_disabled
+#ifndef NO_MIDI
+ && midi_disabled
+#endif
+ ))
+ {
+ CONS_Printf("S_InitSfxChannels(): Setting up sound channels.\n");
+ I_StartupSound();
+ I_InitMusic();
+ S_InitSfxChannels(cv_soundvolume.value);
}
- I_StartupSound();
- I_InitMusic();
- S_InitSfxChannels(cv_soundvolume.value);
CONS_Printf("ST_Init(): Init status bar.\n");
ST_Init();
diff --git a/src/d_main.h b/src/d_main.h
index d67a5bb498ba0f45d37b2be8c6bd15fde96cc78a..65c51802a7c644c871b862ef0ff28182204d0d6b 100644
--- a/src/d_main.h
+++ b/src/d_main.h
@@ -54,4 +54,7 @@ const char *D_Home(void);
void D_AdvanceDemo(void);
void D_StartTitle(void);
+/* Here for title maps */
+void D_Render(void);
+
#endif //__D_MAIN__
diff --git a/src/d_net.c b/src/d_net.c
index 9f68c187c472e7cf73175c0f1ed55dcaccdba31b..cbfef7726ab8e5e96077c4c09b900193eb07582c 100644
--- a/src/d_net.c
+++ b/src/d_net.c
@@ -185,22 +185,10 @@ typedef struct
UINT8 nextacknum;
UINT8 flags;
-#ifndef NEWPING
- // jacobson tcp timeout evaluation algorithm (Karn variation)
- fixed_t ping;
- fixed_t varping;
- INT32 timeout; // computed with ping and varping
-#endif
} node_t;
static node_t nodes[MAXNETNODES];
-#ifndef NEWPING
-#define PINGDEFAULT ((200*TICRATE*FRACUNIT)/1000)
-#define VARPINGDEFAULT ((50*TICRATE*FRACUNIT)/1000)
-#define TIMEOUT(p,v) (p+4*v+FRACUNIT/2)>>FRACBITS;
-#else
-#define NODETIMEOUT 14 //What the above boiled down to...
-#endif
+#define NODETIMEOUT 14
#ifndef NONET
// return <0 if a < b (mod 256)
@@ -320,19 +308,7 @@ static UINT8 GetAcktosend(INT32 node)
static void RemoveAck(INT32 i)
{
INT32 node = ackpak[i].destinationnode;
-#ifndef NEWPING
- fixed_t trueping = (I_GetTime() - ackpak[i].senttime)<<FRACBITS;
- if (ackpak[i].resentnum)
- {
- // +FRACUNIT/2 for round
- nodes[node].ping = (nodes[node].ping*7 + trueping)/8;
- nodes[node].varping = (nodes[node].varping*7 + abs(nodes[node].ping-trueping))/8;
- nodes[node].timeout = TIMEOUT(nodes[node].ping,nodes[node].varping);
- }
- DEBFILE(va("Remove ack %d trueping %d ping %f var %f timeout %d\n",ackpak[i].acknum,trueping>>FRACBITS,(double)FIXED_TO_FLOAT(nodes[node].ping),(double)FIXED_TO_FLOAT(nodes[node].varping),nodes[node].timeout));
-#else
DEBFILE(va("Remove ack %d\n",ackpak[i].acknum));
-#endif
ackpak[i].acknum = 0;
if (nodes[node].flags & NF_CLOSE)
Net_CloseConnection(node);
@@ -519,11 +495,7 @@ void Net_AckTicker(void)
{
const INT32 nodei = ackpak[i].destinationnode;
node_t *node = &nodes[nodei];
-#ifdef NEWPING
if (ackpak[i].acknum && ackpak[i].senttime + NODETIMEOUT < I_GetTime())
-#else
- if (ackpak[i].acknum && ackpak[i].senttime + node->timeout < I_GetTime())
-#endif
{
if (ackpak[i].resentnum > 10 && (node->flags & NF_CLOSE))
{
@@ -534,13 +506,8 @@ void Net_AckTicker(void)
ackpak[i].acknum = 0;
continue;
}
-#ifdef NEWPING
DEBFILE(va("Resend ack %d, %u<%d at %u\n", ackpak[i].acknum, ackpak[i].senttime,
NODETIMEOUT, I_GetTime()));
-#else
- DEBFILE(va("Resend ack %d, %u<%d at %u\n", ackpak[i].acknum, ackpak[i].senttime,
- node->timeout, I_GetTime()));
-#endif
M_Memcpy(netbuffer, ackpak[i].pak.raw, ackpak[i].length);
ackpak[i].senttime = I_GetTime();
ackpak[i].resentnum++;
@@ -658,11 +625,6 @@ void Net_WaitAllAckReceived(UINT32 timeout)
static void InitNode(node_t *node)
{
node->acktosend_head = node->acktosend_tail = 0;
-#ifndef NEWPING
- node->ping = PINGDEFAULT;
- node->varping = VARPINGDEFAULT;
- node->timeout = TIMEOUT(node->ping, node->varping);
-#endif
node->firstacktosend = 0;
node->nextacknum = 1;
node->remotefirstack = 0;
@@ -843,9 +805,7 @@ static const char *packettypename[NUMPACKETTYPE] =
"CLIENTJOIN",
"NODETIMEOUT",
"RESYNCHING",
-#ifdef NEWPING
"PING"
-#endif
};
static void DebugPrintpacket(const char *header)
@@ -1384,30 +1344,73 @@ boolean D_CheckNetGame(void)
return ret;
}
+struct pingcell
+{
+ INT32 num;
+ INT32 ms;
+};
+
+static int pingcellcmp(const void *va, const void *vb)
+{
+ const struct pingcell *a, *b;
+ a = va;
+ b = vb;
+ return ( a->ms - b->ms );
+}
+
+/*
+New ping command formatted nicely to present ping in
+ascending order. And with equally spaced columns.
+The caller's ping is presented at the bottom too, for
+convenience.
+*/
+
void Command_Ping_f(void)
{
-#ifndef NEWPING
- if(server)
+ struct pingcell pingv[MAXPLAYERS];
+ INT32 pingc;
+
+ int name_width = 0;
+ int ms_width = 0;
+
+ int n;
+ INT32 i;
+
+ pingc = 0;
+ for (i = 1; i < MAXPLAYERS; ++i)
+ if (playeringame[i])
{
-#endif
- INT32 i;
- for (i = 0; i < MAXPLAYERS;i++)
- {
-#ifndef NEWPING
- const INT32 node = playernode[i];
- if (playeringame[i] && node != 0)
- CONS_Printf(M_GetText("%.2d : %s\n %d tics, %d ms.\n"), i, player_names[i],
- GetLag(node), G_TicsToMilliseconds(GetLag(node)));
-#else
- if (playeringame[i] && i != 0)
- CONS_Printf(M_GetText("%.2d : %s\n %d ms\n"), i, player_names[i], playerpingtable[i]);
-#endif
- }
-#ifndef NEWPING
+ n = strlen(player_names[i]);
+ if (n > name_width)
+ name_width = n;
+
+ n = playerpingtable[i];
+ if (n > ms_width)
+ ms_width = n;
+
+ pingv[pingc].num = i;
+ pingv[pingc].ms = playerpingtable[i];
+ pingc++;
+ }
+
+ if (ms_width < 10) ms_width = 1;
+ else if (ms_width < 100) ms_width = 2;
+ else ms_width = 3;
+
+ qsort(pingv, pingc, sizeof (struct pingcell), &pingcellcmp);
+
+ for (i = 0; i < pingc; ++i)
+ {
+ CONS_Printf("%02d : %-*s %*d ms\n",
+ pingv[i].num,
+ name_width, player_names[pingv[i].num],
+ ms_width, pingv[i].ms);
+ }
+
+ if (!server && playeringame[consoleplayer])
+ {
+ CONS_Printf("\nYour ping is %d ms\n", playerpingtable[consoleplayer]);
}
- else
- CONS_Printf(M_GetText("Only the server can use this.\n"));
-#endif
}
void D_CloseConnection(void)
diff --git a/src/d_netcmd.c b/src/d_netcmd.c
index cb516d50aba010db085b8e2acb2eee37b01a0c54..a347ca89d53494c10264a33001c509c6454b944d 100644
--- a/src/d_netcmd.c
+++ b/src/d_netcmd.c
@@ -74,6 +74,7 @@ static void Got_Clearscores(UINT8 **cp, INT32 playernum);
static void PointLimit_OnChange(void);
static void TimeLimit_OnChange(void);
static void NumLaps_OnChange(void);
+static void BaseNumLaps_OnChange(void);
static void Mute_OnChange(void);
static void Hidetime_OnChange(void);
@@ -210,7 +211,7 @@ consvar_t cv_allowteamchange = {"allowteamchange", "Yes", CV_NETVAR, CV_YesNo, N
consvar_t cv_startinglives = {"startinglives", "3", CV_NETVAR|CV_CHEAT, startingliveslimit_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
-static CV_PossibleValue_t respawntime_cons_t[] = {{0, "MIN"}, {30, "MAX"}, {0, NULL}};
+static CV_PossibleValue_t respawntime_cons_t[] = {{1, "MIN"}, {30, "MAX"}, {0, "Off"}, {0, NULL}};
consvar_t cv_respawntime = {"respawndelay", "3", CV_NETVAR|CV_CHEAT, respawntime_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_competitionboxes = {"competitionboxes", "Mystery", CV_NETVAR|CV_CHEAT, competitionboxes_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -315,16 +316,17 @@ consvar_t cv_timetic = {"timerres", "Classic", CV_SAVE, timetic_cons_t, NULL, 0,
static CV_PossibleValue_t powerupdisplay_cons_t[] = {{0, "Never"}, {1, "First-person only"}, {2, "Always"}, {0, NULL}};
consvar_t cv_powerupdisplay = {"powerupdisplay", "First-person only", CV_SAVE, powerupdisplay_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
-static CV_PossibleValue_t pointlimit_cons_t[] = {{0, "MIN"}, {999999990, "MAX"}, {0, NULL}};
-consvar_t cv_pointlimit = {"pointlimit", "0", CV_NETVAR|CV_CALL|CV_NOINIT, pointlimit_cons_t,
+static CV_PossibleValue_t pointlimit_cons_t[] = {{1, "MIN"}, {MAXSCORE, "MAX"}, {0, "None"}, {0, NULL}};
+consvar_t cv_pointlimit = {"pointlimit", "None", CV_NETVAR|CV_CALL|CV_NOINIT, pointlimit_cons_t,
PointLimit_OnChange, 0, NULL, NULL, 0, 0, NULL};
-static CV_PossibleValue_t timelimit_cons_t[] = {{0, "MIN"}, {30, "MAX"}, {0, NULL}};
-consvar_t cv_timelimit = {"timelimit", "0", CV_NETVAR|CV_CALL|CV_NOINIT, timelimit_cons_t,
+static CV_PossibleValue_t timelimit_cons_t[] = {{1, "MIN"}, {30, "MAX"}, {0, "None"}, {0, NULL}};
+consvar_t cv_timelimit = {"timelimit", "None", CV_NETVAR|CV_CALL|CV_NOINIT, timelimit_cons_t,
TimeLimit_OnChange, 0, NULL, NULL, 0, 0, NULL};
-static CV_PossibleValue_t numlaps_cons_t[] = {{0, "MIN"}, {50, "MAX"}, {0, NULL}};
+static CV_PossibleValue_t numlaps_cons_t[] = {{1, "MIN"}, {50, "MAX"}, {0, NULL}};
consvar_t cv_numlaps = {"numlaps", "4", CV_NETVAR|CV_CALL|CV_NOINIT, numlaps_cons_t,
NumLaps_OnChange, 0, NULL, NULL, 0, 0, NULL};
-consvar_t cv_usemapnumlaps = {"usemaplaps", "Yes", CV_NETVAR, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
+static CV_PossibleValue_t basenumlaps_cons_t[] = {{1, "MIN"}, {50, "MAX"}, {0, "Map default"}, {0, NULL}};
+consvar_t cv_basenumlaps = {"basenumlaps", "Map default", CV_NETVAR|CV_CALL|CV_CHEAT, basenumlaps_cons_t, BaseNumLaps_OnChange, 0, NULL, NULL, 0, 0, NULL};
// log elemental hazards -- not a netvar, is local to current player
consvar_t cv_hazardlog = {"hazardlog", "Yes", 0, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -340,9 +342,7 @@ static CV_PossibleValue_t nettimeout_cons_t[] = {{TICRATE/7, "MIN"}, {60*TICRATE
consvar_t cv_nettimeout = {"nettimeout", "350", CV_CALL|CV_SAVE, nettimeout_cons_t, NetTimeout_OnChange, 0, NULL, NULL, 0, 0, NULL};
static CV_PossibleValue_t jointimeout_cons_t[] = {{5*TICRATE, "MIN"}, {60*TICRATE, "MAX"}, {0, NULL}};
consvar_t cv_jointimeout = {"jointimeout", "350", CV_CALL|CV_SAVE, jointimeout_cons_t, JoinTimeout_OnChange, 0, NULL, NULL, 0, 0, NULL};
-#ifdef NEWPING
consvar_t cv_maxping = {"maxping", "0", CV_SAVE, CV_Unsigned, NULL, 0, NULL, NULL, 0, 0, NULL};
-#endif
// Intermission time Tails 04-19-2002
static CV_PossibleValue_t inttime_cons_t[] = {{0, "MIN"}, {3600, "MAX"}, {0, NULL}};
consvar_t cv_inttime = {"inttime", "10", CV_NETVAR, inttime_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -363,7 +363,12 @@ consvar_t cv_runscripts = {"runscripts", "Yes", 0, CV_YesNo, NULL, 0, NULL, NULL
consvar_t cv_pause = {"pausepermission", "Server", CV_NETVAR, pause_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_mute = {"mute", "Off", CV_NETVAR|CV_CALL, CV_OnOff, Mute_OnChange, 0, NULL, NULL, 0, 0, NULL};
-consvar_t cv_sleep = {"cpusleep", "-1", CV_SAVE, sleeping_cons_t, NULL, -1, NULL, NULL, 0, 0, NULL};
+consvar_t cv_sleep = {"cpusleep", "1", CV_SAVE, sleeping_cons_t, NULL, -1, NULL, NULL, 0, 0, NULL};
+
+char timedemo_name[256];
+boolean timedemo_csv;
+char timedemo_csv_id[256];
+boolean timedemo_quit;
INT16 gametype = GT_COOP;
boolean splitscreen = false;
@@ -497,7 +502,7 @@ void D_RegisterServerCommands(void)
CV_RegisterVar(&cv_friendlyfire);
CV_RegisterVar(&cv_pointlimit);
CV_RegisterVar(&cv_numlaps);
- CV_RegisterVar(&cv_usemapnumlaps);
+ CV_RegisterVar(&cv_basenumlaps);
CV_RegisterVar(&cv_hazardlog);
@@ -573,9 +578,7 @@ void D_RegisterServerCommands(void)
CV_RegisterVar(&cv_skipmapcheck);
CV_RegisterVar(&cv_sleep);
-#ifdef NEWPING
CV_RegisterVar(&cv_maxping);
-#endif
#ifdef SEENAMES
CV_RegisterVar(&cv_allowseenames);
@@ -740,6 +743,8 @@ void D_RegisterClientCommands(void)
CV_RegisterVar(&cv_chasefreelook);
CV_RegisterVar(&cv_chasefreelook2);
CV_RegisterVar(&cv_tutorialprompt);
+ CV_RegisterVar(&cv_showfocuslost);
+ CV_RegisterVar(&cv_pauseifunfocused);
// g_input.c
CV_RegisterVar(&cv_sideaxis);
@@ -880,7 +885,7 @@ void D_RegisterClientCommands(void)
* \sa CleanupPlayerName, SetPlayerName, Got_NameAndColor
* \author Graue <graue@oceanbase.org>
*/
-static boolean IsNameGood(char *name, INT32 playernum)
+boolean EnsurePlayerNameIsGood(char *name, INT32 playernum)
{
INT32 ix;
@@ -921,14 +926,14 @@ static boolean IsNameGood(char *name, INT32 playernum)
if (len > 1)
{
name[len-1] = '\0';
- if (!IsNameGood (name, playernum))
+ if (!EnsurePlayerNameIsGood (name, playernum))
return false;
}
else if (len == 1) // Agh!
{
// Last ditch effort...
sprintf(name, "%d", M_RandomKey(10));
- if (!IsNameGood (name, playernum))
+ if (!EnsurePlayerNameIsGood (name, playernum))
return false;
}
else
@@ -1057,12 +1062,12 @@ static void CleanupPlayerName(INT32 playernum, const char *newname)
* \param newname New name for that player. Should be good, but won't
* necessarily be if the client is maliciously modified or
* buggy.
- * \sa CleanupPlayerName, IsNameGood
+ * \sa CleanupPlayerName, EnsurePlayerNameIsGood
* \author Graue <graue@oceanbase.org>
*/
static void SetPlayerName(INT32 playernum, char *newname)
{
- if (IsNameGood(newname, playernum))
+ if (EnsurePlayerNameIsGood(newname, playernum))
{
if (strcasecmp(newname, player_names[playernum]) != 0)
{
@@ -1187,12 +1192,12 @@ static void SendNameAndColor(void)
&& !strcmp(cv_skin.string, skins[players[consoleplayer].skin].name))
return;
+ players[consoleplayer].availabilities = R_GetSkinAvailabilities();
+
// We'll handle it later if we're not playing.
if (!Playing())
return;
- players[consoleplayer].availabilities = R_GetSkinAvailabilities();
-
// If you're not in a netgame, merely update the skin, color, and name.
if (!netgame)
{
@@ -1207,9 +1212,9 @@ static void SendNameAndColor(void)
players[consoleplayer].mo->color = players[consoleplayer].skincolor;
if (metalrecording)
- { // Metal Sonic is Sonic, obviously.
- SetPlayerSkinByNum(consoleplayer, 0);
- CV_StealthSet(&cv_skin, skins[0].name);
+ { // Starring Metal Sonic as themselves, obviously.
+ SetPlayerSkinByNum(consoleplayer, 5);
+ CV_StealthSet(&cv_skin, skins[5].name);
}
else if ((foundskin = R_SkinAvailable(cv_skin.string)) != -1 && R_SkinUsable(consoleplayer, foundskin))
{
@@ -1305,12 +1310,12 @@ static void SendNameAndColor2(void)
CV_StealthSet(&cv_playercolor2, cv_playercolor2.defaultvalue);
}
+ players[secondplaya].availabilities = R_GetSkinAvailabilities();
+
// We'll handle it later if we're not playing.
if (!Playing())
return;
- players[secondplaya].availabilities = R_GetSkinAvailabilities();
-
// If you're not in a netgame, merely update the skin, color, and name.
if (botingame)
{
@@ -1570,11 +1575,11 @@ static void Command_Playdemo_f(void)
static void Command_Timedemo_f(void)
{
- char name[256];
+ size_t i = 0;
- if (COM_Argc() != 2)
+ if (COM_Argc() < 2)
{
- CONS_Printf(M_GetText("timedemo <demoname>: time a demo\n"));
+ CONS_Printf(M_GetText("timedemo <demoname> [-csv [<trialid>]] [-quit]: time a demo\n"));
return;
}
@@ -1591,12 +1596,23 @@ static void Command_Timedemo_f(void)
G_StopMetalDemo();
// open the demo file
- strcpy (name, COM_Argv(1));
+ strcpy (timedemo_name, COM_Argv(1));
// dont add .lmp so internal game demos can be played
- CONS_Printf(M_GetText("Timing demo '%s'.\n"), name);
+ // print timedemo results as CSV?
+ i = COM_CheckParm("-csv");
+ timedemo_csv = (i > 0);
+ if (COM_CheckParm("-quit") != i + 1)
+ strcpy(timedemo_csv_id, COM_Argv(i + 1)); // user-defined string to identify row
+ else
+ timedemo_csv_id[0] = 0;
- G_TimeDemo(name);
+ // exit after the timedemo?
+ timedemo_quit = (COM_CheckParm("-quit") > 0);
+
+ CONS_Printf(M_GetText("Timing demo '%s'.\n"), timedemo_name);
+
+ G_TimeDemo(timedemo_name);
}
// stop current demo
@@ -1647,7 +1663,31 @@ void D_MapChange(INT32 mapnum, INT32 newgametype, boolean pultmode, boolean rese
// The supplied data are assumed to be good.
I_Assert(delay >= 0 && delay <= 2);
if (mapnum != -1)
+ {
CV_SetValue(&cv_nextmap, mapnum);
+ // Kick bot from special stages
+ if (botskin)
+ {
+ if (G_IsSpecialStage(mapnum) || (mapheaderinfo[mapnum-1] && (mapheaderinfo[mapnum-1]->typeoflevel & TOL_NIGHTS)))
+ {
+ if (botingame)
+ {
+ //CL_RemoveSplitscreenPlayer();
+ botingame = false;
+ playeringame[1] = false;
+ }
+ }
+ else if (!botingame)
+ {
+ //CL_AddSplitscreenPlayer();
+ botingame = true;
+ secondarydisplayplayer = 1;
+ playeringame[1] = true;
+ players[1].bot = 1;
+ SendNameAndColor2();
+ }
+ }
+ }
CONS_Debug(DBG_GAMELOGIC, "Map change: mapnum=%d gametype=%d ultmode=%d resetplayers=%d delay=%d skipprecutscene=%d\n",
mapnum, newgametype, pultmode, resetplayers, delay, skipprecutscene);
if ((netgame || multiplayer) && !((gametype == newgametype) && (newgametype == GT_COOP)))
@@ -1690,29 +1730,6 @@ void D_MapChange(INT32 mapnum, INT32 newgametype, boolean pultmode, boolean rese
return;
}
- // Kick bot from special stages
- if (botskin)
- {
- if (G_IsSpecialStage(mapnum))
- {
- if (botingame)
- {
- //CL_RemoveSplitscreenPlayer();
- botingame = false;
- playeringame[1] = false;
- }
- }
- else if (!botingame)
- {
- //CL_AddSplitscreenPlayer();
- botingame = true;
- secondarydisplayplayer = 1;
- playeringame[1] = true;
- players[1].bot = 1;
- SendNameAndColor2();
- }
- }
-
chmappending++;
if (netgame)
WRITEUINT32(buf_p, M_RandomizedSeed()); // random seed
@@ -2033,8 +2050,6 @@ static void Command_Suicide(void)
UINT8 buf[4];
UINT8 *cp = buf;
- WRITEINT32(cp, consoleplayer);
-
if (!(gamestate == GS_LEVEL || gamestate == GS_INTERMISSION))
{
CONS_Printf(M_GetText("You must be in a level to use this.\n"));
@@ -2054,6 +2069,7 @@ static void Command_Suicide(void)
return;
}
+ WRITEINT32(cp, consoleplayer);
SendNetXCmd(XD_SUICIDE, &buf, 4);
}
@@ -4466,3 +4482,14 @@ static void Command_ShowTime_f(void)
CONS_Printf(M_GetText("The current time is %f.\nThe timelimit is %f\n"), (double)leveltime/TICRATE, (double)timelimitintics/TICRATE);
}
+
+static void BaseNumLaps_OnChange(void)
+{
+ if (gametype == GT_RACE)
+ {
+ if (cv_basenumlaps.value)
+ CONS_Printf(M_GetText("Number of laps will be changed to map defaults next round.\n"));
+ else
+ CONS_Printf(M_GetText("Number of laps will be changed to %d next round.\n"), cv_basenumlaps.value);
+ }
+}
diff --git a/src/d_netcmd.h b/src/d_netcmd.h
index 5076c8afa3ffa7bc04c1cf48591b618726b83769..0b538890ec569dc8a2062889dc9842c502b89af3 100644
--- a/src/d_netcmd.h
+++ b/src/d_netcmd.h
@@ -66,7 +66,7 @@ extern consvar_t cv_friendlyfire;
extern consvar_t cv_pointlimit;
extern consvar_t cv_timelimit;
extern consvar_t cv_numlaps;
-extern consvar_t cv_usemapnumlaps;
+extern consvar_t cv_basenumlaps;
extern UINT32 timelimitintics;
extern consvar_t cv_allowexitlevel;
@@ -107,14 +107,17 @@ extern consvar_t cv_ringslinger, cv_soundtest;
extern consvar_t cv_specialrings, cv_powerstones, cv_matchboxes, cv_competitionboxes;
-#ifdef NEWPING
extern consvar_t cv_maxping;
-#endif
extern consvar_t cv_skipmapcheck;
extern consvar_t cv_sleep;
+extern char timedemo_name[256];
+extern boolean timedemo_csv;
+extern char timedemo_csv_id[256];
+extern boolean timedemo_quit;
+
typedef enum
{
XD_NAMEANDCOLOR = 1,
@@ -190,6 +193,7 @@ typedef union {
// add game commands, needs cleanup
void D_RegisterServerCommands(void);
void D_RegisterClientCommands(void);
+boolean EnsurePlayerNameIsGood(char *name, INT32 playernum);
void D_SendPlayerConfig(void);
void Command_ExitGame_f(void);
void Command_Retry_f(void);
diff --git a/src/d_netfil.c b/src/d_netfil.c
index ed2d11138ad267f51353c29673f15783b4a97061..5e7f59310c84bca583253276bee4927a995cf377 100644
--- a/src/d_netfil.c
+++ b/src/d_netfil.c
@@ -752,11 +752,9 @@ void Got_Filetxpak(void)
nameonly(filename);
if (!(strcmp(filename, "srb2.pk3")
- && strcmp(filename, "srb2.srb")
- && strcmp(filename, "srb2.wad")
- && strcmp(filename, "zones.dta")
+ && strcmp(filename, "zones.pk3")
&& strcmp(filename, "player.dta")
- && strcmp(filename, "patch.dta")
+ && strcmp(filename, "patch.pk3")
&& strcmp(filename, "music.dta")
))
I_Error("Tried to download \"%s\"", filename);
diff --git a/src/d_player.h b/src/d_player.h
index 69080bd9dc230450241fb0ca668a53c32d54889c..f2fdda0500ad09e1efa88736985f087c6428e5a8 100644
--- a/src/d_player.h
+++ b/src/d_player.h
@@ -234,7 +234,9 @@ typedef enum
CR_ZOOMTUBE,
CR_ROPEHANG,
CR_MACESPIN,
- CR_MINECART
+ CR_MINECART,
+ CR_ROLLOUT,
+ CR_PTERABYTE
} carrytype_t; // pw_carry
// Player powers. (don't edit this comment)
@@ -250,6 +252,8 @@ typedef enum
pw_spacetime, // In space, no one can hear you spin!
pw_extralife, // Extra Life timer
pw_pushing,
+ pw_justsprung,
+ pw_noautobrake,
pw_super, // Are you super?
pw_gravityboots, // gravity boots
@@ -509,6 +513,10 @@ typedef struct player_s
#endif
} player_t;
+// Values for dashmode
+#define DASHMODE_THRESHOLD (3*TICRATE)
+#define DASHMODE_MAX (DASHMODE_THRESHOLD + 3)
+
// Value for infinite lives
#define INFLIVES 0x7F
diff --git a/src/dehacked.c b/src/dehacked.c
index 4cdffd5edf99f45bae30be1d82b76e908982b24c..bf8bf62b524cd73167d858e89408c8285e9fc134 100644
--- a/src/dehacked.c
+++ b/src/dehacked.c
@@ -313,7 +313,13 @@ static boolean findFreeSlot(INT32 *num)
if (*num >= MAXSKINS)
return false;
- description[*num].picname[0] = '\0'; // Redesign your logo. (See M_DrawSetupChoosePlayerMenu in m_menu.c...)
+ // Redesign your logo. (See M_DrawSetupChoosePlayerMenu in m_menu.c...)
+ description[*num].picname[0] = '\0';
+ description[*num].nametag[0] = '\0';
+ description[*num].displayname[0] = '\0';
+ description[*num].oppositecolor = SKINCOLOR_NONE;
+ description[*num].tagtextcolor = SKINCOLOR_NONE;
+ description[*num].tagoutlinecolor = SKINCOLOR_NONE;
// Found one! ^_^
return (description[*num].used = true);
@@ -326,9 +332,16 @@ static void readPlayer(MYFILE *f, INT32 num)
char *s = Z_Malloc(MAXLINELEN, PU_STATIC, NULL);
char *word;
char *word2;
+ char *displayname = ZZ_Alloc(MAXLINELEN+1);
INT32 i;
boolean slotfound = false;
+ #define SLOTFOUND \
+ if (!slotfound && (slotfound = findFreeSlot(&num)) == false) \
+ goto done;
+
+ displayname[MAXLINELEN] = '\0';
+
do
{
if (myfgets(s, MAXLINELEN, f))
@@ -336,6 +349,17 @@ static void readPlayer(MYFILE *f, INT32 num)
if (s[0] == '\n')
break;
+ for (i = 0; i < MAXLINELEN-3; i++)
+ {
+ char *tmp;
+ if (s[i] == '=')
+ {
+ tmp = &s[i+2];
+ strncpy(displayname, tmp, SKINNAMESIZE);
+ break;
+ }
+ }
+
word = strtok(s, " ");
if (word)
strupr(word);
@@ -346,8 +370,7 @@ static void readPlayer(MYFILE *f, INT32 num)
{
char *playertext = NULL;
- if (!slotfound && (slotfound = findFreeSlot(&num)) == false)
- goto done;
+ SLOTFOUND
for (i = 0; i < MAXLINELEN-3; i++)
{
@@ -395,11 +418,54 @@ static void readPlayer(MYFILE *f, INT32 num)
if (fastcmp(word, "PICNAME"))
{
- if (!slotfound && (slotfound = findFreeSlot(&num)) == false)
- goto done;
-
+ SLOTFOUND
strncpy(description[num].picname, word2, 8);
}
+ // new character select
+ else if (fastcmp(word, "DISPLAYNAME"))
+ {
+ SLOTFOUND
+ // replace '#' with line breaks
+ // (also remove any '\n')
+ {
+ char *cur = NULL;
+
+ // remove '\n'
+ cur = strchr(displayname, '\n');
+ if (cur)
+ *cur = '\0';
+
+ // turn '#' into '\n'
+ cur = strchr(displayname, '#');
+ while (cur)
+ {
+ *cur = '\n';
+ cur = strchr(cur, '#');
+ }
+ }
+ // copy final string
+ strncpy(description[num].displayname, displayname, SKINNAMESIZE);
+ }
+ else if (fastcmp(word, "OPPOSITECOLOR") || fastcmp(word, "OPPOSITECOLOUR"))
+ {
+ SLOTFOUND
+ description[num].oppositecolor = (UINT8)get_number(word2);
+ }
+ else if (fastcmp(word, "NAMETAG") || fastcmp(word, "TAGNAME"))
+ {
+ SLOTFOUND
+ strncpy(description[num].nametag, word2, 8);
+ }
+ else if (fastcmp(word, "TAGTEXTCOLOR") || fastcmp(word, "TAGTEXTCOLOUR"))
+ {
+ SLOTFOUND
+ description[num].tagtextcolor = (UINT8)get_number(word2);
+ }
+ else if (fastcmp(word, "TAGOUTLINECOLOR") || fastcmp(word, "TAGOUTLINECOLOUR"))
+ {
+ SLOTFOUND
+ description[num].tagoutlinecolor = (UINT8)get_number(word2);
+ }
else if (fastcmp(word, "STATUS"))
{
/*
@@ -417,9 +483,7 @@ static void readPlayer(MYFILE *f, INT32 num)
else if (fastcmp(word, "SKINNAME"))
{
// Send to free slot.
- if (!slotfound && (slotfound = findFreeSlot(&num)) == false)
- goto done;
-
+ SLOTFOUND
strlcpy(description[num].skinname, word2, sizeof description[num].skinname);
strlwr(description[num].skinname);
}
@@ -427,8 +491,9 @@ static void readPlayer(MYFILE *f, INT32 num)
deh_warning("readPlayer %d: unknown word '%s'", num, word);
}
} while (!myfeof(f)); // finish when the line is empty
-
+ #undef SLOTFOUND
done:
+ Z_Free(displayname);
Z_Free(s);
}
@@ -2024,12 +2089,59 @@ static void readmenu(MYFILE *f, INT32 num)
menupres[num].bgcolor = get_number(word2);
titlechanged = true;
}
- else if (fastcmp(word, "HIDETITLEPICS") || fastcmp(word, "HIDEPICS"))
+ else if (fastcmp(word, "HIDETITLEPICS") || fastcmp(word, "HIDEPICS") || fastcmp(word, "TITLEPICSHIDE"))
{
// true by default, except MM_MAIN
menupres[num].hidetitlepics = (boolean)(value || word2[0] == 'T' || word2[0] == 'Y');
titlechanged = true;
}
+ else if (fastcmp(word, "TITLEPICSMODE"))
+ {
+ if (fastcmp(word2, "USER"))
+ menupres[num].ttmode = TTMODE_USER;
+ else if (fastcmp(word2, "ALACROIX"))
+ menupres[num].ttmode = TTMODE_ALACROIX;
+ else if (fastcmp(word2, "HIDE") || fastcmp(word2, "HIDDEN") || fastcmp(word2, "NONE"))
+ {
+ menupres[num].ttmode = TTMODE_USER;
+ menupres[num].ttname[0] = 0;
+ menupres[num].hidetitlepics = true;
+ }
+ else // if (fastcmp(word2, "OLD") || fastcmp(word2, "SSNTAILS"))
+ menupres[num].ttmode = TTMODE_OLD;
+ titlechanged = true;
+ }
+ else if (fastcmp(word, "TITLEPICSSCALE"))
+ {
+ // Don't handle Alacroix special case here; see Maincfg section.
+ menupres[num].ttscale = max(1, min(8, (UINT8)get_number(word2)));
+ titlechanged = true;
+ }
+ else if (fastcmp(word, "TITLEPICSNAME"))
+ {
+ strncpy(menupres[num].ttname, word2, 9);
+ titlechanged = true;
+ }
+ else if (fastcmp(word, "TITLEPICSX"))
+ {
+ menupres[num].ttx = (INT16)get_number(word2);
+ titlechanged = true;
+ }
+ else if (fastcmp(word, "TITLEPICSY"))
+ {
+ menupres[num].tty = (INT16)get_number(word2);
+ titlechanged = true;
+ }
+ else if (fastcmp(word, "TITLEPICSLOOP"))
+ {
+ menupres[num].ttloop = (INT16)get_number(word2);
+ titlechanged = true;
+ }
+ else if (fastcmp(word, "TITLEPICSTICS"))
+ {
+ menupres[num].tttics = (UINT16)get_number(word2);
+ titlechanged = true;
+ }
else if (fastcmp(word, "TITLESCROLLSPEED") || fastcmp(word, "TITLESCROLLXSPEED")
|| fastcmp(word, "SCROLLSPEED") || fastcmp(word, "SCROLLXSPEED"))
{
@@ -2243,6 +2355,7 @@ static actionpointer_t actionpointers[] =
{{A_ThrownRing}, "A_THROWNRING"},
{{A_SetSolidSteam}, "A_SETSOLIDSTEAM"},
{{A_UnsetSolidSteam}, "A_UNSETSOLIDSTEAM"},
+ {{A_SignSpin}, "S_SIGNSPIN"},
{{A_SignPlayer}, "A_SIGNPLAYER"},
{{A_OverlayThink}, "A_OVERLAYTHINK"},
{{A_JetChase}, "A_JETCHASE"},
@@ -2447,6 +2560,14 @@ static actionpointer_t actionpointers[] =
{{A_SaloonDoorSpawn}, "A_SALOONDOORSPAWN"},
{{A_MinecartSparkThink}, "A_MINECARTSPARKTHINK"},
{{A_ModuloToState}, "A_MODULOTOSTATE"},
+ {{A_LavafallRocks}, "A_LAVAFALLROCKS"},
+ {{A_LavafallLava}, "A_LAVAFALLLAVA"},
+ {{A_FallingLavaCheck}, "A_FALLINGLAVACHECK"},
+ {{A_FireShrink}, "A_FIRESHRINK"},
+ {{A_SpawnPterabytes}, "A_SPAWNPTERABYTES"},
+ {{A_PterabyteHover}, "A_PTERABYTEHOVER"},
+ {{A_RolloutSpawn}, "A_ROLLOUTSPAWN"},
+ {{A_RolloutRock}, "A_ROLLOUTROCK"},
{{NULL}, "NONE"},
// This NULL entry must be the last in the list
@@ -3419,11 +3540,78 @@ static void readmaincfg(MYFILE *f)
titlemap = (INT16)value;
titlechanged = true;
}
- else if (fastcmp(word, "HIDETITLEPICS"))
+ else if (fastcmp(word, "HIDETITLEPICS") || fastcmp(word, "TITLEPICSHIDE"))
{
hidetitlepics = (boolean)(value || word2[0] == 'T' || word2[0] == 'Y');
titlechanged = true;
}
+ else if (fastcmp(word, "TITLEPICSMODE"))
+ {
+ if (fastcmp(word2, "USER"))
+ ttmode = TTMODE_USER;
+ else if (fastcmp(word2, "ALACROIX"))
+ ttmode = TTMODE_ALACROIX;
+ else if (fastcmp(word2, "HIDE") || fastcmp(word2, "HIDDEN") || fastcmp(word2, "NONE"))
+ {
+ ttmode = TTMODE_USER;
+ ttname[0] = 0;
+ hidetitlepics = true;
+ }
+ else // if (fastcmp(word2, "OLD") || fastcmp(word2, "SSNTAILS"))
+ ttmode = TTMODE_OLD;
+ titlechanged = true;
+ }
+ else if (fastcmp(word, "TITLEPICSSCALE"))
+ {
+ ttscale = max(1, min(8, (UINT8)get_number(word2)));
+ titlechanged = true;
+ }
+ else if (fastcmp(word, "TITLEPICSSCALESAVAILABLE"))
+ {
+ // SPECIAL CASE for Alacroix: Comma-separated list of resolutions that are available
+ // for gfx loading.
+ ttavailable[0] = ttavailable[1] = ttavailable[2] = ttavailable[3] =\
+ ttavailable[4] = ttavailable[5] = false;
+
+ if (strstr(word2, "1") != NULL)
+ ttavailable[0] = true;
+ if (strstr(word2, "2") != NULL)
+ ttavailable[1] = true;
+ if (strstr(word2, "3") != NULL)
+ ttavailable[2] = true;
+ if (strstr(word2, "4") != NULL)
+ ttavailable[3] = true;
+ if (strstr(word2, "5") != NULL)
+ ttavailable[4] = true;
+ if (strstr(word2, "6") != NULL)
+ ttavailable[5] = true;
+ titlechanged = true;
+ }
+ else if (fastcmp(word, "TITLEPICSNAME"))
+ {
+ strncpy(ttname, word2, 9);
+ titlechanged = true;
+ }
+ else if (fastcmp(word, "TITLEPICSX"))
+ {
+ ttx = (INT16)get_number(word2);
+ titlechanged = true;
+ }
+ else if (fastcmp(word, "TITLEPICSY"))
+ {
+ tty = (INT16)get_number(word2);
+ titlechanged = true;
+ }
+ else if (fastcmp(word, "TITLEPICSLOOP"))
+ {
+ ttloop = (INT16)get_number(word2);
+ titlechanged = true;
+ }
+ else if (fastcmp(word, "TITLEPICSTICS"))
+ {
+ tttics = (UINT16)get_number(word2);
+ titlechanged = true;
+ }
else if (fastcmp(word, "TITLESCROLLSPEED") || fastcmp(word, "TITLESCROLLXSPEED"))
{
titlescrollxspeed = get_number(word2);
@@ -4185,6 +4373,7 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
// CA_GLIDEANDCLIMB
"S_PLAY_GLIDE",
+ "S_PLAY_GLIDE_LANDING",
"S_PLAY_CLING",
"S_PLAY_CLIMB",
@@ -4284,6 +4473,9 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_TAILSOVERLAY_GASP",
"S_TAILSOVERLAY_EDGE",
+ // [:
+ "S_JETFUMEFLASH",
+
// Blue Crawla
"S_POSS_STND",
"S_POSS_RUN1",
@@ -4432,6 +4624,21 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_CRUSHCLAW_WAIT",
"S_CRUSHCHAIN",
+ // Banpyura
+ "S_BANPYURA_ROAM1",
+ "S_BANPYURA_ROAM2",
+ "S_BANPYURA_ROAM3",
+ "S_BANPYURA_ROAM4",
+ "S_BANPYURA_ROAMPAUSE",
+ "S_CDIAG1",
+ "S_CDIAG2",
+ "S_CDIAG3",
+ "S_CDIAG4",
+ "S_CDIAG5",
+ "S_CDIAG6",
+ "S_CDIAG7",
+ "S_CDIAG8",
+
// Jet Jaw
"S_JETJAW_ROAM1",
"S_JETJAW_ROAM2",
@@ -4618,6 +4825,22 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_CANARIVOREGAS_7",
"S_CANARIVOREGAS_8",
+ // Pyre Fly
+ "S_PYREFLY_FLY",
+ "S_PYREFLY_BURN",
+ "S_PYREFIRE1",
+ "S_PYREFIRE2",
+
+ // Pterabyte
+ "S_PTERABYTESPAWNER",
+ "S_PTERABYTEWAYPOINT",
+ "S_PTERABYTE_FLY1",
+ "S_PTERABYTE_FLY2",
+ "S_PTERABYTE_FLY3",
+ "S_PTERABYTE_FLY4",
+ "S_PTERABYTE_SWOOPDOWN",
+ "S_PTERABYTE_SWOOPUP",
+
// Boss Explosion
"S_BOSSEXPLODE",
@@ -5152,25 +5375,7 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_CYBRAKDEMONVILEEXPLOSION3",
// Metal Sonic (Race)
- // S_PLAY_STND
- "S_METALSONIC_STAND",
- // S_PLAY_TAP1
- "S_METALSONIC_WAIT1",
- "S_METALSONIC_WAIT2",
- // S_PLAY_WALK
- "S_METALSONIC_WALK1",
- "S_METALSONIC_WALK2",
- "S_METALSONIC_WALK3",
- "S_METALSONIC_WALK4",
- "S_METALSONIC_WALK5",
- "S_METALSONIC_WALK6",
- "S_METALSONIC_WALK7",
- "S_METALSONIC_WALK8",
- // S_PLAY_SPD1
- "S_METALSONIC_RUN1",
- "S_METALSONIC_RUN2",
- "S_METALSONIC_RUN3",
- "S_METALSONIC_RUN4",
+ "S_METALSONIC_RACE",
// Metal Sonic (Battle)
"S_METALSONIC_FLOAT",
"S_METALSONIC_VECTOR",
@@ -5277,59 +5482,18 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_BUBBLES4",
// Level End Sign
- "S_SIGN1",
- "S_SIGN2",
- "S_SIGN3",
- "S_SIGN4",
- "S_SIGN5",
- "S_SIGN6",
- "S_SIGN7",
- "S_SIGN8",
- "S_SIGN9",
- "S_SIGN10",
- "S_SIGN11",
- "S_SIGN12",
- "S_SIGN13",
- "S_SIGN14",
- "S_SIGN15",
- "S_SIGN16",
- "S_SIGN17",
- "S_SIGN18",
- "S_SIGN19",
- "S_SIGN20",
- "S_SIGN21",
- "S_SIGN22",
- "S_SIGN23",
- "S_SIGN24",
- "S_SIGN25",
- "S_SIGN26",
- "S_SIGN27",
- "S_SIGN28",
- "S_SIGN29",
- "S_SIGN30",
- "S_SIGN31",
- "S_SIGN32",
- "S_SIGN33",
- "S_SIGN34",
- "S_SIGN35",
- "S_SIGN36",
- "S_SIGN37",
- "S_SIGN38",
- "S_SIGN39",
- "S_SIGN40",
- "S_SIGN41",
- "S_SIGN42",
- "S_SIGN43",
- "S_SIGN44",
- "S_SIGN45",
- "S_SIGN46",
- "S_SIGN47",
- "S_SIGN48",
- "S_SIGN49",
- "S_SIGN50",
- "S_SIGN51",
- "S_SIGN52", // Eggman
- "S_SIGN53",
+ "S_SIGN",
+ "S_SIGNSPIN1",
+ "S_SIGNSPIN2",
+ "S_SIGNSPIN3",
+ "S_SIGNSPIN4",
+ "S_SIGNSPIN5",
+ "S_SIGNSPIN6",
+ "S_SIGNPLAYER",
+ "S_SIGNSLOW",
+ "S_SIGNSTOP",
+ "S_SIGNBOARD",
+ "S_EGGMANSIGN",
// Spike Ball
"S_SPIKEBALL1",
@@ -5554,7 +5718,7 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_ARROW",
"S_ARROWBONK",
- // Trapgoyle Demon fire
+ // Glaregoyle Demon fire
"S_DEMONFIRE",
// GFZ flowers
@@ -5861,7 +6025,7 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
// Saloon door
"S_SALOONDOOR",
- "S_SALOONDOORTHINKER",
+ "S_SALOONDOORCENTER",
// Train cameo
"S_TRAINCAMEOSPAWNER_1",
@@ -5882,6 +6046,12 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_FLAMEJETFLAME1",
"S_FLAMEJETFLAME2",
"S_FLAMEJETFLAME3",
+ "S_FLAMEJETFLAME4",
+ "S_FLAMEJETFLAME5",
+ "S_FLAMEJETFLAME6",
+ "S_FLAMEJETFLAME7",
+ "S_FLAMEJETFLAME8",
+ "S_FLAMEJETFLAME9",
// Spinning flame jets
"S_FJSPINAXISA1", // Counter-clockwise
@@ -5894,29 +6064,57 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_FLAMEJETFLAMEB2",
"S_FLAMEJETFLAMEB3",
- // Trapgoyles
- "S_TRAPGOYLE",
- "S_TRAPGOYLE_CHECK",
- "S_TRAPGOYLE_FIRE1",
- "S_TRAPGOYLE_FIRE2",
- "S_TRAPGOYLE_FIRE3",
- "S_TRAPGOYLEUP",
- "S_TRAPGOYLEUP_CHECK",
- "S_TRAPGOYLEUP_FIRE1",
- "S_TRAPGOYLEUP_FIRE2",
- "S_TRAPGOYLEUP_FIRE3",
- "S_TRAPGOYLEDOWN",
- "S_TRAPGOYLEDOWN_CHECK",
- "S_TRAPGOYLEDOWN_FIRE1",
- "S_TRAPGOYLEDOWN_FIRE2",
- "S_TRAPGOYLEDOWN_FIRE3",
- "S_TRAPGOYLELONG",
- "S_TRAPGOYLELONG_CHECK",
- "S_TRAPGOYLELONG_FIRE1",
- "S_TRAPGOYLELONG_FIRE2",
- "S_TRAPGOYLELONG_FIRE3",
- "S_TRAPGOYLELONG_FIRE4",
- "S_TRAPGOYLELONG_FIRE5",
+ // Lavafall
+ "S_LAVAFALL_DORMANT",
+ "S_LAVAFALL_TELL",
+ "S_LAVAFALL_SHOOT",
+ "S_LAVAFALL_LAVA1",
+ "S_LAVAFALL_LAVA2",
+ "S_LAVAFALL_LAVA3",
+ "S_LAVAFALLROCK",
+
+ // Rollout Rock
+ "S_ROLLOUTSPAWN",
+ "S_ROLLOUTROCK",
+
+ // RVZ scenery
+ "S_BIGFERNLEAF",
+ "S_BIGFERN1",
+ "S_BIGFERN2",
+ "S_JUNGLEPALM",
+ "S_TORCHFLOWER",
+ "S_WALLVINE_LONG",
+ "S_WALLVINE_SHORT",
+
+ // Glaregoyles
+ "S_GLAREGOYLE",
+ "S_GLAREGOYLE_CHARGE",
+ "S_GLAREGOYLE_BLINK",
+ "S_GLAREGOYLE_HOLD",
+ "S_GLAREGOYLE_FIRE",
+ "S_GLAREGOYLE_LOOP",
+ "S_GLAREGOYLE_COOLDOWN",
+ "S_GLAREGOYLEUP",
+ "S_GLAREGOYLEUP_CHARGE",
+ "S_GLAREGOYLEUP_BLINK",
+ "S_GLAREGOYLEUP_HOLD",
+ "S_GLAREGOYLEUP_FIRE",
+ "S_GLAREGOYLEUP_LOOP",
+ "S_GLAREGOYLEUP_COOLDOWN",
+ "S_GLAREGOYLEDOWN",
+ "S_GLAREGOYLEDOWN_CHARGE",
+ "S_GLAREGOYLEDOWN_BLINK",
+ "S_GLAREGOYLEDOWN_HOLD",
+ "S_GLAREGOYLEDOWN_FIRE",
+ "S_GLAREGOYLEDOWN_LOOP",
+ "S_GLAREGOYLEDOWN_COOLDOWN",
+ "S_GLAREGOYLELONG",
+ "S_GLAREGOYLELONG_CHARGE",
+ "S_GLAREGOYLELONG_BLINK",
+ "S_GLAREGOYLELONG_HOLD",
+ "S_GLAREGOYLELONG_FIRE",
+ "S_GLAREGOYLELONG_LOOP",
+ "S_GLAREGOYLELONG_COOLDOWN",
// ATZ's Red Crystal/Target
"S_TARGET_IDLE",
@@ -5925,6 +6123,12 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_TARGET_RESPAWN",
"S_TARGET_ALLDONE",
+ // ATZ's green flame
+ "S_GREENFLAME",
+
+ // ATZ Blue Gargoyle
+ "S_BLUEGARGOYLE",
+
// Stalagmites
"S_STG0",
"S_STG1",
@@ -5945,6 +6149,7 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_LAMPPOST1", // normal
"S_LAMPPOST2", // with snow
"S_HANGSTAR",
+ "S_MISTLETOE",
// Xmas GFZ bushes
"S_XMASBLUEBERRYBUSH",
"S_XMASBERRYBUSH",
@@ -5952,6 +6157,16 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
// FHZ
"S_FHZICE1",
"S_FHZICE2",
+ "S_ROSY_IDLE1",
+ "S_ROSY_IDLE2",
+ "S_ROSY_IDLE3",
+ "S_ROSY_IDLE4",
+ "S_ROSY_JUMP",
+ "S_ROSY_WALK",
+ "S_ROSY_HUG",
+ "S_ROSY_PAIN",
+ "S_ROSY_STND",
+ "S_ROSY_UNHAPPY",
// Halloween Scenery
// Pumpkins
@@ -6603,6 +6818,16 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_BHORIZ7",
"S_BHORIZ8",
+ "S_BOOSTERSOUND",
+ "S_YELLOWBOOSTERROLLER",
+ "S_YELLOWBOOSTERSEG_LEFT",
+ "S_YELLOWBOOSTERSEG_RIGHT",
+ "S_YELLOWBOOSTERSEG_FACE",
+ "S_REDBOOSTERROLLER",
+ "S_REDBOOSTERSEG_LEFT",
+ "S_REDBOOSTERSEG_RIGHT",
+ "S_REDBOOSTERSEG_FACE",
+
// Rain
"S_RAIN1",
"S_RAINRETURN",
@@ -6623,6 +6848,9 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_SPLISH8",
"S_SPLISH9",
+ // Lava splish
+ "S_LAVASPLISH",
+
// added water splash
"S_SPLASH1",
"S_SPLASH2",
@@ -7090,8 +7318,8 @@ static const char *const STATE_LIST[] = { // array length left dynamic for sanit
"S_BUMBLEBORE_STUCK2",
"S_BUMBLEBORE_DIE",
- "S_BBUZZFLY1",
- "S_BBUZZFLY2",
+ "S_BUGGLEIDLE",
+ "S_BUGGLEFLY",
"S_SMASHSPIKE_FLOAT",
"S_SMASHSPIKE_EASE1",
@@ -7234,6 +7462,7 @@ static const char *const MOBJTYPE_LIST[] = { // array length left dynamic for s
"MT_THOK", // Thok! mobj
"MT_PLAYER",
"MT_TAILSOVERLAY", // c:
+ "MT_METALJETFUME", // [:
// Enemies
"MT_BLUECRAWLA", // Crawla (Blue)
@@ -7252,6 +7481,8 @@ static const char *const MOBJTYPE_LIST[] = { // array length left dynamic for s
"MT_CRUSHSTACEAN", // Crushstacean
"MT_CRUSHCLAW", // Big meaty claw
"MT_CRUSHCHAIN", // Chain
+ "MT_BANPYURA", // Banpyura
+ "MT_BANPSPRING", // Banpyura spring
"MT_JETJAW", // Jet Jaw
"MT_SNAILER", // Snailer
"MT_VULTURE", // BASH
@@ -7273,6 +7504,11 @@ static const char *const MOBJTYPE_LIST[] = { // array length left dynamic for s
"MT_UNIBALL", // Unidus Ball
"MT_CANARIVORE", // Canarivore
"MT_CANARIVORE_GAS", // Canarivore gas
+ "MT_PYREFLY", // Pyre Fly
+ "MT_PYREFLY_FIRE", // Pyre Fly fire
+ "MT_PTERABYTESPAWNER", // Pterabyte spawner
+ "MT_PTERABYTEWAYPOINT", // Pterabyte waypoint
+ "MT_PTERABYTE", // Pterabyte
// Generic Boss Items
"MT_BOSSEXPLODE",
@@ -7384,6 +7620,11 @@ static const char *const MOBJTYPE_LIST[] = { // array length left dynamic for s
"MT_REDHORIZ",
"MT_BLUEHORIZ",
+ "MT_BOOSTERSEG",
+ "MT_BOOSTERROLLER",
+ "MT_YELLOWBOOSTER",
+ "MT_REDBOOSTER",
+
// Interactive Objects
"MT_BUBBLES", // Bubble source
"MT_SIGN", // Level end sign
@@ -7474,7 +7715,7 @@ static const char *const MOBJTYPE_LIST[] = { // array length left dynamic for s
"MT_CANNONBALL", // Cannonball
"MT_CANNONBALLDECOR", // Decorative/still cannonball
"MT_ARROW", // Arrow
- "MT_DEMONFIRE", // Trapgoyle fire
+ "MT_DEMONFIRE", // Glaregoyle fire
// Greenflower Scenery
"MT_GFZFLOWER1",
@@ -7601,7 +7842,7 @@ static const char *const MOBJTYPE_LIST[] = { // array length left dynamic for s
"MT_MINECARTSIDEMARK",
"MT_MINECARTSPARK",
"MT_SALOONDOOR",
- "MT_SALOONDOORTHINKER",
+ "MT_SALOONDOORCENTER",
"MT_TRAINCAMEOSPAWNER",
"MT_TRAINSEG",
"MT_TRAINDUSTSPAWNER",
@@ -7618,16 +7859,32 @@ static const char *const MOBJTYPE_LIST[] = { // array length left dynamic for s
"MT_FLAMEJETFLAMEB", // Blade's flame
+ "MT_LAVAFALL",
+ "MT_LAVAFALL_LAVA",
+ "MT_LAVAFALLROCK",
+
+ "MT_ROLLOUTSPAWN",
+ "MT_ROLLOUTROCK",
+
+ "MT_BIGFERNLEAF",
+ "MT_BIGFERN",
+ "MT_JUNGLEPALM",
+ "MT_TORCHFLOWER",
+ "MT_WALLVINE_LONG",
+ "MT_WALLVINE_SHORT",
+
// Dark City Scenery
// Egg Rock Scenery
// Azure Temple Scenery
- "MT_TRAPGOYLE",
- "MT_TRAPGOYLEUP",
- "MT_TRAPGOYLEDOWN",
- "MT_TRAPGOYLELONG",
+ "MT_GLAREGOYLE",
+ "MT_GLAREGOYLEUP",
+ "MT_GLAREGOYLEDOWN",
+ "MT_GLAREGOYLELONG",
"MT_TARGET",
+ "MT_GREENFLAME",
+ "MT_BLUEGARGOYLE",
// Stalagmites
"MT_STALAGMITE0",
@@ -7649,6 +7906,7 @@ static const char *const MOBJTYPE_LIST[] = { // array length left dynamic for s
"MT_LAMPPOST1", // normal
"MT_LAMPPOST2", // with snow
"MT_HANGSTAR",
+ "MT_MISTLETOE",
// Xmas GFZ bushes
"MT_XMASBLUEBERRYBUSH",
"MT_XMASBERRYBUSH",
@@ -7656,6 +7914,8 @@ static const char *const MOBJTYPE_LIST[] = { // array length left dynamic for s
// FHZ
"MT_FHZICE1",
"MT_FHZICE2",
+ "MT_ROSY",
+ "MT_CDLHRT",
// Halloween Scenery
// Pumpkins
@@ -7784,6 +8044,7 @@ static const char *const MOBJTYPE_LIST[] = { // array length left dynamic for s
"MT_RAIN", // Rain
"MT_SNOWFLAKE", // Snowflake
"MT_SPLISH", // Water splish!
+ "MT_LAVASPLISH", // Lava splish!
"MT_SMOKE",
"MT_SMALLBUBBLE", // small bubble
"MT_MEDIUMBUBBLE", // medium bubble
@@ -7898,7 +8159,7 @@ static const char *const MOBJTYPE_LIST[] = { // array length left dynamic for s
"MT_HIVEELEMENTAL",
"MT_BUMBLEBORE",
- "MT_BUBBLEBUZZ",
+ "MT_BUGGLE",
"MT_SMASHINGSPIKEBALL",
"MT_CACOLANTERN",
@@ -8269,6 +8530,8 @@ static const char *const POWERS_LIST[] = {
"SPACETIME", // In space, no one can hear you spin!
"EXTRALIFE", // Extra Life timer
"PUSHING",
+ "JUSTSPRUNG",
+ "NOAUTOBRAKE",
"SUPER", // Are you super?
"GRAVITYBOOTS", // gravity boots
@@ -8609,6 +8872,8 @@ struct {
{"CR_ROPEHANG",CR_ROPEHANG},
{"CR_MACESPIN",CR_MACESPIN},
{"CR_MINECART",CR_MINECART},
+ {"CR_ROLLOUT", CR_ROLLOUT},
+ {"CR_PTERABYTE",CR_PTERABYTE},
// Ring weapons (ringweapons_t)
// Useful for A_GiveWeapon
@@ -8830,9 +9095,9 @@ struct {
{"FF_PLATFORM",FF_PLATFORM}, ///< You can jump up through this to the top.
{"FF_REVERSEPLATFORM",FF_REVERSEPLATFORM}, ///< A fall-through floor in normal gravity, a platform in reverse gravity.
{"FF_INTANGABLEFLATS",FF_INTANGABLEFLATS}, ///< Both flats are intangable, but the sides are still solid.
- {"FF_SHATTER",FF_SHATTER}, ///< Used with ::FF_BUSTUP. Thinks everyone's Knuckles.
- {"FF_SPINBUST",FF_SPINBUST}, ///< Used with ::FF_BUSTUP. Jump or fall onto it while curled in a ball.
- {"FF_ONLYKNUX",FF_ONLYKNUX}, ///< Used with ::FF_BUSTUP. Only Knuckles can break this rock.
+ {"FF_SHATTER",FF_SHATTER}, ///< Used with ::FF_BUSTUP. Bustable on mere touch.
+ {"FF_SPINBUST",FF_SPINBUST}, ///< Used with ::FF_BUSTUP. Also bustable if you're in your spinning frames.
+ {"FF_STRONGBUST",FF_STRONGBUST }, ///< Used with ::FF_BUSTUP. Only bustable by "strong" characters (Knuckles) and abilities (bouncing, twinspin, melee).
{"FF_RIPPLE",FF_RIPPLE}, ///< Ripple the flats
{"FF_COLORMAPONLY",FF_COLORMAPONLY}, ///< Only copy the colormap, not the lightlevel
{"FF_GOOWATER",FF_GOOWATER}, ///< Used with ::FF_SWIMMABLE. Makes thick bouncey goop.
@@ -8963,6 +9228,7 @@ struct {
{"V_OFFSET",V_OFFSET},
{"V_ALLOWLOWERCASE",V_ALLOWLOWERCASE},
{"V_FLIP",V_FLIP},
+ {"V_CENTERNAMETAG",V_CENTERNAMETAG},
{"V_SNAPTOTOP",V_SNAPTOTOP},
{"V_SNAPTOBOTTOM",V_SNAPTOBOTTOM},
{"V_SNAPTOLEFT",V_SNAPTOLEFT},
@@ -8996,6 +9262,7 @@ struct {
{"TC_ALLWHITE",TC_ALLWHITE},
{"TC_RAINBOW",TC_RAINBOW},
{"TC_BLINK",TC_BLINK},
+ {"TC_DASHMODE",TC_DASHMODE},
#endif
{NULL,0}
@@ -9982,6 +10249,23 @@ static inline int lib_getenum(lua_State *L)
} else if (fastcmp(word,"mapmusposition")) {
lua_pushinteger(L, mapmusposition);
return 1;
+ // local player variables, by popular request
+ } else if (fastcmp(word,"consoleplayer")) { // player controlling console (aka local player 1)
+ if (consoleplayer < 0 || !playeringame[consoleplayer])
+ return 0;
+ LUA_PushUserdata(L, &players[consoleplayer], META_PLAYER);
+ return 1;
+ } else if (fastcmp(word,"displayplayer")) { // player visible on screen (aka display player 1)
+ if (displayplayer < 0 || !playeringame[displayplayer])
+ return 0;
+ LUA_PushUserdata(L, &players[displayplayer], META_PLAYER);
+ return 1;
+ } else if (fastcmp(word,"secondarydisplayplayer")) { // local/display player 2, for splitscreen
+ if (!splitscreen || secondarydisplayplayer < 0 || !playeringame[secondarydisplayplayer])
+ return 0;
+ LUA_PushUserdata(L, &players[secondarydisplayplayer], META_PLAYER);
+ return 1;
+ // end local player variables
} else if (fastcmp(word,"server")) {
if ((!multiplayer || !netgame) && !playeringame[serverplayer])
return 0;
diff --git a/src/doomdef.h b/src/doomdef.h
index 3e801f2f657c9656abca043bf304239ad27467ad..b087f45d348cad628a98eea41b3b156608032efe 100644
--- a/src/doomdef.h
+++ b/src/doomdef.h
@@ -509,13 +509,17 @@ INT32 I_GetKey(void);
// Max gamepad/joysticks that can be detected/used.
#define MAX_JOYSTICKS 4
+#ifndef M_PIl
+#define M_PIl 3.1415926535897932384626433832795029L
+#endif
+
// Floating point comparison epsilons from float.h
#ifndef FLT_EPSILON
#define FLT_EPSILON 1.1920928955078125e-7f
#endif
#ifndef DBL_EPSILON
-#define DBL_EPSILON 2.2204460492503131e-16
+#define DBL_EPSILON 2.2204460492503131e-16l
#endif
// An assert-type mechanism.
@@ -561,9 +565,6 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
/// Polyobject fake flat code
#define POLYOBJECTS_PLANES
-/// Improved way of dealing with ping values and a ping limit.
-#define NEWPING
-
/// See name of player in your crosshair
#define SEENAMES
diff --git a/src/doomstat.h b/src/doomstat.h
index 57e37f72dc98dfbcbecdb225292e6bcc10c71db7..7d06f03e24445c868d385f6dc83002fbcb542ab2 100644
--- a/src/doomstat.h
+++ b/src/doomstat.h
@@ -327,7 +327,7 @@ typedef struct
// Music stuff.
UINT32 musinterfadeout; ///< Fade out level music on intermission screen in milliseconds
char musintername[7]; ///< Intermission screen music.
-
+
char muspostbossname[7]; ///< Post-bossdeath music.
UINT16 muspostbosstrack; ///< Post-bossdeath track.
UINT32 muspostbosspos; ///< Post-bossdeath position
@@ -433,6 +433,7 @@ typedef struct
tic_t time; ///< Time in which the level was finished.
UINT32 score; ///< Score when the level was finished.
UINT16 rings; ///< Rings when the level was finished.
+ boolean gotperfect; ///< Got perfect bonus?
} recorddata_t;
/** Setup for one NiGHTS map.
diff --git a/src/doomtype.h b/src/doomtype.h
index 7acdde966835b97f6977214e8925729bdbe14108..5f60e21b51cc6aec62c1a3427a897c47d649816d 100644
--- a/src/doomtype.h
+++ b/src/doomtype.h
@@ -326,16 +326,18 @@ size_t strlcpy(char *dst, const char *src, size_t siz);
/* Miscellaneous types that don't fit anywhere else (Can this be changed?) */
+typedef struct
+{
+ UINT8 red;
+ UINT8 green;
+ UINT8 blue;
+ UINT8 alpha;
+} byteColor_t;
+
union FColorRGBA
{
UINT32 rgba;
- struct
- {
- UINT8 red;
- UINT8 green;
- UINT8 blue;
- UINT8 alpha;
- } s;
+ byteColor_t s;
} ATTRPACK;
typedef union FColorRGBA RGBA_t;
diff --git a/src/f_finale.c b/src/f_finale.c
index 97a60004b7d34fc38ef2f0a4e4493bf4c011212f..aa3b96754323c6e3a99b9068a91278e352b0ab5f 100644
--- a/src/f_finale.c
+++ b/src/f_finale.c
@@ -70,16 +70,38 @@ mobj_t *titlemapcameraref = NULL;
// menu presentation state
char curbgname[9];
SINT8 curfadevalue;
-boolean curhidepics;
INT32 curbgcolor;
INT32 curbgxspeed;
INT32 curbgyspeed;
boolean curbghide;
+boolean hidetitlemap; // WARNING: set to false by M_SetupNextMenu and M_ClearMenus
static UINT8 curDemo = 0;
static UINT32 demoDelayLeft;
static UINT32 demoIdleLeft;
+// customizable title screen graphics
+
+ttmode_enum ttmode = TTMODE_OLD;
+UINT8 ttscale = 1; // FRACUNIT / ttscale
+// ttmode user vars
+char ttname[9];
+INT16 ttx = 0;
+INT16 tty = 0;
+INT16 ttloop = -1;
+UINT16 tttics = 1;
+
+boolean curhidepics;
+ttmode_enum curttmode;
+UINT8 curttscale;
+// ttmode user vars
+char curttname[9];
+INT16 curttx;
+INT16 curtty;
+INT16 curttloop;
+UINT16 curtttics;
+
+// ttmode old
static patch_t *ttbanner; // white banner with "robo blast" and "2"
static patch_t *ttwing; // wing background
static patch_t *ttsonic; // "SONIC"
@@ -96,6 +118,78 @@ static patch_t *ttspop5;
static patch_t *ttspop6;
static patch_t *ttspop7;
+// ttmode alacroix
+static SINT8 testttscale = 0;
+static SINT8 activettscale = 0;
+boolean ttavailable[6];
+boolean ttloaded[6];
+
+static patch_t *ttribb[6][TTMAX_ALACROIX];
+static patch_t *ttsont[6][TTMAX_ALACROIX];
+static patch_t *ttrobo[6][TTMAX_ALACROIX];
+static patch_t *tttwot[6][TTMAX_ALACROIX];
+static patch_t *ttembl[6][TTMAX_ALACROIX];
+static patch_t *ttrbtx[6][TTMAX_ALACROIX];
+static patch_t *ttsoib[6][TTMAX_ALACROIX];
+static patch_t *ttsoif[6][TTMAX_ALACROIX];
+static patch_t *ttsoba[6][TTMAX_ALACROIX];
+static patch_t *ttsobk[6][TTMAX_ALACROIX];
+static patch_t *ttsodh[6][TTMAX_ALACROIX];
+static patch_t *tttaib[6][TTMAX_ALACROIX];
+static patch_t *tttaif[6][TTMAX_ALACROIX];
+static patch_t *tttaba[6][TTMAX_ALACROIX];
+static patch_t *tttabk[6][TTMAX_ALACROIX];
+static patch_t *tttabt[6][TTMAX_ALACROIX];
+static patch_t *tttaft[6][TTMAX_ALACROIX];
+static patch_t *ttknib[6][TTMAX_ALACROIX];
+static patch_t *ttknif[6][TTMAX_ALACROIX];
+static patch_t *ttknba[6][TTMAX_ALACROIX];
+static patch_t *ttknbk[6][TTMAX_ALACROIX];
+static patch_t *ttkndh[6][TTMAX_ALACROIX];
+
+#define TTEMBL (ttembl[activettscale-1])
+#define TTRIBB (ttribb[activettscale-1])
+#define TTSONT (ttsont[activettscale-1])
+#define TTROBO (ttrobo[activettscale-1])
+#define TTTWOT (tttwot[activettscale-1])
+#define TTRBTX (ttrbtx[activettscale-1])
+#define TTSOIB (ttsoib[activettscale-1])
+#define TTSOIF (ttsoif[activettscale-1])
+#define TTSOBA (ttsoba[activettscale-1])
+#define TTSOBK (ttsobk[activettscale-1])
+#define TTSODH (ttsodh[activettscale-1])
+#define TTTAIB (tttaib[activettscale-1])
+#define TTTAIF (tttaif[activettscale-1])
+#define TTTABA (tttaba[activettscale-1])
+#define TTTABK (tttabk[activettscale-1])
+#define TTTABT (tttabt[activettscale-1])
+#define TTTAFT (tttaft[activettscale-1])
+#define TTKNIB (ttknib[activettscale-1])
+#define TTKNIF (ttknif[activettscale-1])
+#define TTKNBA (ttknba[activettscale-1])
+#define TTKNBK (ttknbk[activettscale-1])
+#define TTKNDH (ttkndh[activettscale-1])
+
+static boolean sonic_blink = false;
+static boolean sonic_blink_twice = false;
+static boolean sonic_blinked_already = false;
+static INT32 sonic_idle_start = 0;
+static INT32 sonic_idle_end = 0;
+static boolean tails_blink = false;
+static boolean tails_blink_twice = false;
+static boolean tails_blinked_already = false;
+static INT32 tails_idle_start = 0;
+static INT32 tails_idle_end = 0;
+static boolean knux_blink = false;
+static boolean knux_blink_twice = false;
+static boolean knux_blinked_already = false;
+static INT32 knux_idle_start = 0;
+static INT32 knux_idle_end = 0;
+
+// ttmode user
+static patch_t *ttuser[TTMAX_USER];
+static INT32 ttuser_count = 0;
+
static boolean goodending;
static patch_t *endbrdr[2]; // border - blue, white, pink - where have i seen those colours before?
static patch_t *endbgsp[3]; // nebula, sun, planet
@@ -637,6 +731,7 @@ static void F_IntroDrawScene(void)
}
else
{
+ menuanimtimer = animtimer; // Reusing this variable for the intro to fix the scrolling sky, better than changing the function around.
F_SkyScroll(80*4, 0, "TITLESKY");
if (timetonext == 6)
{
@@ -834,7 +929,7 @@ void F_IntroDrawer(void)
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
V_DrawScaledPatch(0, 0, 0, radar);
W_UnlockCachedPatch(radar);
- V_DrawString(8, 128, 0, cutscene_disptext);
+ V_DrawString(8, 128, V_ALLOWLOWERCASE, cutscene_disptext);
F_WipeEndScreen();
F_RunWipe(99,true);
@@ -847,7 +942,7 @@ void F_IntroDrawer(void)
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
V_DrawScaledPatch(0, 0, 0, grass);
W_UnlockCachedPatch(grass);
- V_DrawString(8, 128, 0, cutscene_disptext);
+ V_DrawString(8, 128, V_ALLOWLOWERCASE, cutscene_disptext);
F_WipeEndScreen();
F_RunWipe(99,true);
@@ -860,7 +955,7 @@ void F_IntroDrawer(void)
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
V_DrawSmallScaledPatch(0, 0, 0, confront);
W_UnlockCachedPatch(confront);
- V_DrawString(8, 128, 0, cutscene_disptext);
+ V_DrawString(8, 128, V_ALLOWLOWERCASE, cutscene_disptext);
F_WipeEndScreen();
F_RunWipe(99,true);
@@ -873,7 +968,7 @@ void F_IntroDrawer(void)
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
V_DrawSmallScaledPatch(0, 0, 0, sdo);
W_UnlockCachedPatch(sdo);
- V_DrawString(224, 8, 0, cutscene_disptext);
+ V_DrawString(224, 8, V_ALLOWLOWERCASE, cutscene_disptext);
F_WipeEndScreen();
F_RunWipe(99,true);
@@ -1563,15 +1658,15 @@ static void F_CacheEnding(void)
UINT8 skinnum = players[consoleplayer].skin;
spritedef_t *sprdef;
spriteframe_t *sprframe;
- if (skins[skinnum].sprites[SPR2_XTRA].numframes >= 7)
+ if (skins[skinnum].sprites[SPR2_XTRA].numframes >= (XTRA_ENDING+2)+1)
{
sprdef = &skins[skinnum].sprites[SPR2_XTRA];
// character head, skin specific
- sprframe = &sprdef->spriteframes[4];
+ sprframe = &sprdef->spriteframes[XTRA_ENDING];
endfwrk[0] = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
- sprframe = &sprdef->spriteframes[5];
+ sprframe = &sprdef->spriteframes[XTRA_ENDING+1];
endfwrk[1] = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
- sprframe = &sprdef->spriteframes[6];
+ sprframe = &sprdef->spriteframes[XTRA_ENDING+2];
endfwrk[2] = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
}
else // Show a star if your character doesn't have an ending firework display. (Basically the MISSINGs for this)
@@ -2110,16 +2205,24 @@ void F_InitMenuPresValues(void)
// Set defaults for presentation values
strncpy(curbgname, "TITLESKY", 9);
curfadevalue = 16;
- curhidepics = hidetitlepics;
curbgcolor = -1;
- curbgxspeed = titlescrollxspeed;
- curbgyspeed = titlescrollyspeed;
- curbghide = true;
+ curbgxspeed = (gamestate == GS_TIMEATTACK) ? 0 : titlescrollxspeed;
+ curbgyspeed = (gamestate == GS_TIMEATTACK) ? 22 : titlescrollyspeed;
+ curbghide = (gamestate == GS_TIMEATTACK) ? false : true;
+
+ curhidepics = hidetitlepics;
+ curttmode = ttmode;
+ curttscale = ttscale;
+ strncpy(curttname, ttname, 9);
+ curttx = ttx;
+ curtty = tty;
+ curttloop = ttloop;
+ curtttics = tttics;
// Find current presentation values
- M_SetMenuCurBackground((gamestate == GS_TIMEATTACK) ? "SRB2BACK" : "TITLESKY");
+ M_SetMenuCurBackground((gamestate == GS_TIMEATTACK) ? "RECATTBG" : "TITLESKY");
M_SetMenuCurFadeValue(16);
- M_SetMenuCurHideTitlePics();
+ M_SetMenuCurTitlePics();
}
//
@@ -2186,23 +2289,69 @@ void F_SkyScroll(INT32 scrollxspeed, INT32 scrollyspeed, const char *patchname)
W_UnlockCachedPatch(pat);
}
+#define LOADTTGFX(arr, name, maxf) \
+lumpnum = W_CheckNumForName(name); \
+if (lumpnum != LUMPERROR) \
+{ \
+ arr[0] = W_CachePatchName(name, PU_LEVEL); \
+ arr[min(1, maxf-1)] = 0; \
+} \
+else if (strlen(name) <= 6) \
+{ \
+ fixed_t cnt = strlen(name); \
+ strncpy(lumpname, name, 7); \
+ for (i = 0; i < maxf-1; i++) \
+ { \
+ sprintf(&lumpname[cnt], "%.2hu", (UINT16)(i+1)); \
+ lumpname[8] = 0; \
+ lumpnum = W_CheckNumForName(lumpname); \
+ if (lumpnum != LUMPERROR) \
+ arr[i] = W_CachePatchName(lumpname, PU_LEVEL); \
+ else \
+ break; \
+ } \
+ arr[min(i, maxf-1)] = 0; \
+} \
+else \
+ arr[0] = 0;
+
static void F_CacheTitleScreen(void)
{
- ttbanner = W_CachePatchName("TTBANNER", PU_PATCH);
- ttwing = W_CachePatchName("TTWING", PU_PATCH);
- ttsonic = W_CachePatchName("TTSONIC", PU_PATCH);
- ttswave1 = W_CachePatchName("TTSWAVE1", PU_PATCH);
- ttswave2 = W_CachePatchName("TTSWAVE2", PU_PATCH);
- ttswip1 = W_CachePatchName("TTSWIP1", PU_PATCH);
- ttsprep1 = W_CachePatchName("TTSPREP1", PU_PATCH);
- ttsprep2 = W_CachePatchName("TTSPREP2", PU_PATCH);
- ttspop1 = W_CachePatchName("TTSPOP1", PU_PATCH);
- ttspop2 = W_CachePatchName("TTSPOP2", PU_PATCH);
- ttspop3 = W_CachePatchName("TTSPOP3", PU_PATCH);
- ttspop4 = W_CachePatchName("TTSPOP4", PU_PATCH);
- ttspop5 = W_CachePatchName("TTSPOP5", PU_PATCH);
- ttspop6 = W_CachePatchName("TTSPOP6", PU_PATCH);
- ttspop7 = W_CachePatchName("TTSPOP7", PU_PATCH);
+ switch(curttmode)
+ {
+ case TTMODE_OLD:
+ case TTMODE_NONE:
+ ttbanner = W_CachePatchName("TTBANNER", PU_LEVEL);
+ ttwing = W_CachePatchName("TTWING", PU_LEVEL);
+ ttsonic = W_CachePatchName("TTSONIC", PU_LEVEL);
+ ttswave1 = W_CachePatchName("TTSWAVE1", PU_LEVEL);
+ ttswave2 = W_CachePatchName("TTSWAVE2", PU_LEVEL);
+ ttswip1 = W_CachePatchName("TTSWIP1", PU_LEVEL);
+ ttsprep1 = W_CachePatchName("TTSPREP1", PU_LEVEL);
+ ttsprep2 = W_CachePatchName("TTSPREP2", PU_LEVEL);
+ ttspop1 = W_CachePatchName("TTSPOP1", PU_LEVEL);
+ ttspop2 = W_CachePatchName("TTSPOP2", PU_LEVEL);
+ ttspop3 = W_CachePatchName("TTSPOP3", PU_LEVEL);
+ ttspop4 = W_CachePatchName("TTSPOP4", PU_LEVEL);
+ ttspop5 = W_CachePatchName("TTSPOP5", PU_LEVEL);
+ ttspop6 = W_CachePatchName("TTSPOP6", PU_LEVEL);
+ ttspop7 = W_CachePatchName("TTSPOP7", PU_LEVEL);
+ break;
+
+ // don't load alacroix gfx yet; we do that upon first draw.
+ case TTMODE_ALACROIX:
+ break;
+
+ case TTMODE_USER:
+ {
+ UINT16 i;
+ lumpnum_t lumpnum;
+ char lumpname[9];
+
+ LOADTTGFX(ttuser, curttname, TTMAX_USER)
+ break;
+ }
+ }
}
void F_StartTitleScreen(void)
@@ -2214,7 +2363,19 @@ void F_StartTitleScreen(void)
if (gamestate != GS_TITLESCREEN && gamestate != GS_WAITINGPLAYERS)
{
- finalecount = 0;
+ ttuser_count =\
+ ttloaded[0] = ttloaded[1] = ttloaded[2] = ttloaded[3] = ttloaded[4] = ttloaded[5] =\
+ testttscale = activettscale =\
+ sonic_blink = sonic_blink_twice = sonic_idle_start = sonic_idle_end =\
+ tails_blink = tails_blink_twice = tails_idle_start = tails_idle_end =\
+ knux_blink = knux_blink_twice = knux_idle_start = knux_idle_end = 0;
+
+ sonic_blinked_already = tails_blinked_already = knux_blinked_already = 1; // don't blink on the first idle cycle
+
+ if (curttmode == TTMODE_ALACROIX)
+ finalecount = -3; // hack so that frames don't advance during the entry wipe
+ else
+ finalecount = 0;
wipetypepost = menupres[MN_MAIN].enterwipe;
}
else
@@ -2292,10 +2453,146 @@ void F_StartTitleScreen(void)
F_CacheTitleScreen();
}
+static void F_UnloadAlacroixGraphics(SINT8 oldttscale)
+{
+ // This all gets freed by PU_LEVEL when exiting the menus.
+ // When re-visiting the menus (e.g., from exiting in-game), the gfx are force-reloaded.
+ // So leftover addresses here should not be a problem.
+
+ UINT16 i;
+ oldttscale--; // zero-based index
+ for (i = 0; i < TTMAX_ALACROIX; i++)
+ {
+ if(ttembl[oldttscale][i]) { Z_Free(ttembl[oldttscale][i]); ttembl[oldttscale][i] = 0; }
+ if(ttribb[oldttscale][i]) { Z_Free(ttribb[oldttscale][i]); ttribb[oldttscale][i] = 0; }
+ if(ttsont[oldttscale][i]) { Z_Free(ttsont[oldttscale][i]); ttsont[oldttscale][i] = 0; }
+ if(ttrobo[oldttscale][i]) { Z_Free(ttrobo[oldttscale][i]); ttrobo[oldttscale][i] = 0; }
+ if(tttwot[oldttscale][i]) { Z_Free(tttwot[oldttscale][i]); tttwot[oldttscale][i] = 0; }
+ if(ttrbtx[oldttscale][i]) { Z_Free(ttrbtx[oldttscale][i]); ttrbtx[oldttscale][i] = 0; }
+ if(ttsoib[oldttscale][i]) { Z_Free(ttsoib[oldttscale][i]); ttsoib[oldttscale][i] = 0; }
+ if(ttsoif[oldttscale][i]) { Z_Free(ttsoif[oldttscale][i]); ttsoif[oldttscale][i] = 0; }
+ if(ttsoba[oldttscale][i]) { Z_Free(ttsoba[oldttscale][i]); ttsoba[oldttscale][i] = 0; }
+ if(ttsobk[oldttscale][i]) { Z_Free(ttsobk[oldttscale][i]); ttsobk[oldttscale][i] = 0; }
+ if(ttsodh[oldttscale][i]) { Z_Free(ttsodh[oldttscale][i]); ttsodh[oldttscale][i] = 0; }
+ if(tttaib[oldttscale][i]) { Z_Free(tttaib[oldttscale][i]); tttaib[oldttscale][i] = 0; }
+ if(tttaif[oldttscale][i]) { Z_Free(tttaif[oldttscale][i]); tttaif[oldttscale][i] = 0; }
+ if(tttaba[oldttscale][i]) { Z_Free(tttaba[oldttscale][i]); tttaba[oldttscale][i] = 0; }
+ if(tttabk[oldttscale][i]) { Z_Free(tttabk[oldttscale][i]); tttabk[oldttscale][i] = 0; }
+ if(tttabt[oldttscale][i]) { Z_Free(tttabt[oldttscale][i]); tttabt[oldttscale][i] = 0; }
+ if(tttaft[oldttscale][i]) { Z_Free(tttaft[oldttscale][i]); tttaft[oldttscale][i] = 0; }
+ if(ttknib[oldttscale][i]) { Z_Free(ttknib[oldttscale][i]); ttknib[oldttscale][i] = 0; }
+ if(ttknif[oldttscale][i]) { Z_Free(ttknif[oldttscale][i]); ttknif[oldttscale][i] = 0; }
+ if(ttknba[oldttscale][i]) { Z_Free(ttknba[oldttscale][i]); ttknba[oldttscale][i] = 0; }
+ if(ttknbk[oldttscale][i]) { Z_Free(ttknbk[oldttscale][i]); ttknbk[oldttscale][i] = 0; }
+ if(ttkndh[oldttscale][i]) { Z_Free(ttkndh[oldttscale][i]); ttkndh[oldttscale][i] = 0; }
+ }
+ ttloaded[oldttscale] = false;
+}
+
+static void F_LoadAlacroixGraphics(SINT8 newttscale)
+{
+ UINT16 i, j;
+ lumpnum_t lumpnum;
+ char lumpname[9];
+ char names[22][5] = {
+ "EMBL",
+ "RIBB",
+ "SONT",
+ "ROBO",
+ "TWOT",
+ "RBTX",
+ "SOIB",
+ "SOIF",
+ "SOBA",
+ "SOBK",
+ "SODH",
+ "TAIB",
+ "TAIF",
+ "TABA",
+ "TABK",
+ "TABT",
+ "TAFT",
+ "KNIB",
+ "KNIF",
+ "KNBA",
+ "KNBK",
+ "KNDH"
+ };
+ char lumpnames[22][7];
+
+ newttscale--; // 0-based index
+
+ if (!ttloaded[newttscale])
+ {
+ for (j = 0; j < 22; j++)
+ sprintf(&lumpnames[j][0], "T%.1hu%s", (UINT8)newttscale+1, names[j]);
+
+ LOADTTGFX(ttembl[newttscale], lumpnames[0], TTMAX_ALACROIX)
+ LOADTTGFX(ttribb[newttscale], lumpnames[1], TTMAX_ALACROIX)
+ LOADTTGFX(ttsont[newttscale], lumpnames[2], TTMAX_ALACROIX)
+ LOADTTGFX(ttrobo[newttscale], lumpnames[3], TTMAX_ALACROIX)
+ LOADTTGFX(tttwot[newttscale], lumpnames[4], TTMAX_ALACROIX)
+ LOADTTGFX(ttrbtx[newttscale], lumpnames[5], TTMAX_ALACROIX)
+ LOADTTGFX(ttsoib[newttscale], lumpnames[6], TTMAX_ALACROIX)
+ LOADTTGFX(ttsoif[newttscale], lumpnames[7], TTMAX_ALACROIX)
+ LOADTTGFX(ttsoba[newttscale], lumpnames[8], TTMAX_ALACROIX)
+ LOADTTGFX(ttsobk[newttscale], lumpnames[9], TTMAX_ALACROIX)
+ LOADTTGFX(ttsodh[newttscale], lumpnames[10], TTMAX_ALACROIX)
+ LOADTTGFX(tttaib[newttscale], lumpnames[11], TTMAX_ALACROIX)
+ LOADTTGFX(tttaif[newttscale], lumpnames[12], TTMAX_ALACROIX)
+ LOADTTGFX(tttaba[newttscale], lumpnames[13], TTMAX_ALACROIX)
+ LOADTTGFX(tttabk[newttscale], lumpnames[14], TTMAX_ALACROIX)
+ LOADTTGFX(tttabt[newttscale], lumpnames[15], TTMAX_ALACROIX)
+ LOADTTGFX(tttaft[newttscale], lumpnames[16], TTMAX_ALACROIX)
+ LOADTTGFX(ttknib[newttscale], lumpnames[17], TTMAX_ALACROIX)
+ LOADTTGFX(ttknif[newttscale], lumpnames[18], TTMAX_ALACROIX)
+ LOADTTGFX(ttknba[newttscale], lumpnames[19], TTMAX_ALACROIX)
+ LOADTTGFX(ttknbk[newttscale], lumpnames[20], TTMAX_ALACROIX)
+ LOADTTGFX(ttkndh[newttscale], lumpnames[21], TTMAX_ALACROIX)
+
+ ttloaded[newttscale] = true;
+ }
+}
+
+#undef LOADTTGFX
+
+static void F_FigureActiveTtScale(void)
+{
+ SINT8 newttscale = max(1, min(6, vid.dupx));
+ SINT8 oldttscale = activettscale;
+
+ if (newttscale == testttscale)
+ return;
+ testttscale = newttscale;
+
+ // If ttscale is unavailable: look for lower scales, then higher scales.
+ for (; newttscale >= 1; newttscale--)
+ {
+ if (ttavailable[newttscale-1])
+ break;
+ }
+
+ for (; newttscale <= 6; newttscale++)
+ {
+ if (ttavailable[newttscale-1])
+ break;
+ }
+
+ activettscale = (newttscale >= 1 && newttscale <= 6) ? newttscale : 0;
+
+ // We have a new ttscale, so load gfx
+ if(oldttscale > 0)
+ F_UnloadAlacroixGraphics(oldttscale);
+
+ if(activettscale > 0)
+ F_LoadAlacroixGraphics(activettscale);
+}
+
// (no longer) De-Demo'd Title Screen
void F_TitleScreenDrawer(void)
{
boolean hidepics;
+ fixed_t sc = FRACUNIT / max(1, curttscale);
if (modeattacking)
return; // We likely came here from retrying. Don't do a damn thing.
@@ -2306,11 +2603,13 @@ void F_TitleScreenDrawer(void)
// Draw that sky!
if (curbgcolor >= 0)
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, curbgcolor);
- else if (!curbghide || !titlemapinaction || gamestate == GS_WAITINGPLAYERS)
+ else if (titlemapinaction && curbghide && ! hidetitlemap)
+ D_Render();
+ else
F_SkyScroll(curbgxspeed, curbgyspeed, curbgname);
// Don't draw outside of the title screen, or if the patch isn't there.
- if (!ttwing || (gamestate != GS_TITLESCREEN && gamestate != GS_WAITINGPLAYERS))
+ if (gamestate != GS_TITLESCREEN && gamestate != GS_WAITINGPLAYERS)
return;
// rei|miru: use title pics?
@@ -2322,42 +2621,701 @@ void F_TitleScreenDrawer(void)
return;
#endif
- V_DrawScaledPatch(30, 14, 0, ttwing);
-
- if (finalecount < 57)
- {
- if (finalecount == 35)
- V_DrawScaledPatch(115, 15, 0, ttspop1);
- else if (finalecount == 36)
- V_DrawScaledPatch(114, 15, 0,ttspop2);
- else if (finalecount == 37)
- V_DrawScaledPatch(113, 15, 0,ttspop3);
- else if (finalecount == 38)
- V_DrawScaledPatch(112, 15, 0,ttspop4);
- else if (finalecount == 39)
- V_DrawScaledPatch(111, 15, 0,ttspop5);
- else if (finalecount == 40)
- V_DrawScaledPatch(110, 15, 0, ttspop6);
- else if (finalecount >= 41 && finalecount <= 44)
- V_DrawScaledPatch(109, 15, 0, ttspop7);
- else if (finalecount >= 45 && finalecount <= 48)
- V_DrawScaledPatch(108, 12, 0, ttsprep1);
- else if (finalecount >= 49 && finalecount <= 52)
- V_DrawScaledPatch(107, 9, 0, ttsprep2);
- else if (finalecount >= 53 && finalecount <= 56)
- V_DrawScaledPatch(106, 6, 0, ttswip1);
- V_DrawScaledPatch(93, 106, 0, ttsonic);
- }
- else
+ switch(curttmode)
{
- V_DrawScaledPatch(93, 106, 0,ttsonic);
- if (finalecount/5 & 1)
- V_DrawScaledPatch(100, 3, 0,ttswave1);
- else
- V_DrawScaledPatch(100,3, 0,ttswave2);
- }
+ case TTMODE_OLD:
+ case TTMODE_NONE:
+ V_DrawSciencePatch(30<<FRACBITS, 14<<FRACBITS, 0, ttwing, sc);
+
+ if (finalecount < 57)
+ {
+ if (finalecount == 35)
+ V_DrawSciencePatch(115<<FRACBITS, 15<<FRACBITS, 0, ttspop1, sc);
+ else if (finalecount == 36)
+ V_DrawSciencePatch(114<<FRACBITS, 15<<FRACBITS, 0,ttspop2, sc);
+ else if (finalecount == 37)
+ V_DrawSciencePatch(113<<FRACBITS, 15<<FRACBITS, 0,ttspop3, sc);
+ else if (finalecount == 38)
+ V_DrawSciencePatch(112<<FRACBITS, 15<<FRACBITS, 0,ttspop4, sc);
+ else if (finalecount == 39)
+ V_DrawSciencePatch(111<<FRACBITS, 15<<FRACBITS, 0,ttspop5, sc);
+ else if (finalecount == 40)
+ V_DrawSciencePatch(110<<FRACBITS, 15<<FRACBITS, 0, ttspop6, sc);
+ else if (finalecount >= 41 && finalecount <= 44)
+ V_DrawSciencePatch(109<<FRACBITS, 15<<FRACBITS, 0, ttspop7, sc);
+ else if (finalecount >= 45 && finalecount <= 48)
+ V_DrawSciencePatch(108<<FRACBITS, 12<<FRACBITS, 0, ttsprep1, sc);
+ else if (finalecount >= 49 && finalecount <= 52)
+ V_DrawSciencePatch(107<<FRACBITS, 9<<FRACBITS, 0, ttsprep2, sc);
+ else if (finalecount >= 53 && finalecount <= 56)
+ V_DrawSciencePatch(106<<FRACBITS, 6<<FRACBITS, 0, ttswip1, sc);
+ V_DrawSciencePatch(93<<FRACBITS, 106<<FRACBITS, 0, ttsonic, sc);
+ }
+ else
+ {
+ V_DrawSciencePatch(93<<FRACBITS, 106<<FRACBITS, 0,ttsonic, sc);
+ if (finalecount/5 & 1)
+ V_DrawSciencePatch(100<<FRACBITS, 3<<FRACBITS, 0,ttswave1, sc);
+ else
+ V_DrawSciencePatch(100<<FRACBITS, 3<<FRACBITS, 0,ttswave2, sc);
+ }
+
+ V_DrawSciencePatch(48<<FRACBITS, 142<<FRACBITS, 0,ttbanner, sc);
+ break;
+
+ case TTMODE_ALACROIX:
+ //
+ // PRE-INTRO: WING ON BLACK BACKGROUND
+ //
+
+ // Figure the gfx scale and load gfx if necessary
+ F_FigureActiveTtScale();
+
+ if (!activettscale) // invalid scale, draw nothing
+ break;
+ sc = FRACUNIT / activettscale;
+
+ // Start at black background. Draw it until tic 30, where we replace with a white flash.
+ //
+ // TODO: How to NOT draw the titlemap while this background is drawn?
+ //
+ if (finalecount <= 29)
+ V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
+
+ // Draw emblem
+ V_DrawSciencePatch(40<<FRACBITS, 20<<FRACBITS, 0, TTEMBL[0], sc);
+
+ // Animate SONIC ROBO BLAST 2 before the white flash at tic 30.
+ if (finalecount <= 29)
+ {
+ // Ribbon unfurls, revealing SONIC text, from tic 0 to tic 24. SONIC text is pre-baked into this ribbon graphic.
+ V_DrawSciencePatch(39<<FRACBITS, 88<<FRACBITS, 0, TTRIBB[min(max(0, finalecount), 24)], sc);
+
+ // Animate SONIC text while the ribbon unfurls, from tic 0 to tic 28.
+ if(finalecount >= 0)
+ V_DrawSciencePatch(89<<FRACBITS, 92<<FRACBITS, 0, TTSONT[min(finalecount, 28)], sc);
+
+ // Fade in ROBO BLAST 2 starting at tic 10.
+ if (finalecount > 9)
+ {
+ INT32 fadeval = 0;
+
+ // Fade between tic 10 and tic 29.
+ if (finalecount < 30)
+ {
+ UINT8 fadecounter = 30-finalecount;
+ switch(fadecounter)
+ {
+ case 20: case 19: fadeval = V_90TRANS; break;
+ case 18: case 17: fadeval = V_80TRANS; break;
+ case 16: case 15: fadeval = V_70TRANS; break;
+ case 14: case 13: fadeval = V_60TRANS; break;
+ case 12: case 11: fadeval = V_TRANSLUCENT; break;
+ case 10: case 9: fadeval = V_40TRANS; break;
+ case 8: case 7: fadeval = V_30TRANS; break;
+ case 6: case 5: fadeval = V_20TRANS; break;
+ case 4: case 3: fadeval = V_10TRANS; break;
+ }
+ }
+ V_DrawSciencePatch(79<<FRACBITS, 132<<FRACBITS, fadeval, TTROBO[0], sc);
+
+ // Draw the TWO from tic 16 to tic 31, so the TWO lands right when the screen flashes white.
+ if(finalecount > 15)
+ V_DrawSciencePatch(106<<FRACBITS, 118<<FRACBITS, fadeval, TTTWOT[min(finalecount-16, 15)], sc);
+ }
+ }
+
+ //
+ // ALACROIX CHARACTER FRAMES
+ //
+ // Start all animation from tic 34 (or whenever the white flash begins to fade; see below.)
+ // Delay the start a bit for better music timing.
+ //
+
+#define CHARSTART 41
+#define SONICSTART (CHARSTART+0)
+#define SONICIDLE (SONICSTART+57)
+#define SONICX 89
+#define SONICY 13
+#define TAILSSTART (CHARSTART+27)
+#define TAILSIDLE (TAILSSTART+60)
+#define TAILSX 35
+#define TAILSY 19
+#define KNUXSTART (CHARSTART+44)
+#define KNUXIDLE (KNUXSTART+70)
+#define KNUXX 167
+#define KNUXY 7
+
+ // Decide who gets to blink or not.
+ // Make this decision at the END of an idle/blink cycle.
+ // Upon first idle, both idle_start and idle_end will be 0.
+
+ if (finalecount >= KNUXIDLE)
+ {
+ if (!knux_idle_start || finalecount - knux_idle_start >= knux_idle_end)
+ {
+ if (knux_blink)
+ {
+ knux_blink = false; // don't run the cycle twice in a row
+ knux_blinked_already = true;
+ }
+ else if (knux_blinked_already) // or after the first non-blink cycle, either.
+ knux_blinked_already = false;
+ else
+ {
+ // make this chance higher than Sonic/Tails because Knux's idle cycle is longer
+ knux_blink = !(M_RandomKey(100) % 2);
+ knux_blink_twice = knux_blink ? !(M_RandomKey(100) % 5) : false;
+ }
+ knux_idle_start = finalecount;
+ }
+
+ knux_idle_end = knux_blink ? (knux_blink_twice ? 17 : 7) : 46;
+ }
+
+ if (finalecount >= TAILSIDLE)
+ {
+ if (!tails_idle_start || finalecount - tails_idle_start >= tails_idle_end)
+ {
+ if (tails_blink)
+ {
+ tails_blink = false; // don't run the cycle twice in a row
+ tails_blinked_already = true;
+ }
+ else if (tails_blinked_already) // or after the first non-blink cycle, either.
+ tails_blinked_already = false;
+ else
+ {
+ tails_blink = !(M_RandomKey(100) % 3);
+ tails_blink_twice = tails_blink ? !(M_RandomKey(100) % 5) : false;
+ }
+ tails_idle_start = finalecount;
+ }
+
+ // Tails does not actually have a non-blink idle cycle, but make up a number
+ // so he can still blink.
+ tails_idle_end = tails_blink ? (tails_blink_twice ? 17 : 7) : 30;
+ }
+
+ if (finalecount >= SONICIDLE)
+ {
+ if (!sonic_idle_start || finalecount - sonic_idle_start >= sonic_idle_end)
+ {
+ if (sonic_blink)
+ {
+ sonic_blink = false; // don't run the cycle twice in a row
+ sonic_blinked_already = true;
+ }
+ else if (sonic_blinked_already) // or after the first non-blink cycle, either.
+ sonic_blinked_already = false;
+ else
+ {
+ sonic_blink = !(M_RandomKey(100) % 3);
+ sonic_blink_twice = sonic_blink ? !(M_RandomKey(100) % 5) : false;
+ }
+ sonic_idle_start = finalecount;
+ }
+
+ sonic_idle_end = sonic_blink ? (sonic_blink_twice ? 17 : 7) : 25;
+ }
+
+
+ //
+ // BACK TAIL LAYER
+ //
+
+ if (finalecount >= TAILSSTART)
+ {
+ if (finalecount >= TAILSIDLE)
+ {
+ //
+ // Tails Back Tail Layer Idle
+ //
+ SINT8 taftcount = (finalecount - (TAILSIDLE)) % 41;
+ if (taftcount >= 0 && taftcount < 5 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABT[0 ], sc);
+ else if (taftcount >= 5 && taftcount < 9 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABT[1 ], sc);
+ else if (taftcount >= 9 && taftcount < 12 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABT[2 ], sc);
+ else if (taftcount >= 12 && taftcount < 14 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABT[3 ], sc);
+ else if (taftcount >= 14 && taftcount < 17 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABT[4 ], sc);
+ else if (taftcount >= 17 && taftcount < 21 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABT[5 ], sc);
+ else if (taftcount >= 21 && taftcount < 24 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABT[6 ], sc);
+ else if (taftcount >= 24 && taftcount < 25 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABT[7 ], sc);
+ else if (taftcount >= 25 && taftcount < 28 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABT[8 ], sc);
+ else if (taftcount >= 28 && taftcount < 31 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABT[9 ], sc);
+ else if (taftcount >= 31 && taftcount < 35 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABT[10], sc);
+ else if (taftcount >= 35 && taftcount < 41 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABT[11], sc);
+ }
+ }
+
+ //
+ // FRONT TAIL LAYER
+ //
+
+ if (finalecount >= TAILSSTART)
+ {
+ if (finalecount >= TAILSIDLE)
+ {
+ //
+ // Tails Front Tail Layer Idle
+ //
+ SINT8 tabtcount = (finalecount - (TAILSIDLE)) % 41;
+ if (tabtcount >= 0 && tabtcount < 6 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAFT[0 ], sc);
+ else if (tabtcount >= 6 && tabtcount < 11 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAFT[1 ], sc);
+ else if (tabtcount >= 11 && tabtcount < 15 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAFT[2 ], sc);
+ else if (tabtcount >= 15 && tabtcount < 18 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAFT[3 ], sc);
+ else if (tabtcount >= 18 && tabtcount < 19 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAFT[4 ], sc);
+ else if (tabtcount >= 19 && tabtcount < 22 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAFT[5 ], sc);
+ else if (tabtcount >= 22 && tabtcount < 27 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAFT[6 ], sc);
+ else if (tabtcount >= 27 && tabtcount < 30 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAFT[7 ], sc);
+ else if (tabtcount >= 30 && tabtcount < 31 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAFT[8 ], sc);
+ else if (tabtcount >= 31 && tabtcount < 34 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAFT[9 ], sc);
+ else if (tabtcount >= 34 && tabtcount < 37 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAFT[10], sc);
+ else if (tabtcount >= 37 && tabtcount < 41 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAFT[11], sc);
+ }
+ }
+
+ //
+ // BACK LAYER CHARACTERS
+ //
+
+ if (finalecount >= KNUXSTART)
+ {
+ if (finalecount < KNUXIDLE)
+ {
+ //
+ // Knux Back Layer Intro
+ //
+ if (finalecount >= KNUXSTART+0 && finalecount < KNUXSTART+6 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[0 ], sc);
+ else if (finalecount >= KNUXSTART+6 && finalecount < KNUXSTART+10 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[1 ], sc);
+ else if (finalecount >= KNUXSTART+10 && finalecount < KNUXSTART+13 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[2 ], sc);
+ else if (finalecount >= KNUXSTART+13 && finalecount < KNUXSTART+15 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[3 ], sc);
+ else if (finalecount >= KNUXSTART+15 && finalecount < KNUXSTART+18 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[4 ], sc);
+ else if (finalecount >= KNUXSTART+18 && finalecount < KNUXSTART+22 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[5 ], sc);
+ else if (finalecount >= KNUXSTART+22 && finalecount < KNUXSTART+28 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[6 ], sc);
+ else if (finalecount >= KNUXSTART+28 && finalecount < KNUXSTART+32 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[7 ], sc);
+ else if (finalecount >= KNUXSTART+32 && finalecount < KNUXSTART+35 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[8 ], sc);
+ else if (finalecount >= KNUXSTART+35 && finalecount < KNUXSTART+40 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[9 ], sc);
+ else if (finalecount >= KNUXSTART+40 && finalecount < KNUXSTART+41 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[10], sc);
+ else if (finalecount >= KNUXSTART+41 && finalecount < KNUXSTART+44 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[11], sc);
+ else if (finalecount >= KNUXSTART+44 && finalecount < KNUXSTART+50 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[12], sc);
+ else if (finalecount >= KNUXSTART+50 && finalecount < KNUXSTART+56 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[13], sc);
+ else if (finalecount >= KNUXSTART+56 && finalecount < KNUXSTART+57 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[14], sc);
+ else if (finalecount >= KNUXSTART+57 && finalecount < KNUXSTART+60 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[15], sc);
+ else if (finalecount >= KNUXSTART+60 && finalecount < KNUXSTART+63 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[16], sc);
+ else if (finalecount >= KNUXSTART+63 && finalecount < KNUXSTART+67 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[17], sc);
+ else if (finalecount >= KNUXSTART+67 && finalecount < KNUXSTART+70 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIB[18], sc);
+ // Start idle animation (frame K20-B)
+ }
+ else
+ {
+ //
+ // Knux Back Layer Idle
+ //
+ if (!knux_blink)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNBA[0], sc);
+ else
+ {
+ //
+ // Knux Blinking
+ //
+ SINT8 idlecount = finalecount - knux_idle_start;
+ if (idlecount >= 0 && idlecount < 2 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNBK[0], sc);
+ else if (idlecount >= 2 && idlecount < 6 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNBK[1], sc);
+ else if (idlecount >= 6 && idlecount < 7 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNBK[2], sc);
+ // We reach this point if knux_blink_twice == true
+ else if (idlecount >= 7 && idlecount < 10)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNBA[0], sc);
+ else if (idlecount >= 10 && idlecount < 12)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNBK[0], sc);
+ else if (idlecount >= 12 && idlecount < 16)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNBK[1], sc);
+ else if (idlecount >= 16 && idlecount < 17)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNBK[2], sc);
+ }
+ }
+ }
- V_DrawScaledPatch(48, 142, 0,ttbanner);
+ if (finalecount >= TAILSSTART)
+ {
+ if (finalecount < TAILSIDLE)
+ {
+ //
+ // Tails Back Layer Intro
+ //
+ if (finalecount >= TAILSSTART+0 && finalecount < TAILSSTART+6 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[0 ], sc);
+ else if (finalecount >= TAILSSTART+6 && finalecount < TAILSSTART+10 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[1 ], sc);
+ else if (finalecount >= TAILSSTART+10 && finalecount < TAILSSTART+12 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[2 ], sc);
+ else if (finalecount >= TAILSSTART+12 && finalecount < TAILSSTART+16 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[3 ], sc);
+ else if (finalecount >= TAILSSTART+16 && finalecount < TAILSSTART+22 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[4 ], sc);
+ else if (finalecount >= TAILSSTART+22 && finalecount < TAILSSTART+23 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[5 ], sc);
+ else if (finalecount >= TAILSSTART+23 && finalecount < TAILSSTART+26 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[6 ], sc);
+ else if (finalecount >= TAILSSTART+26 && finalecount < TAILSSTART+30 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[7 ], sc);
+ else if (finalecount >= TAILSSTART+30 && finalecount < TAILSSTART+35 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[8 ], sc);
+ else if (finalecount >= TAILSSTART+35 && finalecount < TAILSSTART+41 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[9 ], sc);
+ else if (finalecount >= TAILSSTART+41 && finalecount < TAILSSTART+43 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[10], sc);
+ else if (finalecount >= TAILSSTART+43 && finalecount < TAILSSTART+47 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[11], sc);
+ else if (finalecount >= TAILSSTART+47 && finalecount < TAILSSTART+51 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[12], sc);
+ else if (finalecount >= TAILSSTART+51 && finalecount < TAILSSTART+53 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[13], sc);
+ else if (finalecount >= TAILSSTART+53 && finalecount < TAILSSTART+56 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[14], sc);
+ else if (finalecount >= TAILSSTART+56 && finalecount < TAILSSTART+60 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIB[15], sc);
+ // Start idle animation (frame T17-B)
+ }
+ else
+ {
+ //
+ // Tails Back Layer Idle
+ //
+ if (!tails_blink)
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABA[0], sc);
+ else
+ {
+ //
+ // Tails Blinking
+ //
+ SINT8 idlecount = finalecount - tails_idle_start;
+ if (idlecount >= +0 && idlecount < +2 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABK[0], sc);
+ else if (idlecount >= +2 && idlecount < +6 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABK[1], sc);
+ else if (idlecount >= +6 && idlecount < +7 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABK[2], sc);
+ // We reach this point if tails_blink_twice == true
+ else if (idlecount >= +7 && idlecount < +10)
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABA[0], sc);
+ else if (idlecount >= +10 && idlecount < +12)
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABK[0], sc);
+ else if (idlecount >= +12 && idlecount < +16)
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABK[1], sc);
+ else if (idlecount >= +16 && idlecount < +17)
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTABK[2], sc);
+ }
+ }
+ }
+
+ if (finalecount >= SONICSTART)
+ {
+ if (finalecount < SONICIDLE)
+ {
+ //
+ // Sonic Back Layer Intro
+ //
+ if (finalecount >= SONICSTART+0 && finalecount < SONICSTART+6 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[0 ], sc);
+ else if (finalecount >= SONICSTART+6 && finalecount < SONICSTART+11 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[1 ], sc);
+ else if (finalecount >= SONICSTART+11 && finalecount < SONICSTART+14 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[2 ], sc);
+ else if (finalecount >= SONICSTART+14 && finalecount < SONICSTART+18 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[3 ], sc);
+ else if (finalecount >= SONICSTART+18 && finalecount < SONICSTART+19 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[4 ], sc);
+ else if (finalecount >= SONICSTART+19 && finalecount < SONICSTART+27 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[5 ], sc);
+ else if (finalecount >= SONICSTART+27 && finalecount < SONICSTART+31 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[6 ], sc);
+ //else if (finalecount >= SONICSTART+31 && finalecount < SONICSTART+33 )
+ // Frame is blank
+ // V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[7 ], sc);
+ else if (finalecount >= SONICSTART+33 && finalecount < SONICSTART+36 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[8 ], sc);
+ else if (finalecount >= SONICSTART+36 && finalecount < SONICSTART+40 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[9 ], sc);
+ else if (finalecount >= SONICSTART+40 && finalecount < SONICSTART+44 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[10], sc);
+ else if (finalecount >= SONICSTART+44 && finalecount < SONICSTART+47 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[11], sc);
+ else if (finalecount >= SONICSTART+47 && finalecount < SONICSTART+49 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[12], sc);
+ else if (finalecount >= SONICSTART+49 && finalecount < SONICSTART+50 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[13], sc);
+ else if (finalecount >= SONICSTART+50 && finalecount < SONICSTART+53 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[14], sc);
+ else if (finalecount >= SONICSTART+53 && finalecount < SONICSTART+57 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIB[15], sc);
+ // Start idle animation (frame S17-B)
+ }
+ else
+ {
+ //
+ // Sonic Back Layer Idle
+ //
+ if (!sonic_blink)
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOBA[0], sc);
+ else
+ {
+ //
+ // Sonic Blinking
+ //
+ SINT8 idlecount = finalecount - sonic_idle_start;
+ if (idlecount >= 0 && idlecount < 2 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOBK[0], sc);
+ else if (idlecount >= 2 && idlecount < 6 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOBK[1], sc);
+ else if (idlecount >= 6 && idlecount < 7 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOBK[2], sc);
+ // We reach this point if sonic_blink_twice == true
+ else if (idlecount >= 7 && idlecount < 10)
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOBA[0], sc);
+ else if (idlecount >= 10 && idlecount < 12)
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOBK[0], sc);
+ else if (idlecount >= 12 && idlecount < 16)
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOBK[1], sc);
+ else if (idlecount >= 16 && idlecount < 17)
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOBK[2], sc);
+ }
+ }
+ }
+
+ //
+ // LOGO LAYER
+ //
+
+ // After tic 34, starting when the flash fades,
+ // draw the combined ribbon and SONIC ROBO BLAST 2 logo. Note the different Y value, because this
+ // graphic is cropped differently from the unfurling ribbon.
+ if (finalecount > 34)
+ V_DrawSciencePatch(39<<FRACBITS, 93<<FRACBITS, 0, TTRBTX[0], sc);
+
+ //
+ // FRONT LAYER CHARACTERS
+ //
+
+ if (finalecount >= KNUXSTART)
+ {
+ if (finalecount < KNUXIDLE)
+ {
+ //
+ // Knux Front Layer Intro
+ //
+ if (finalecount >= KNUXSTART+22 && finalecount < KNUXSTART+28 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIF[6 ], sc);
+ else if (finalecount >= KNUXSTART+28 && finalecount < KNUXSTART+32 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIF[7 ], sc);
+ else if (finalecount >= KNUXSTART+32 && finalecount < KNUXSTART+35 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNIF[8 ], sc);
+ }
+ else
+ {
+ //
+ // Knux Front Layer Idle
+ //
+ if (!knux_blink)
+ {
+ SINT8 idlecount = finalecount - knux_idle_start;
+ if (idlecount >= 0 && idlecount < 5 )
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNDH[0 ], sc);
+ else if (idlecount >= 5 && idlecount < 10)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNDH[1 ], sc);
+ else if (idlecount >= 10 && idlecount < 13)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNDH[2 ], sc);
+ else if (idlecount >= 13 && idlecount < 14)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNDH[3 ], sc);
+ else if (idlecount >= 14 && idlecount < 17)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNDH[4 ], sc);
+ else if (idlecount >= 17 && idlecount < 21)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNDH[5 ], sc);
+ else if (idlecount >= 21 && idlecount < 27)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNDH[6 ], sc);
+ else if (idlecount >= 27 && idlecount < 32)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNDH[7 ], sc);
+ else if (idlecount >= 32 && idlecount < 34)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNDH[8 ], sc);
+ else if (idlecount >= 34 && idlecount < 37)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNDH[9 ], sc);
+ else if (idlecount >= 37 && idlecount < 39)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNDH[10], sc);
+ else if (idlecount >= 39 && idlecount < 42)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNDH[11], sc);
+ else if (idlecount >= 42 && idlecount < 46)
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNDH[12], sc);
+ }
+ else
+ V_DrawSciencePatch(KNUXX<<FRACBITS, KNUXY<<FRACBITS, 0, TTKNDH[0 ], sc);
+ }
+ }
+
+ if (finalecount >= TAILSSTART)
+ {
+ if (finalecount < TAILSIDLE)
+ {
+ //
+ // Tails Front Layer Intro
+ //
+ if (finalecount >= TAILSSTART+26 && finalecount < TAILSSTART+30 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIF[7 ], sc);
+ else if (finalecount >= TAILSSTART+30 && finalecount < TAILSSTART+35 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIF[8 ], sc);
+ else if (finalecount >= TAILSSTART+35 && finalecount < TAILSSTART+41 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIF[9 ], sc);
+ else if (finalecount >= TAILSSTART+41 && finalecount < TAILSSTART+43 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIF[10], sc);
+ else if (finalecount >= TAILSSTART+43 && finalecount < TAILSSTART+47 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIF[11], sc);
+ else if (finalecount >= TAILSSTART+47 && finalecount < TAILSSTART+51 )
+ V_DrawSciencePatch(TAILSX<<FRACBITS, TAILSY<<FRACBITS, 0, TTTAIF[12], sc);
+ }
+ // No Tails Front Layer Idle
+ }
+
+ if (finalecount >= SONICSTART)
+ {
+ if (finalecount < SONICIDLE)
+ {
+ //
+ // Sonic Front Layer Intro
+ //
+ if (finalecount >= SONICSTART+19 && finalecount < SONICSTART+27 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIF[5 ], sc);
+ else if (finalecount >= SONICSTART+27 && finalecount < SONICSTART+31 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIF[6 ], sc);
+ else if (finalecount >= SONICSTART+31 && finalecount < SONICSTART+33 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIF[7 ], sc);
+ else if (finalecount >= SONICSTART+33 && finalecount < SONICSTART+36 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIF[8 ], sc);
+ else if (finalecount >= SONICSTART+36 && finalecount < SONICSTART+40 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIF[9 ], sc);
+ else if (finalecount >= SONICSTART+40 && finalecount < SONICSTART+44 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIF[10], sc);
+ else if (finalecount >= SONICSTART+44 && finalecount < SONICSTART+47 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIF[11], sc);
+ // ...
+ else if (finalecount >= SONICSTART+53 && finalecount < SONICSTART+57 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSOIF[15], sc);
+ }
+ else
+ {
+ //
+ // Sonic Front Layer Idle
+ //
+ if (!sonic_blink)
+ {
+ SINT8 idlecount = finalecount - sonic_idle_start;
+ if (idlecount >= 0 && idlecount < 5 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSODH[0], sc);
+ else if (idlecount >= 5 && idlecount < 8 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSODH[1], sc);
+ else if (idlecount >= 8 && idlecount < 9 )
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSODH[2], sc);
+ else if (idlecount >= 9 && idlecount < 12)
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSODH[3], sc);
+ else if (idlecount >= 12 && idlecount < 17)
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSODH[4], sc);
+ else if (idlecount >= 17 && idlecount < 19)
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSODH[5], sc);
+ else if (idlecount >= 19 && idlecount < 21)
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSODH[6], sc);
+ else if (idlecount >= 21 && idlecount < 22)
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSODH[7], sc);
+ else if (idlecount >= 22 && idlecount < 25)
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSODH[8], sc);
+ }
+ else
+ V_DrawSciencePatch(SONICX<<FRACBITS, SONICY<<FRACBITS, 0, TTSODH[0], sc);
+ }
+ }
+
+ // Flash at tic 30, timed to O__TITLE percussion. Hold the flash until tic 34.
+ // After tic 34, fade the flash until tic 44.
+ if (finalecount > 29 && finalecount < 35)
+ V_DrawFadeScreen(0, 9);
+ else if (finalecount > 34 && 44-finalecount > 0 && 44-finalecount < 10)
+ V_DrawFadeScreen(0, 44-finalecount);
+
+#undef CHARSTART
+#undef SONICSTART
+#undef SONICIDLE
+#undef SONICX
+#undef SONICY
+#undef TAILSSTART
+#undef TAILSIDLE
+#undef TAILSX
+#undef TAILSY
+#undef KNUXSTART
+#undef KNUXIDLE
+#undef KNUXX
+#undef KNUXY
+
+ break;
+
+ case TTMODE_USER:
+ if (!ttuser[max(0, ttuser_count)])
+ {
+ if(curttloop > -1 && ttuser[curttloop])
+ ttuser_count = curttloop;
+ else if (ttuser[max(0, ttuser_count-1)])
+ ttuser_count = max(0, ttuser_count-1);
+ else
+ break; // draw nothing
+ }
+
+ V_DrawSciencePatch(curttx<<FRACBITS, curtty<<FRACBITS, 0, ttuser[ttuser_count], sc);
+
+ if (!(finalecount % max(1, curtttics)))
+ ttuser_count++;
+ break;
+ }
#ifdef HAVE_BLUA
luahook:
@@ -2379,10 +3337,6 @@ void F_TitleScreenTicker(boolean run)
if (run)
finalecount++;
- // don't trigger if doing anything besides idling on title
- if (gameaction != ga_nothing || gamestate != GS_TITLESCREEN)
- return;
-
// Execute the titlemap camera settings
if (titlemapinaction)
{
@@ -2429,6 +3383,10 @@ void F_TitleScreenTicker(boolean run)
}
}
+ // don't trigger if doing anything besides idling on title
+ if (gameaction != ga_nothing || gamestate != GS_TITLESCREEN)
+ return;
+
// no demos to play? or, are they disabled?
if (!cv_rollingdemos.value || !numDemos)
return;
@@ -2607,8 +3565,8 @@ void F_ContinueDrawer(void)
{
if (!(continuetime & 1) || continuetime > 17)
V_DrawContinueIcon(x, 68, 0, players[consoleplayer].skin, players[consoleplayer].skincolor);
- V_DrawScaledPatch(x+12, 68-2, 0, stlivex);
- V_DrawRightAlignedString(x+36, 69-5, 0,
+ V_DrawScaledPatch(x+12, 66, 0, stlivex);
+ V_DrawRightAlignedString(x+38, 64, 0,
va("%d",(imcontinuing ? ncontinues-1 : ncontinues)));
}
else
diff --git a/src/f_finale.h b/src/f_finale.h
index d640abc8a4896590a406d79a5505050cd20cd29f..f75f93c7745057f6b845054070af3a792bae6a3b 100644
--- a/src/f_finale.h
+++ b/src/f_finale.h
@@ -77,6 +77,28 @@ void F_ContinueDrawer(void);
extern INT32 titlescrollxspeed;
extern INT32 titlescrollyspeed;
+typedef enum
+{
+ TTMODE_NONE = 0,
+ TTMODE_OLD,
+ TTMODE_ALACROIX,
+ TTMODE_USER
+} ttmode_enum;
+
+#define TTMAX_ALACROIX 30 // max frames for SONIC typeface, plus one for NULL terminating entry
+#define TTMAX_USER 100
+
+extern ttmode_enum ttmode;
+extern UINT8 ttscale;
+// ttmode user vars
+extern char ttname[9];
+extern INT16 ttx;
+extern INT16 tty;
+extern INT16 ttloop;
+extern UINT16 tttics;
+extern boolean ttavailable[6];
+
+
typedef enum
{
TITLEMAP_OFF = 0,
@@ -89,11 +111,21 @@ typedef enum
extern mobj_t *titlemapcameraref;
extern char curbgname[9];
extern SINT8 curfadevalue;
-extern boolean curhidepics;
extern INT32 curbgcolor;
extern INT32 curbgxspeed;
extern INT32 curbgyspeed;
extern boolean curbghide;
+extern boolean hidetitlemap;
+
+extern boolean curhidepics;
+extern ttmode_enum curttmode;
+extern UINT8 curttscale;
+// ttmode user vars
+extern char curttname[9];
+extern INT16 curttx;
+extern INT16 curtty;
+extern INT16 curttloop;
+extern UINT16 curtttics;
#define TITLEBACKGROUNDACTIVE (curfadevalue >= 0 || curbgname[0])
diff --git a/src/g_game.c b/src/g_game.c
index 6c31ce9e32b9716494ea7915da4ff55e755bd8e7..18d0cdfe849027a034deae84f95c760294534e70 100644
--- a/src/g_game.c
+++ b/src/g_game.c
@@ -104,7 +104,7 @@ UINT32 demoIdleTime = 3*TICRATE;
boolean timingdemo; // if true, exit with report on completion
boolean nodrawers; // for comparative timing purposes
boolean noblit; // for comparative timing purposes
-static tic_t demostarttime; // for comparative timing purposes
+tic_t demostarttime; // for comparative timing purposes
boolean netgame; // only true if packets are broadcast
boolean multiplayer;
@@ -289,7 +289,7 @@ static struct {
// There is no conflict here.
typedef struct demoghost {
UINT8 checksum[16];
- UINT8 *buffer, *p, color;
+ UINT8 *buffer, *p, color, fadein;
UINT16 version;
mobj_t oldmo, *mo;
struct demoghost *next;
@@ -361,6 +361,8 @@ consvar_t cv_chatbacktint = {"chatbacktint", "On", CV_SAVE, CV_OnOff, NULL, 0, N
static CV_PossibleValue_t consolechat_cons_t[] = {{0, "Window"}, {1, "Console"}, {2, "Window (Hidden)"}, {0, NULL}};
consvar_t cv_consolechat = {"chatmode", "Window", CV_SAVE, consolechat_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
+// Pause game upon window losing focus
+consvar_t cv_pauseifunfocused = {"pauseifunfocused", "Yes", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_crosshair = {"crosshair", "Cross", CV_SAVE, crosshair_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_crosshair2 = {"crosshair2", "Cross", CV_SAVE, crosshair_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -966,8 +968,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics)
forcefullinput = true;
if (twodlevel
|| (player->mo && (player->mo->flags2 & MF2_TWOD))
- || (!demoplayback && (player->climbing
- || (player->powers[pw_carry] == CR_NIGHTSMODE)
+ || (!demoplayback && ((player->powers[pw_carry] == CR_NIGHTSMODE)
|| (player->pflags & (PF_SLIDING|PF_FORCESTRAFE))))) // Analog
forcestrafe = true;
if (forcestrafe)
@@ -1148,8 +1149,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics)
if (!mouseaiming && cv_mousemove.value)
forward += mousey;
- if ((!demoplayback && (player->climbing
- || (player->pflags & PF_SLIDING)))) // Analog for mouse
+ if ((!demoplayback && (player->pflags & PF_SLIDING))) // Analog for mouse
side += mousex*2;
else if (cv_analog.value)
{
@@ -1713,65 +1713,6 @@ static INT32 camtoggledelay, camtoggledelay2 = 0;
//
boolean G_Responder(event_t *ev)
{
- // allow spy mode changes even during the demo
- if (gamestate == GS_LEVEL && ev->type == ev_keydown
- && (ev->data1 == KEY_F12 || ev->data1 == gamecontrol[gc_viewpoint][0] || ev->data1 == gamecontrol[gc_viewpoint][1]))
- {
- if (splitscreen || !netgame)
- displayplayer = consoleplayer;
- else
- {
- // spy mode
- do
- {
- displayplayer++;
- if (displayplayer == MAXPLAYERS)
- displayplayer = 0;
-
- if (!playeringame[displayplayer])
- continue;
-
- if (players[displayplayer].spectator)
- continue;
-
- if (G_GametypeHasTeams())
- {
- if (players[consoleplayer].ctfteam
- && players[displayplayer].ctfteam != players[consoleplayer].ctfteam)
- continue;
- }
- else if (gametype == GT_HIDEANDSEEK)
- {
- if (players[consoleplayer].pflags & PF_TAGIT)
- continue;
- }
- // Other Tag-based gametypes?
- else if (G_TagGametype())
- {
- if (!players[consoleplayer].spectator
- && (players[consoleplayer].pflags & PF_TAGIT) != (players[displayplayer].pflags & PF_TAGIT))
- continue;
- }
- else if (G_GametypeHasSpectators() && G_RingSlingerGametype())
- {
- if (!players[consoleplayer].spectator)
- continue;
- }
-
- break;
- } while (displayplayer != consoleplayer);
-
- // change statusbar also if playing back demo
- if (singledemo)
- ST_changeDemoView();
-
- // tell who's the view
- CONS_Printf(M_GetText("Viewpoint: %s\n"), player_names[displayplayer]);
-
- return true;
- }
- }
-
// any other key pops up menu if in demos
if (gameaction == ga_nothing && !singledemo &&
((demoplayback && !modeattacking && !titledemo) || gamestate == GS_TITLESCREEN))
@@ -1848,6 +1789,65 @@ boolean G_Responder(event_t *ev)
if (HU_Responder(ev))
return true; // chat ate the event
+ // allow spy mode changes even during the demo
+ if (gamestate == GS_LEVEL && ev->type == ev_keydown
+ && (ev->data1 == KEY_F12 || ev->data1 == gamecontrol[gc_viewpoint][0] || ev->data1 == gamecontrol[gc_viewpoint][1]))
+ {
+ if (splitscreen || !netgame)
+ displayplayer = consoleplayer;
+ else
+ {
+ // spy mode
+ do
+ {
+ displayplayer++;
+ if (displayplayer == MAXPLAYERS)
+ displayplayer = 0;
+
+ if (!playeringame[displayplayer])
+ continue;
+
+ if (players[displayplayer].spectator)
+ continue;
+
+ if (G_GametypeHasTeams())
+ {
+ if (players[consoleplayer].ctfteam
+ && players[displayplayer].ctfteam != players[consoleplayer].ctfteam)
+ continue;
+ }
+ else if (gametype == GT_HIDEANDSEEK)
+ {
+ if (players[consoleplayer].pflags & PF_TAGIT)
+ continue;
+ }
+ // Other Tag-based gametypes?
+ else if (G_TagGametype())
+ {
+ if (!players[consoleplayer].spectator
+ && (players[consoleplayer].pflags & PF_TAGIT) != (players[displayplayer].pflags & PF_TAGIT))
+ continue;
+ }
+ else if (G_GametypeHasSpectators() && G_RingSlingerGametype())
+ {
+ if (!players[consoleplayer].spectator)
+ continue;
+ }
+
+ break;
+ } while (displayplayer != consoleplayer);
+
+ // change statusbar also if playing back demo
+ if (singledemo)
+ ST_changeDemoView();
+
+ // tell who's the view
+ CONS_Printf(M_GetText("Viewpoint: %s\n"), player_names[displayplayer]);
+
+ return true;
+ }
+ }
+
// update keys current state
G_MapEventsToControls(ev);
@@ -2755,6 +2755,8 @@ void G_DoReborn(INT32 playernum)
LUAh_MapChange(gamemap);
#endif
G_DoLoadLevel(true);
+ if (metalrecording)
+ G_BeginMetal();
return;
}
}
@@ -2803,7 +2805,7 @@ void G_AddPlayer(INT32 playernum)
countplayers++;
- if (!players->exiting)
+ if (!players[i].exiting)
notexiting++;
if (!(cv_coopstarposts.value && (gametype == GT_COOP) && (p->starpostnum < players[i].starpostnum)))
@@ -2922,7 +2924,7 @@ boolean G_GametypeUsesLives(void)
{
// Coop, Competitive
if ((gametype == GT_COOP || gametype == GT_COMPETITION)
- && !modeattacking // No lives in Time Attack
+ && !(modeattacking || metalrecording) // No lives in Time Attack
//&& !G_IsSpecialStage(gamemap)
&& !(maptol & TOL_NIGHTS)) // No lives in NiGHTS
return true;
@@ -3053,7 +3055,7 @@ static void G_DoCompleted(void)
if (metalplayback)
G_StopMetalDemo();
if (metalrecording)
- G_StopMetalRecording();
+ G_StopMetalRecording(false);
for (i = 0; i < MAXPLAYERS; i++)
if (playeringame[i])
@@ -3341,6 +3343,7 @@ void G_LoadGameData(void)
UINT32 recscore;
tic_t rectime;
UINT16 recrings;
+ boolean gotperf;
UINT8 recmares;
INT32 curmare;
@@ -3357,6 +3360,11 @@ void G_LoadGameData(void)
// Allow saving of gamedata beyond this point
gamedataloaded = true;
+ if (M_CheckParm("-gamedata") && M_IsNextParm())
+ {
+ strlcpy(gamedatafilename, M_GetNextParm(), sizeof gamedatafilename);
+ }
+
if (M_CheckParm("-resetdata"))
return; // Don't load (essentially, reset).
@@ -3433,6 +3441,7 @@ void G_LoadGameData(void)
recscore = READUINT32(save_p);
rectime = (tic_t)READUINT32(save_p);
recrings = READUINT16(save_p);
+ gotperf = (boolean)READUINT8(save_p);
if (recrings > 10000 || recscore > MAXSCORE)
goto datacorrupt;
@@ -3444,6 +3453,9 @@ void G_LoadGameData(void)
mainrecords[i]->time = rectime;
mainrecords[i]->rings = recrings;
}
+
+ if (gotperf)
+ mainrecords[i]->gotperfect = gotperf;
}
// Nights records
@@ -3575,12 +3587,14 @@ void G_SaveGameData(void)
WRITEUINT32(save_p, mainrecords[i]->score);
WRITEUINT32(save_p, mainrecords[i]->time);
WRITEUINT16(save_p, mainrecords[i]->rings);
+ WRITEUINT8(save_p, mainrecords[i]->gotperfect);
}
else
{
WRITEUINT32(save_p, 0);
WRITEUINT32(save_p, 0);
WRITEUINT16(save_p, 0);
+ WRITEUINT8(save_p, 0);
}
}
@@ -4037,7 +4051,7 @@ char *G_BuildMapTitle(INT32 mapnum)
// DEMO RECORDING
//
-#define DEMOVERSION 0x000a
+#define DEMOVERSION 0x000c
#define DEMOHEADER "\xF0" "SRB2Replay" "\x0F"
#define DF_GHOST 0x01 // This demo contains ghost data too!
@@ -4053,6 +4067,8 @@ char *G_BuildMapTitle(INT32 mapnum)
#define ZT_BUTTONS 0x08
#define ZT_AIMING 0x10
#define DEMOMARKER 0x80 // demoend
+#define METALDEATH 0x44
+#define METALSNICE 0x69
static ticcmd_t oldcmd;
@@ -4061,7 +4077,6 @@ static ticcmd_t oldcmd;
#define GZT_MOMXY 0x02
#define GZT_MOMZ 0x04
#define GZT_ANGLE 0x08
-// Not used for Metal Sonic
#define GZT_FRAME 0x10 // Animation frame
#define GZT_SPR2 0x20 // Player animations
#define GZT_EXTRA 0x40
@@ -4077,7 +4092,15 @@ static ticcmd_t oldcmd;
#define EZT_SCALE 0x10 // Changed size
#define EZT_HIT 0x20 // Damaged a mobj
#define EZT_SPRITE 0x40 // Changed sprite set completely out of PLAY (NiGHTS, SOCs, whatever)
-// spare EZT slot 0x80
+#define EZT_HEIGHT 0x80 // Changed height
+
+// GZT_FOLLOW flags
+#define FZT_SPAWNED 0x01 // just been spawned
+#define FZT_SKIN 0x02 // has skin
+#define FZT_LINKDRAW 0x04 // has linkdraw (combine with spawned only)
+#define FZT_COLORIZED 0x08 // colorized (ditto)
+#define FZT_SCALE 0x10 // different scale to object
+// spare FZT slots 0x20 to 0x80
static mobj_t oldmetal, oldghost;
@@ -4203,28 +4226,28 @@ void G_WriteDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
void G_GhostAddThok(void)
{
- if (!demorecording || !(demoflags & DF_GHOST))
+ if (!metalrecording && (!demorecording || !(demoflags & DF_GHOST)))
return;
ghostext.flags = (ghostext.flags & ~EZT_THOKMASK) | EZT_THOK;
}
void G_GhostAddSpin(void)
{
- if (!demorecording || !(demoflags & DF_GHOST))
+ if (!metalrecording && (!demorecording || !(demoflags & DF_GHOST)))
return;
ghostext.flags = (ghostext.flags & ~EZT_THOKMASK) | EZT_SPIN;
}
void G_GhostAddRev(void)
{
- if (!demorecording || !(demoflags & DF_GHOST))
+ if (!metalrecording && (!demorecording || !(demoflags & DF_GHOST)))
return;
ghostext.flags = (ghostext.flags & ~EZT_THOKMASK) | EZT_REV;
}
void G_GhostAddFlip(void)
{
- if (!demorecording || !(demoflags & DF_GHOST))
+ if (!metalrecording && (!demorecording || !(demoflags & DF_GHOST)))
return;
ghostext.flags |= EZT_FLIP;
}
@@ -4244,7 +4267,7 @@ void G_GhostAddColor(ghostcolor_t color)
void G_GhostAddScale(fixed_t scale)
{
- if (!demorecording || !(demoflags & DF_GHOST))
+ if (!metalrecording && (!demorecording || !(demoflags & DF_GHOST)))
return;
if (ghostext.lastscale == scale)
{
@@ -4270,6 +4293,7 @@ void G_WriteGhostTic(mobj_t *ghost)
char ziptic = 0;
UINT8 *ziptic_p;
UINT32 i;
+ fixed_t height;
if (!demo_p)
return;
@@ -4359,6 +4383,12 @@ void G_WriteGhostTic(mobj_t *ghost)
ghostext.flags |= EZT_SPRITE;
}
+ if ((height = FixedDiv(ghost->height, ghost->scale)) != oldghost.height)
+ {
+ oldghost.height = height;
+ ghostext.flags |= EZT_HEIGHT;
+ }
+
if (ghostext.flags)
{
ziptic |= GZT_EXTRA;
@@ -4398,26 +4428,60 @@ void G_WriteGhostTic(mobj_t *ghost)
ghostext.hitlist = NULL;
}
if (ghostext.flags & EZT_SPRITE)
- WRITEUINT8(demo_p,oldghost.sprite);
+ WRITEUINT16(demo_p,oldghost.sprite);
+ if (ghostext.flags & EZT_HEIGHT)
+ {
+ height >>= FRACBITS;
+ WRITEINT16(demo_p, height);
+ }
ghostext.flags = 0;
}
- if (ghost->player && ghost->player->followmobj) // bloats tails runs but what can ya do
+ if (ghost->player && ghost->player->followmobj && !(ghost->player->followmobj->sprite == SPR_NULL || (ghost->player->followmobj->flags2 & MF2_DONTDRAW))) // bloats tails runs but what can ya do
{
INT16 temp;
+ UINT8 *followtic_p = demo_p++;
+ UINT8 followtic = 0;
ziptic |= GZT_FOLLOW;
+ if (ghost->player->followmobj->skin)
+ followtic |= FZT_SKIN;
+
+ if (!(oldghost.flags2 & MF2_AMBUSH))
+ {
+ followtic |= FZT_SPAWNED;
+ WRITEINT16(demo_p,ghost->player->followmobj->info->height>>FRACBITS);
+ if (ghost->player->followmobj->flags2 & MF2_LINKDRAW)
+ followtic |= FZT_LINKDRAW;
+ if (ghost->player->followmobj->colorized)
+ followtic |= FZT_COLORIZED;
+ if (followtic & FZT_SKIN)
+ WRITEUINT8(demo_p,(UINT8)(((skin_t *)(ghost->player->followmobj->skin))-skins));
+ oldghost.flags2 |= MF2_AMBUSH;
+ }
+
temp = (INT16)((ghost->player->followmobj->x-ghost->x)>>8);
WRITEINT16(demo_p,temp);
temp = (INT16)((ghost->player->followmobj->y-ghost->y)>>8);
WRITEINT16(demo_p,temp);
temp = (INT16)((ghost->player->followmobj->z-ghost->z)>>8);
WRITEINT16(demo_p,temp);
- WRITEUINT8(demo_p,ghost->player->followmobj->sprite);
- WRITEUINT8(demo_p,ghost->player->followmobj->sprite2);
+ if (followtic & FZT_SKIN)
+ WRITEUINT8(demo_p,ghost->player->followmobj->sprite2);
+ WRITEUINT16(demo_p,ghost->player->followmobj->sprite);
WRITEUINT8(demo_p,(ghost->player->followmobj->frame & FF_FRAMEMASK));
+ WRITEUINT8(demo_p,ghost->player->followmobj->color);
+ if (ghost->player->followmobj->scale != ghost->scale)
+ {
+ followtic |= FZT_SCALE;
+ WRITEFIXED(demo_p,ghost->player->followmobj->scale);
+ }
+
+ *followtic_p = followtic;
}
+ else
+ oldghost.flags2 &= ~MF2_AMBUSH;
*ziptic_p = ziptic;
@@ -4521,15 +4585,28 @@ void G_ConsGhostTic(void)
}
}
if (xziptic & EZT_SPRITE)
- demo_p++;
+ demo_p += sizeof(UINT16);
+ if (xziptic & EZT_HEIGHT)
+ demo_p += sizeof(INT16);
}
if (ziptic & GZT_FOLLOW)
{ // Even more...
+ UINT8 followtic = READUINT8(demo_p);
+ if (followtic & FZT_SPAWNED)
+ {
+ demo_p += sizeof(INT16);
+ if (followtic & FZT_SKIN)
+ demo_p++;
+ }
+ if (followtic & FZT_SCALE)
+ demo_p += sizeof(fixed_t);
demo_p += sizeof(INT16);
demo_p += sizeof(INT16);
demo_p += sizeof(INT16);
- demo_p++;
+ if (followtic & FZT_SKIN)
+ demo_p++;
+ demo_p += sizeof(UINT16);
demo_p++;
demo_p++;
}
@@ -4617,6 +4694,11 @@ void G_GhostTicker(void)
g->mo->z = g->oldmo.z;
P_SetThingPosition(g->mo);
g->mo->frame = g->oldmo.frame | tr_trans30<<FF_TRANSSHIFT;
+ if (g->fadein)
+ {
+ g->mo->frame += (((--g->fadein)/6)<<FF_TRANSSHIFT); // this calc never exceeds 9 unless g->fadein is bad, and it's only set once, so...
+ g->mo->flags2 &= ~MF2_DONTDRAW;
+ }
g->mo->sprite2 = g->oldmo.sprite2;
if (ziptic & GZT_EXTRA)
@@ -4674,33 +4756,38 @@ void G_GhostTicker(void)
break;
}
}
- if (type == MT_GHOST)
- {
- mobj = P_SpawnGhostMobj(g->mo); // does a large portion of the work for us
- mobj->frame = (mobj->frame & ~FF_FRAMEMASK)|tr_trans60<<FF_TRANSSHIFT; // P_SpawnGhostMobj sets trans50, we want trans60
- }
- else
+ if (type != MT_NULL)
{
- mobj = P_SpawnMobj(g->mo->x, g->mo->y, g->mo->z - FixedDiv(FixedMul(g->mo->info->height, g->mo->scale) - g->mo->height,3*FRACUNIT), MT_THOK);
- mobj->sprite = states[mobjinfo[type].spawnstate].sprite;
- mobj->frame = (states[mobjinfo[type].spawnstate].frame & FF_FRAMEMASK) | tr_trans60<<FF_TRANSSHIFT;
- mobj->tics = -1; // nope.
- mobj->color = g->mo->color;
- if (g->mo->eflags & MFE_VERTICALFLIP)
+ if (type == MT_GHOST)
{
- mobj->flags2 |= MF2_OBJECTFLIP;
- mobj->eflags |= MFE_VERTICALFLIP;
+ mobj = P_SpawnGhostMobj(g->mo); // does a large portion of the work for us
+ mobj->frame = (mobj->frame & ~FF_FRAMEMASK)|tr_trans60<<FF_TRANSSHIFT; // P_SpawnGhostMobj sets trans50, we want trans60
}
- P_SetScale(mobj, g->mo->scale);
- mobj->destscale = g->mo->scale;
+ else
+ {
+ mobj = P_SpawnMobjFromMobj(g->mo, 0, 0, -FixedDiv(FixedMul(g->mo->info->height, g->mo->scale) - g->mo->height,3*FRACUNIT), MT_THOK);
+ mobj->sprite = states[mobjinfo[type].spawnstate].sprite;
+ mobj->frame = (states[mobjinfo[type].spawnstate].frame & FF_FRAMEMASK) | tr_trans60<<FF_TRANSSHIFT;
+ mobj->color = g->mo->color;
+ mobj->skin = g->mo->skin;
+ P_SetScale(mobj, (mobj->destscale = g->mo->scale));
+
+ if (type == MT_THOK) // spintrail-specific modification for MT_THOK
+ {
+ mobj->frame = FF_TRANS80;
+ mobj->fuse = mobj->tics;
+ }
+ mobj->tics = -1; // nope.
+ }
+ mobj->floorz = mobj->z;
+ mobj->ceilingz = mobj->z+mobj->height;
+ P_UnsetThingPosition(mobj);
+ mobj->flags = MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY; // make an ATTEMPT to curb crazy SOCs fucking stuff up...
+ P_SetThingPosition(mobj);
+ if (!mobj->fuse)
+ mobj->fuse = 8;
+ P_SetTarget(&mobj->target, g->mo);
}
- mobj->floorz = mobj->z;
- mobj->ceilingz = mobj->z+mobj->height;
- P_UnsetThingPosition(mobj);
- mobj->flags = MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY; // make an ATTEMPT to curb crazy SOCs fucking stuff up...
- P_SetThingPosition(mobj);
- mobj->fuse = 8;
- P_SetTarget(&mobj->target, g->mo);
}
if (xziptic & EZT_HIT)
{ // Spawn hit poofs for killing things!
@@ -4730,7 +4817,12 @@ void G_GhostTicker(void)
}
}
if (xziptic & EZT_SPRITE)
- g->mo->sprite = READUINT8(g->p);
+ g->mo->sprite = READUINT16(g->p);
+ if (xziptic & EZT_HEIGHT)
+ {
+ fixed_t temp = READINT16(g->p)<<FRACBITS;
+ g->mo->height = FixedMul(temp, g->mo->scale);
+ }
}
// Tick ghost colors (Super and Mario Invincibility flashing)
@@ -4756,55 +4848,81 @@ void G_GhostTicker(void)
#define follow g->mo->tracer
if (ziptic & GZT_FOLLOW)
{ // Even more...
- if (!follow)
+ UINT8 followtic = READUINT8(g->p);
+ fixed_t temp;
+ if (followtic & FZT_SPAWNED)
{
- mobj_t *newmo = P_SpawnMobj(g->mo->x, g->mo->y, g->mo->z, MT_GHOST);
- P_SetTarget(&g->mo->tracer, newmo);
- P_SetTarget(&newmo->tracer, g->mo);
- newmo->skin = g->mo->skin;
- newmo->tics = -1;
- newmo->flags2 |= MF2_LINKDRAW;
-
- follow->eflags = (follow->eflags & ~MFE_VERTICALFLIP)|(g->mo->eflags & MFE_VERTICALFLIP);
- follow->destscale = g->mo->destscale;
- if (follow->destscale != follow->scale)
- P_SetScale(follow, follow->destscale);
+ if (follow)
+ P_RemoveMobj(follow);
+ P_SetTarget(&follow, P_SpawnMobjFromMobj(g->mo, 0, 0, 0, MT_GHOST));
+ P_SetTarget(&follow->tracer, g->mo);
+ follow->tics = -1;
+ temp = READINT16(g->p)<<FRACBITS;
+ follow->height = FixedMul(follow->scale, temp);
+
+ if (followtic & FZT_LINKDRAW)
+ follow->flags2 |= MF2_LINKDRAW;
+
+ if (followtic & FZT_COLORIZED)
+ follow->colorized = true;
+
+ if (followtic & FZT_SKIN)
+ follow->skin = &skins[READUINT8(g->p)];
}
- else
+ if (follow)
{
- if (xziptic & EZT_FLIP)
- g->mo->eflags ^= MFE_VERTICALFLIP;
- if (xziptic & EZT_SCALE)
- {
+ if (followtic & FZT_SCALE)
+ follow->destscale = READFIXED(g->p);
+ else
follow->destscale = g->mo->destscale;
- if (follow->destscale != follow->scale)
- P_SetScale(follow, follow->destscale);
+ if (follow->destscale != follow->scale)
+ P_SetScale(follow, follow->destscale);
+
+ P_UnsetThingPosition(follow);
+ temp = READINT16(g->p)<<8;
+ follow->x = g->mo->x + temp;
+ temp = READINT16(g->p)<<8;
+ follow->y = g->mo->y + temp;
+ temp = READINT16(g->p)<<8;
+ follow->z = g->mo->z + temp;
+ P_SetThingPosition(follow);
+ if (followtic & FZT_SKIN)
+ follow->sprite2 = READUINT8(g->p);
+ else
+ follow->sprite2 = 0;
+ follow->sprite = READUINT16(g->p);
+ follow->frame = (READUINT8(g->p)) | (g->mo->frame & FF_TRANSMASK);
+ follow->angle = g->mo->angle;
+ follow->color = READUINT8(g->p);
+
+ if (!(followtic & FZT_SPAWNED))
+ {
+ if (xziptic & EZT_FLIP)
+ {
+ follow->flags2 ^= MF2_OBJECTFLIP;
+ follow->eflags ^= MFE_VERTICALFLIP;
+ }
}
}
-
- P_UnsetThingPosition(follow);
- follow->x = g->mo->x + (READINT16(g->p)<<8);
- follow->y = g->mo->y + (READINT16(g->p)<<8);
- follow->z = g->mo->z + (READINT16(g->p)<<8);
- P_SetThingPosition(follow);
- follow->sprite = READUINT8(g->p);
- follow->sprite2 = READUINT8(g->p);
- follow->frame = (READUINT8(g->p)) | tr_trans30<<FF_TRANSSHIFT;
-
- follow->angle = g->mo->angle;
- follow->color = g->mo->color;
}
else if (follow)
{
P_RemoveMobj(follow);
P_SetTarget(&follow, NULL);
}
-#undef follow
-
// Demo ends after ghost data.
if (*g->p == DEMOMARKER)
{
g->mo->momx = g->mo->momy = g->mo->momz = 0;
+#if 1 // freeze frame (maybe more useful for time attackers)
+ g->mo->colorized = true;
+ if (follow)
+ follow->colorized = true;
+#else // dissapearing act
+ g->mo->fuse = TICRATE;
+ if (follow)
+ follow->fuse = TICRATE;
+#endif
if (p)
p->next = g->next;
else
@@ -4813,17 +4931,41 @@ void G_GhostTicker(void)
continue;
}
p = g;
+#undef follow
}
}
void G_ReadMetalTic(mobj_t *metal)
{
UINT8 ziptic;
- UINT16 speed;
- UINT8 statetype;
+ UINT8 xziptic = 0;
if (!metal_p)
return;
+
+ if (!metal->health)
+ {
+ G_StopMetalDemo();
+ return;
+ }
+
+ switch (*metal_p)
+ {
+ case METALSNICE:
+ break;
+ case METALDEATH:
+ if (metal->tracer)
+ P_RemoveMobj(metal->tracer);
+ P_KillMobj(metal, NULL, NULL, 0);
+ /* FALLTHRU */
+ case DEMOMARKER:
+ default:
+ // end of demo data stream
+ G_StopMetalDemo();
+ return;
+ }
+ metal_p++;
+
ziptic = READUINT8(metal_p);
// Read changes from the tic
@@ -4850,9 +4992,9 @@ void G_ReadMetalTic(mobj_t *metal)
if (ziptic & GZT_ANGLE)
metal->angle = READUINT8(metal_p)<<24;
if (ziptic & GZT_FRAME)
- metal_p++; // Currently unused. (Metal Sonic figures out what he's doing his own damn self.)
+ oldmetal.frame = READUINT32(metal_p);
if (ziptic & GZT_SPR2)
- metal_p++;
+ oldmetal.sprite2 = READUINT8(metal_p);
// Set movement, position, and angle
// oldmetal contains where you're supposed to be.
@@ -4864,67 +5006,160 @@ void G_ReadMetalTic(mobj_t *metal)
metal->y = oldmetal.y;
metal->z = oldmetal.z;
P_SetThingPosition(metal);
+ metal->frame = oldmetal.frame;
+ metal->sprite2 = oldmetal.sprite2;
if (ziptic & GZT_EXTRA)
{ // But wait, there's more!
- ziptic = READUINT8(metal_p);
- if (ziptic & EZT_FLIP)
+ xziptic = READUINT8(metal_p);
+ if (xziptic & EZT_FLIP)
metal->eflags ^= MFE_VERTICALFLIP;
- if (ziptic & EZT_SCALE)
+ if (xziptic & EZT_SCALE)
{
metal->destscale = READFIXED(metal_p);
if (metal->destscale != metal->scale)
P_SetScale(metal, metal->destscale);
}
- }
-
- // Calculates player's speed based on distance-of-a-line formula
- speed = FixedDiv(P_AproxDistance(oldmetal.momx, oldmetal.momy), metal->scale)>>FRACBITS;
-
- // Use speed to decide an appropriate state
- if (speed > 28) // default skin runspeed
- statetype = 2;
- else if (speed > 1) // stopspeed
- statetype = 1;
- else
- statetype = 0;
+ if (xziptic & EZT_THOKMASK)
+ { // Let's only spawn ONE of these per frame, thanks.
+ mobj_t *mobj;
+ INT32 type = -1;
+ if (metal->skin)
+ {
+ skin_t *skin = (skin_t *)metal->skin;
+ switch (xziptic & EZT_THOKMASK)
+ {
+ case EZT_THOK:
+ type = skin->thokitem < 0 ? (UINT32)mobjinfo[MT_PLAYER].painchance : (UINT32)skin->thokitem;
+ break;
+ case EZT_SPIN:
+ type = skin->spinitem < 0 ? (UINT32)mobjinfo[MT_PLAYER].damage : (UINT32)skin->spinitem;
+ break;
+ case EZT_REV:
+ type = skin->revitem < 0 ? (UINT32)mobjinfo[MT_PLAYER].raisestate : (UINT32)skin->revitem;
+ break;
+ }
+ }
+ if (type != MT_NULL)
+ {
+ if (type == MT_GHOST)
+ {
+ mobj = P_SpawnGhostMobj(metal); // does a large portion of the work for us
+ }
+ else
+ {
+ mobj = P_SpawnMobjFromMobj(metal, 0, 0, -FixedDiv(FixedMul(metal->info->height, metal->scale) - metal->height,3*FRACUNIT), MT_THOK);
+ mobj->sprite = states[mobjinfo[type].spawnstate].sprite;
+ mobj->frame = states[mobjinfo[type].spawnstate].frame;
+ mobj->angle = metal->angle;
+ mobj->color = metal->color;
+ mobj->skin = metal->skin;
+ P_SetScale(mobj, (mobj->destscale = metal->scale));
- // Set state
- if (statetype != metal->threshold)
- {
- switch (statetype)
+ if (type == MT_THOK) // spintrail-specific modification for MT_THOK
+ {
+ mobj->frame = FF_TRANS70;
+ mobj->fuse = mobj->tics;
+ }
+ mobj->tics = -1; // nope.
+ }
+ mobj->floorz = mobj->z;
+ mobj->ceilingz = mobj->z+mobj->height;
+ P_UnsetThingPosition(mobj);
+ mobj->flags = MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY; // make an ATTEMPT to curb crazy SOCs fucking stuff up...
+ P_SetThingPosition(mobj);
+ if (!mobj->fuse)
+ mobj->fuse = 8;
+ P_SetTarget(&mobj->target, metal);
+ }
+ }
+ if (xziptic & EZT_SPRITE)
+ metal->sprite = READUINT16(metal_p);
+ if (xziptic & EZT_HEIGHT)
{
- case 2: // run
- P_SetMobjState(metal,metal->info->meleestate);
- break;
- case 1: // walk
- P_SetMobjState(metal,metal->info->seestate);
- break;
- default: // stand
- P_SetMobjState(metal,metal->info->spawnstate);
- break;
+ fixed_t temp = READINT16(metal_p)<<FRACBITS;
+ metal->height = FixedMul(temp, metal->scale);
}
- metal->threshold = statetype;
}
- // TODO: Modify state durations based on movement speed, similar to players?
+#define follow metal->tracer
+ if (ziptic & GZT_FOLLOW)
+ { // Even more...
+ UINT8 followtic = READUINT8(metal_p);
+ fixed_t temp;
+ if (followtic & FZT_SPAWNED)
+ {
+ if (follow)
+ P_RemoveMobj(follow);
+ P_SetTarget(&follow, P_SpawnMobjFromMobj(metal, 0, 0, 0, MT_GHOST));
+ P_SetTarget(&follow->tracer, metal);
+ follow->tics = -1;
+ temp = READINT16(metal_p)<<FRACBITS;
+ follow->height = FixedMul(follow->scale, temp);
+
+ if (followtic & FZT_LINKDRAW)
+ follow->flags2 |= MF2_LINKDRAW;
+
+ if (followtic & FZT_COLORIZED)
+ follow->colorized = true;
+
+ if (followtic & FZT_SKIN)
+ follow->skin = &skins[READUINT8(metal_p)];
+ }
+ if (follow)
+ {
+ if (followtic & FZT_SCALE)
+ follow->destscale = READFIXED(metal_p);
+ else
+ follow->destscale = metal->destscale;
+ if (follow->destscale != follow->scale)
+ P_SetScale(follow, follow->destscale);
- if (*metal_p == DEMOMARKER)
- {
- // end of demo data stream
- G_StopMetalDemo();
- return;
- }
+ P_UnsetThingPosition(follow);
+ temp = READINT16(metal_p)<<8;
+ follow->x = metal->x + temp;
+ temp = READINT16(metal_p)<<8;
+ follow->y = metal->y + temp;
+ temp = READINT16(metal_p)<<8;
+ follow->z = metal->z + temp;
+ P_SetThingPosition(follow);
+ if (followtic & FZT_SKIN)
+ follow->sprite2 = READUINT8(metal_p);
+ else
+ follow->sprite2 = 0;
+ follow->sprite = READUINT16(metal_p);
+ follow->frame = READUINT32(metal_p); // NOT & FF_FRAMEMASK here, so 32 bits
+ follow->angle = metal->angle;
+ follow->color = READUINT8(metal_p);
+
+ if (!(followtic & FZT_SPAWNED))
+ {
+ if (xziptic & EZT_FLIP)
+ {
+ follow->flags2 ^= MF2_OBJECTFLIP;
+ follow->eflags ^= MFE_VERTICALFLIP;
+ }
+ }
+ }
+ }
+ else if (follow)
+ {
+ P_RemoveMobj(follow);
+ P_SetTarget(&follow, NULL);
+ }
+#undef follow
}
void G_WriteMetalTic(mobj_t *metal)
{
UINT8 ziptic = 0;
UINT8 *ziptic_p;
+ fixed_t height;
- if (!demo_p) // demo_p will be NULL until the race start linedef executor is triggered!
+ if (!demo_p) // demo_p will be NULL until the race start linedef executor is activated!
return;
+ WRITEUINT8(demo_p, METALSNICE);
ziptic_p = demo_p++; // the ziptic, written at the end of this function
#define MAXMOM (0xFFFF<<8)
@@ -4937,10 +5172,10 @@ void G_WriteMetalTic(mobj_t *metal)
oldmetal.x = metal->x;
oldmetal.y = metal->y;
oldmetal.z = metal->z;
+ ziptic |= GZT_XYZ;
WRITEFIXED(demo_p,oldmetal.x);
WRITEFIXED(demo_p,oldmetal.y);
WRITEFIXED(demo_p,oldmetal.z);
- ziptic |= GZT_XYZ;
}
else
{
@@ -4953,16 +5188,16 @@ void G_WriteMetalTic(mobj_t *metal)
{
oldmetal.momx = momx;
oldmetal.momy = momy;
+ ziptic |= GZT_MOMXY;
WRITEINT16(demo_p,momx);
WRITEINT16(demo_p,momy);
- ziptic |= GZT_MOMXY;
}
momx = (INT16)((metal->z-oldmetal.z)>>8);
if (momx != oldmetal.momz)
{
oldmetal.momz = momx;
- WRITEINT16(demo_p,momx);
ziptic |= GZT_MOMZ;
+ WRITEINT16(demo_p,momx);
}
// This SHOULD set oldmetal.x/y/z to match metal->x/y/z
@@ -4985,33 +5220,104 @@ void G_WriteMetalTic(mobj_t *metal)
WRITEUINT8(demo_p,oldmetal.angle);
}
- // Metal Sonic does not need our state changes.
- // ... currently.
+ // Store the sprite frame.
+ if ((metal->frame & FF_FRAMEMASK) != oldmetal.frame)
+ {
+ oldmetal.frame = metal->frame; // NOT & FF_FRAMEMASK here, so 32 bits
+ ziptic |= GZT_FRAME;
+ WRITEUINT32(demo_p,oldmetal.frame);
+ }
+
+ if (metal->sprite == SPR_PLAY
+ && metal->sprite2 != oldmetal.sprite2)
+ {
+ oldmetal.sprite2 = metal->sprite2;
+ ziptic |= GZT_SPR2;
+ WRITEUINT8(demo_p,oldmetal.sprite2);
+ }
+ // Check for sprite set changes
+ if (metal->sprite != oldmetal.sprite)
{
- UINT8 *exttic_p = NULL;
- UINT8 exttic = 0;
- if ((metal->eflags & MFE_VERTICALFLIP) != (oldmetal.eflags & MFE_VERTICALFLIP))
+ oldmetal.sprite = metal->sprite;
+ ghostext.flags |= EZT_SPRITE;
+ }
+
+ if ((height = FixedDiv(metal->height, metal->scale)) != oldmetal.height)
+ {
+ oldmetal.height = height;
+ ghostext.flags |= EZT_HEIGHT;
+ }
+
+ if (ghostext.flags & ~(EZT_COLOR|EZT_HIT)) // these two aren't handled by metal ever
+ {
+ ziptic |= GZT_EXTRA;
+
+ if (ghostext.scale == ghostext.lastscale)
+ ghostext.flags &= ~EZT_SCALE;
+
+ WRITEUINT8(demo_p,ghostext.flags);
+ if (ghostext.flags & EZT_SCALE)
{
- if (!exttic_p)
- exttic_p = demo_p++;
- exttic |= EZT_FLIP;
- oldmetal.eflags ^= MFE_VERTICALFLIP;
+ WRITEFIXED(demo_p,ghostext.scale);
+ ghostext.lastscale = ghostext.scale;
}
- if (metal->scale != oldmetal.scale)
+ if (ghostext.flags & EZT_SPRITE)
+ WRITEUINT16(demo_p,oldmetal.sprite);
+ if (ghostext.flags & EZT_HEIGHT)
+ {
+ height >>= FRACBITS;
+ WRITEINT16(demo_p, height);
+ }
+ ghostext.flags = 0;
+ }
+
+ if (metal->player && metal->player->followmobj && !(metal->player->followmobj->sprite == SPR_NULL || (metal->player->followmobj->flags2 & MF2_DONTDRAW)))
+ {
+ INT16 temp;
+ UINT8 *followtic_p = demo_p++;
+ UINT8 followtic = 0;
+
+ ziptic |= GZT_FOLLOW;
+
+ if (metal->player->followmobj->skin)
+ followtic |= FZT_SKIN;
+
+ if (!(oldmetal.flags2 & MF2_AMBUSH))
{
- if (!exttic_p)
- exttic_p = demo_p++;
- exttic |= EZT_SCALE;
- WRITEFIXED(demo_p,metal->scale);
- oldmetal.scale = metal->scale;
+ followtic |= FZT_SPAWNED;
+ WRITEINT16(demo_p,metal->player->followmobj->info->height>>FRACBITS);
+ if (metal->player->followmobj->flags2 & MF2_LINKDRAW)
+ followtic |= FZT_LINKDRAW;
+ if (metal->player->followmobj->colorized)
+ followtic |= FZT_COLORIZED;
+ if (followtic & FZT_SKIN)
+ WRITEUINT8(demo_p,(UINT8)(((skin_t *)(metal->player->followmobj->skin))-skins));
+ oldmetal.flags2 |= MF2_AMBUSH;
}
- if (exttic_p)
+
+ if (metal->player->followmobj->scale != metal->scale)
{
- *exttic_p = exttic;
- ziptic |= GZT_EXTRA;
+ followtic |= FZT_SCALE;
+ WRITEFIXED(demo_p,metal->player->followmobj->scale);
}
+
+ temp = (INT16)((metal->player->followmobj->x-metal->x)>>8);
+ WRITEINT16(demo_p,temp);
+ temp = (INT16)((metal->player->followmobj->y-metal->y)>>8);
+ WRITEINT16(demo_p,temp);
+ temp = (INT16)((metal->player->followmobj->z-metal->z)>>8);
+ WRITEINT16(demo_p,temp);
+ if (followtic & FZT_SKIN)
+ WRITEUINT8(demo_p,metal->player->followmobj->sprite2);
+ WRITEUINT16(demo_p,metal->player->followmobj->sprite);
+ WRITEUINT32(demo_p,metal->player->followmobj->frame); // NOT & FF_FRAMEMASK here, so 32 bits
+ WRITEUINT8(demo_p,metal->player->followmobj->color);
+
+ *followtic_p = followtic;
}
+ else
+ oldmetal.flags2 &= ~MF2_AMBUSH;
*ziptic_p = ziptic;
@@ -5019,7 +5325,7 @@ void G_WriteMetalTic(mobj_t *metal)
// latest demos with mouse aiming byte in ticcmd
if (demo_p >= demoend - 32)
{
- G_StopMetalRecording(); // no more space
+ G_StopMetalRecording(false); // no more space
return;
}
}
@@ -5153,22 +5459,36 @@ void G_BeginRecording(void)
// And mobjtype_t is best with UINT32 too...
WRITEUINT32(demo_p, player->followitem);
- // Save pflag data
+ // Save pflag data - see SendWeaponPref()
{
UINT8 buf = 0;
- if (player->pflags & PF_FLIPCAM)
+ pflags_t pflags = 0;
+ if (cv_flipcam.value)
+ {
buf |= 0x01;
- if (player->pflags & PF_ANALOGMODE)
+ pflags |= PF_FLIPCAM;
+ }
+ if (cv_analog.value)
+ {
buf |= 0x02;
- if (player->pflags & PF_DIRECTIONCHAR)
+ pflags |= PF_ANALOGMODE;
+ }
+ if (cv_directionchar.value)
+ {
buf |= 0x04;
- if (player->pflags & PF_AUTOBRAKE)
+ pflags |= PF_DIRECTIONCHAR;
+ }
+ if (cv_autobrake.value)
+ {
buf |= 0x08;
+ pflags |= PF_AUTOBRAKE;
+ }
if (cv_usejoystick.value)
buf |= 0x10;
CV_SetValue(&cv_showinputjoy, !!(cv_usejoystick.value));
WRITEUINT8(demo_p,buf);
+ player->pflags = pflags;
}
// Save netvar data
@@ -5197,8 +5517,10 @@ void G_BeginMetal(void)
{
mobj_t *mo = players[consoleplayer].mo;
+#if 0
if (demo_p)
return;
+#endif
demo_p = demobuffer;
@@ -5213,6 +5535,9 @@ void G_BeginMetal(void)
M_Memcpy(demo_p, "METL", 4); demo_p += 4;
+ memset(&ghostext,0,sizeof(ghostext));
+ ghostext.lastscale = ghostext.scale = FRACUNIT;
+
// Set up our memory.
memset(&oldmetal,0,sizeof(oldmetal));
oldmetal.x = mo->x;
@@ -5861,7 +6186,9 @@ void G_AddGhost(char *defdemoname)
gh->mo->state = states+S_PLAY_STND;
gh->mo->sprite = gh->mo->state->sprite;
gh->mo->sprite2 = (gh->mo->state->frame & FF_FRAMEMASK);
- gh->mo->frame = tr_trans20<<FF_TRANSSHIFT;
+ //gh->mo->frame = tr_trans30<<FF_TRANSSHIFT;
+ gh->mo->flags2 |= MF2_DONTDRAW;
+ gh->fadein = (9-3)*6; // fade from invisible to trans30 over as close to 35 tics as possible
gh->mo->tics = -1;
CONS_Printf(M_GetText("Added ghost %s from %s\n"), name, pdemoname);
@@ -5982,19 +6309,23 @@ void G_StopMetalDemo(void)
}
// Stops metal sonic recording.
-ATTRNORETURN void FUNCNORETURN G_StopMetalRecording(void)
+ATTRNORETURN void FUNCNORETURN G_StopMetalRecording(boolean kill)
{
boolean saved = false;
if (demo_p)
{
UINT8 *p = demobuffer+16; // checksum position
+ if (kill)
+ WRITEUINT8(demo_p, METALDEATH); // add the metal death marker
+ else
+ WRITEUINT8(demo_p, DEMOMARKER); // add the demo end marker
#ifdef NOMD5
- UINT8 i;
- WRITEUINT8(demo_p, DEMOMARKER); // add the demo end marker
- for (i = 0; i < 16; i++, p++)
- *p = P_RandomByte(); // This MD5 was chosen by fair dice roll and most likely < 50% correct.
+ {
+ UINT8 i;
+ for (i = 0; i < 16; i++, p++)
+ *p = P_RandomByte(); // This MD5 was chosen by fair dice roll and most likely < 50% correct.
+ }
#else
- WRITEUINT8(demo_p, DEMOMARKER); // add the demo end marker
md5_buffer((char *)p+16, demo_p - (p+16), (void *)p); // make a checksum of everything after the checksum in the file.
#endif
saved = FIL_WriteFile(va("%sMS.LMP", G_BuildMapName(gamemap)), demobuffer, demo_p - demobuffer); // finally output the file.
@@ -6052,7 +6383,46 @@ boolean G_CheckDemoStatus(void)
timingdemo = false;
f1 = (double)demotime;
f2 = (double)framecount*TICRATE;
- CONS_Printf(M_GetText("timed %u gametics in %d realtics\n%f seconds, %f avg fps\n"), leveltime,demotime,f1/TICRATE,f2/f1);
+
+ CONS_Printf(M_GetText("timed %u gametics in %d realtics - %u frames\n%f seconds, %f avg fps\n"),
+ leveltime,demotime,(UINT32)framecount,f1/TICRATE,f2/f1);
+
+ // CSV-readable timedemo results, for external parsing
+ if (timedemo_csv)
+ {
+ FILE *f;
+ const char *csvpath = va("%s"PATHSEP"%s", srb2home, "timedemo.csv");
+ const char *header = "id,demoname,seconds,avgfps,leveltime,demotime,framecount,ticrate,rendermode,vidmode,vidwidth,vidheight,procbits\n";
+ const char *rowformat = "\"%s\",\"%s\",%f,%f,%u,%d,%u,%u,%u,%u,%u,%u,%u\n";
+ boolean headerrow = !FIL_FileExists(csvpath);
+ UINT8 procbits = 0;
+
+ // Bitness
+ if (sizeof(void*) == 4)
+ procbits = 32;
+ else if (sizeof(void*) == 8)
+ procbits = 64;
+
+ f = fopen(csvpath, "a+");
+
+ if (f)
+ {
+ if (headerrow)
+ fputs(header, f);
+ fprintf(f, rowformat,
+ timedemo_csv_id,timedemo_name,f1/TICRATE,f2/f1,leveltime,demotime,(UINT32)framecount,TICRATE,rendermode,vid.modenum,vid.width,vid.height,procbits);
+ fclose(f);
+ CONS_Printf("Timedemo results saved to '%s'\n", csvpath);
+ }
+ else
+ {
+ // Just print the CSV output to console
+ CON_LogMessage(header);
+ CONS_Printf(rowformat,
+ timedemo_csv_id,timedemo_name,f1/TICRATE,f2/f1,leveltime,demotime,(UINT32)framecount,TICRATE,rendermode,vid.modenum,vid.width,vid.height,procbits);
+ }
+ }
+
if (restorecv_vidwait != cv_vidwait.value)
CV_SetValue(&cv_vidwait, restorecv_vidwait);
D_AdvanceDemo();
diff --git a/src/g_game.h b/src/g_game.h
index df1301dd7c392071a14fa66870c9f8fc7f099883..22abae17dea2c66d116fc109fe08101161d3c646 100644
--- a/src/g_game.h
+++ b/src/g_game.h
@@ -37,6 +37,7 @@ extern boolean playeringame[MAXPLAYERS];
// demoplaying back and demo recording
extern boolean demoplayback, titledemo, demorecording, timingdemo;
+extern tic_t demostarttime;
// Quit after playing a demo from cmdline.
extern boolean singledemo;
@@ -59,6 +60,8 @@ extern boolean pausebreakkey;
extern boolean promptactive;
+extern consvar_t cv_pauseifunfocused;
+
// used in game menu
extern consvar_t cv_tutorialprompt;
extern consvar_t cv_chatwidth, cv_chatnotifications, cv_chatheight, cv_chattime, cv_consolechat, cv_chatbacktint, cv_chatspamprotection, cv_compactscoreboard;
@@ -172,7 +175,7 @@ void G_AddGhost(char *defdemoname);
void G_DoPlayMetal(void);
void G_DoneLevelLoad(void);
void G_StopMetalDemo(void);
-ATTRNORETURN void FUNCNORETURN G_StopMetalRecording(void);
+ATTRNORETURN void FUNCNORETURN G_StopMetalRecording(boolean kill);
void G_StopDemo(void);
boolean G_CheckDemoStatus(void);
diff --git a/src/g_input.c b/src/g_input.c
index 45c517e1a634740caf8a25accf5facc93df35227..afefbcc3b7629ea03ad57e58522d9a39f41c219b 100644
--- a/src/g_input.c
+++ b/src/g_input.c
@@ -709,8 +709,8 @@ void G_DefineDefaultControls(void)
for (i = 1; i < num_gamecontrolschemes; i++) // skip gcs_custom (0)
{
- gamecontroldefault[i][gc_weaponnext ][0] = 'e';
- gamecontroldefault[i][gc_weaponprev ][0] = 'q';
+ gamecontroldefault[i][gc_weaponnext ][0] = KEY_MOUSEWHEELUP+0;
+ gamecontroldefault[i][gc_weaponprev ][0] = KEY_MOUSEWHEELDOWN+0;
gamecontroldefault[i][gc_wepslot1 ][0] = '1';
gamecontroldefault[i][gc_wepslot2 ][0] = '2';
gamecontroldefault[i][gc_wepslot3 ][0] = '3';
diff --git a/src/hardware/hw_bsp.c b/src/hardware/hw_bsp.c
index 00bc706789f161277bbdffe39970fbdff0d3f15c..f8d4f43d9b285197c3b43743eb5bfdd83e0ce4be 100644
--- a/src/hardware/hw_bsp.c
+++ b/src/hardware/hw_bsp.c
@@ -201,7 +201,7 @@ static polyvertex_t *fracdivline(fdivline_t *bsp, polyvertex_t *v1,
// (do not accept hit with the extensions)
num = (v2x - v1x)*v2dy + (v1y - v2y)*v2dx;
frac = num / den;
- if (frac < 0.0 || frac > 1.0)
+ if (frac < 0.0l || frac > 1.0l)
return NULL;
// now get the frac along the BSP line
diff --git a/src/hardware/hw_cache.c b/src/hardware/hw_cache.c
index a1f4ed2cc60dae809e3b819a9f8c6b620c62e1e9..f8cdf4aa7c432488c9935c0561d1f586604cdcaa 100644
--- a/src/hardware/hw_cache.c
+++ b/src/hardware/hw_cache.c
@@ -505,43 +505,6 @@ static void HWR_ResizeBlock(INT32 originalwidth, INT32 originalheight,
if (blockheight < 1)
I_Error("3D GenerateTexture : too small");
}
- else if (cv_voodoocompatibility.value)
- {
- if (originalwidth > 256 || originalheight > 256)
- {
- blockwidth = 256;
- while (originalwidth < blockwidth)
- blockwidth >>= 1;
- if (blockwidth < 1)
- I_Error("3D GenerateTexture : too small");
-
- blockheight = 256;
- while (originalheight < blockheight)
- blockheight >>= 1;
- if (blockheight < 1)
- I_Error("3D GenerateTexture : too small");
- }
- else
- {
- //size up to nearest power of 2
- blockwidth = 1;
- while (blockwidth < originalwidth)
- blockwidth <<= 1;
- // scale down the original graphics to fit in 256
- if (blockwidth > 256)
- blockwidth = 256;
- //I_Error("3D GenerateTexture : too big");
-
- //size up to nearest power of 2
- blockheight = 1;
- while (blockheight < originalheight)
- blockheight <<= 1;
- // scale down the original graphics to fit in 256
- if (blockheight > 256)
- blockheight = 255;
- //I_Error("3D GenerateTexture : too big");
- }
- }
else
{
#ifdef GLIDE_API_COMPATIBILITY
@@ -690,7 +653,9 @@ static void HWR_GenerateTexture(INT32 texnum, GLTexture_t *grtex)
// Composite the columns together.
for (i = 0, patch = texture->patches; i < texture->patchcount; i++, patch++)
{
+#ifndef NO_PNG_LUMPS
size_t lumplength = W_LumpLengthPwad(patch->wad, patch->lump);
+#endif
realpatch = W_CacheLumpNumPwad(patch->wad, patch->lump, PU_CACHE);
#ifndef NO_PNG_LUMPS
if (R_IsLumpPNG((UINT8 *)realpatch, lumplength))
@@ -768,18 +733,6 @@ void HWR_MakePatch (const patch_t *patch, GLPatch_t *grPatch, GLMipmap_t *grMipm
newwidth = blockwidth;
newheight = blockheight;
}
- else if (cv_voodoocompatibility.value) // Only scales down textures that exceed 256x256.
- {
- // no rounddown, do not size up patches, so they don't look 'scaled'
- newwidth = min(grPatch->width, blockwidth);
- newheight = min(grPatch->height, blockheight);
-
- if (newwidth > 256 || newheight > 256)
- {
- newwidth = blockwidth;
- newheight = blockheight;
- }
- }
else
{
// no rounddown, do not size up patches, so they don't look 'scaled'
@@ -821,10 +774,10 @@ static void FreeMipmapColormap(INT32 patchnum, void *patch)
{
GLPatch_t* const grpatch = patch;
(void)patchnum; //unused
- while (grpatch->mipmap.nextcolormap)
+ while (grpatch->mipmap->nextcolormap)
{
- GLMipmap_t *grmip = grpatch->mipmap.nextcolormap;
- grpatch->mipmap.nextcolormap = grmip->nextcolormap;
+ GLMipmap_t *grmip = grpatch->mipmap->nextcolormap;
+ grpatch->mipmap->nextcolormap = grmip->nextcolormap;
if (grmip->grInfo.data) Z_Free(grmip->grInfo.data);
free(grmip);
}
@@ -927,29 +880,6 @@ GLTexture_t *HWR_GetTexture(INT32 tex)
return grtex;
}
-// HWR_RenderPlane and HWR_RenderPolyObjectPlane need this to get the flat dimensions from a patch.
-lumpnum_t gr_patchflat;
-
-static void HWR_LoadPatchFlat(GLMipmap_t *grMipmap, lumpnum_t flatlumpnum)
-{
- UINT8 *flat;
- patch_t *patch = (patch_t *)W_CacheLumpNum(flatlumpnum, PU_STATIC);
- size_t lumplength = W_LumpLength(flatlumpnum);
-
-#ifndef NO_PNG_LUMPS
- if (R_IsLumpPNG((UINT8 *)patch, lumplength))
- patch = R_PNGToPatch((UINT8 *)patch, lumplength, NULL, false);
-#endif
-
- grMipmap->width = (UINT16)SHORT(patch->width);
- grMipmap->height = (UINT16)SHORT(patch->height);
-
- flat = Z_Malloc(grMipmap->width * grMipmap->height, PU_HWRCACHE, &grMipmap->grInfo.data);
- memset(flat, TRANSPARENTPIXEL, grMipmap->width * grMipmap->height);
-
- R_PatchToFlat(patch, flat);
-}
-
static void HWR_CacheFlat(GLMipmap_t *grMipmap, lumpnum_t flatlumpnum)
{
size_t size, pflatsize;
@@ -990,46 +920,21 @@ static void HWR_CacheFlat(GLMipmap_t *grMipmap, lumpnum_t flatlumpnum)
break;
}
- if (R_CheckIfPatch(flatlumpnum))
- HWR_LoadPatchFlat(grMipmap, flatlumpnum);
- else
- {
- grMipmap->width = (UINT16)pflatsize;
- grMipmap->height = (UINT16)pflatsize;
+ grMipmap->width = (UINT16)pflatsize;
+ grMipmap->height = (UINT16)pflatsize;
- // the flat raw data needn't be converted with palettized textures
- W_ReadLump(flatlumpnum, Z_Malloc(W_LumpLength(flatlumpnum),
- PU_HWRCACHE, &grMipmap->grInfo.data));
- }
+ // the flat raw data needn't be converted with palettized textures
+ W_ReadLump(flatlumpnum, Z_Malloc(W_LumpLength(flatlumpnum),
+ PU_HWRCACHE, &grMipmap->grInfo.data));
}
-// Download a Doom 'flat' to the hardware cache and make it ready for use
-void HWR_GetFlat(lumpnum_t flatlumpnum)
+static void HWR_CacheTextureAsFlat(GLMipmap_t *grMipmap, INT32 texturenum)
{
- GLMipmap_t *grmip;
+ UINT8 *flat;
if (needpatchflush)
W_FlushCachedPatches();
- grmip = &HWR_GetCachedGLPatch(flatlumpnum)->mipmap;
-
- if (!grmip->downloaded && !grmip->grInfo.data)
- HWR_CacheFlat(grmip, flatlumpnum);
-
- HWD.pfnSetTexture(grmip);
-
- // The system-memory data can be purged now.
- Z_ChangeTag(grmip->grInfo.data, PU_HWRCACHE_UNLOCKED);
-
- gr_patchflat = 0;
- if (R_CheckIfPatch(flatlumpnum))
- gr_patchflat = flatlumpnum;
-}
-
-static void HWR_LoadTextureFlat(GLMipmap_t *grMipmap, INT32 texturenum)
-{
- UINT8 *flat;
-
// setup the texture info
#ifdef GLIDE_API_COMPATIBILITY
grMipmap->grInfo.smallLodLog2 = GR_LOD_LOG2_64;
@@ -1048,24 +953,56 @@ static void HWR_LoadTextureFlat(GLMipmap_t *grMipmap, INT32 texturenum)
R_TextureToFlat(texturenum, flat);
}
-void HWR_GetTextureFlat(INT32 texturenum)
+// Download a Doom 'flat' to the hardware cache and make it ready for use
+void HWR_LiterallyGetFlat(lumpnum_t flatlumpnum)
{
- GLTexture_t *grtex;
-#ifdef PARANOIA
- if ((unsigned)texturenum >= gr_numtextures)
- I_Error("HWR_GetTextureFlat: texturenum >= numtextures\n");
-#endif
- if (texturenum == 0 || texturenum == -1)
+ GLMipmap_t *grmip;
+ if (flatlumpnum == LUMPERROR)
return;
- grtex = &gr_textures2[texturenum];
- if (!grtex->mipmap.grInfo.data && !grtex->mipmap.downloaded)
- HWR_LoadTextureFlat(&grtex->mipmap, texturenum);
+ if (needpatchflush)
+ W_FlushCachedPatches();
- HWD.pfnSetTexture(&grtex->mipmap);
+ grmip = HWR_GetCachedGLPatch(flatlumpnum)->mipmap;
+ if (!grmip->downloaded && !grmip->grInfo.data)
+ HWR_CacheFlat(grmip, flatlumpnum);
+
+ HWD.pfnSetTexture(grmip);
// The system-memory data can be purged now.
- Z_ChangeTag(grtex->mipmap.grInfo.data, PU_HWRCACHE_UNLOCKED);
+ Z_ChangeTag(grmip->grInfo.data, PU_HWRCACHE_UNLOCKED);
+}
+
+void HWR_GetLevelFlat(levelflat_t *levelflat)
+{
+ // Who knows?
+ if (levelflat == NULL)
+ return;
+
+ if (levelflat->type == LEVELFLAT_FLAT)
+ HWR_LiterallyGetFlat(levelflat->u.flat.lumpnum);
+ else if (levelflat->type == LEVELFLAT_TEXTURE)
+ {
+ GLTexture_t *grtex;
+ INT32 texturenum = levelflat->u.texture.num;
+#ifdef PARANOIA
+ if ((unsigned)texturenum >= gr_numtextures)
+ I_Error("HWR_GetLevelFlat: texturenum >= numtextures\n");
+#endif
+ if (texturenum == 0 || texturenum == -1)
+ return;
+ grtex = &gr_textures2[texturenum];
+
+ if (!grtex->mipmap.grInfo.data && !grtex->mipmap.downloaded)
+ HWR_CacheTextureAsFlat(&grtex->mipmap, texturenum);
+
+ HWD.pfnSetTexture(&grtex->mipmap);
+
+ // The system-memory data can be purged now.
+ Z_ChangeTag(grtex->mipmap.grInfo.data, PU_HWRCACHE_UNLOCKED);
+ }
+ else // set no texture
+ HWD.pfnSetTexture(NULL);
}
//
@@ -1097,22 +1034,22 @@ void HWR_GetPatch(GLPatch_t *gpatch)
W_FlushCachedPatches();
// is it in hardware cache
- if (!gpatch->mipmap.downloaded && !gpatch->mipmap.grInfo.data)
+ if (!gpatch->mipmap->downloaded && !gpatch->mipmap->grInfo.data)
{
// load the software patch, PU_STATIC or the Z_Malloc for hardware patch will
// flush the software patch before the conversion! oh yeah I suffered
patch_t *ptr = W_CacheLumpNumPwad(gpatch->wadnum, gpatch->lumpnum, PU_STATIC);
- HWR_MakePatch(ptr, gpatch, &gpatch->mipmap, true);
+ HWR_MakePatch(ptr, gpatch, gpatch->mipmap, true);
// this is inefficient.. but the hardware patch in heap is purgeable so it should
// not fragment memory, and besides the REAL cache here is the hardware memory
Z_Free(ptr);
}
- HWD.pfnSetTexture(&gpatch->mipmap);
+ HWD.pfnSetTexture(gpatch->mipmap);
// The system-memory patch data can be purged now.
- Z_ChangeTag(gpatch->mipmap.grInfo.data, PU_HWRCACHE_UNLOCKED);
+ Z_ChangeTag(gpatch->mipmap->grInfo.data, PU_HWRCACHE_UNLOCKED);
}
@@ -1135,7 +1072,7 @@ void HWR_GetMappedPatch(GLPatch_t *gpatch, const UINT8 *colormap)
// search for the mimmap
// skip the first (no colormap translated)
- for (grmip = &gpatch->mipmap; grmip->nextcolormap; )
+ for (grmip = gpatch->mipmap; grmip->nextcolormap; )
{
grmip = grmip->nextcolormap;
if (grmip->colormap == colormap)
@@ -1165,7 +1102,7 @@ void HWR_UnlockCachedPatch(GLPatch_t *gpatch)
if (!gpatch)
return;
- Z_ChangeTag(gpatch->mipmap.grInfo.data, PU_HWRCACHE_UNLOCKED);
+ Z_ChangeTag(gpatch->mipmap->grInfo.data, PU_HWRCACHE_UNLOCKED);
Z_ChangeTag(gpatch, PU_HWRPATCHINFO_UNLOCKED);
}
@@ -1256,7 +1193,7 @@ GLPatch_t *HWR_GetPic(lumpnum_t lumpnum)
grpatch = HWR_GetCachedGLPatch(lumpnum);
- if (!grpatch->mipmap.downloaded && !grpatch->mipmap.grInfo.data)
+ if (!grpatch->mipmap->downloaded && !grpatch->mipmap->grInfo.data)
{
pic_t *pic;
UINT8 *block;
@@ -1272,19 +1209,19 @@ GLPatch_t *HWR_GetPic(lumpnum_t lumpnum)
grpatch->topoffset = 0;
// find the good 3dfx size (boring spec)
- HWR_ResizeBlock (grpatch->width, grpatch->height, &grpatch->mipmap.grInfo);
- grpatch->mipmap.width = (UINT16)blockwidth;
- grpatch->mipmap.height = (UINT16)blockheight;
+ HWR_ResizeBlock (grpatch->width, grpatch->height, &grpatch->mipmap->grInfo);
+ grpatch->mipmap->width = (UINT16)blockwidth;
+ grpatch->mipmap->height = (UINT16)blockheight;
if (pic->mode == PALETTE)
- grpatch->mipmap.grInfo.format = textureformat; // can be set by driver
+ grpatch->mipmap->grInfo.format = textureformat; // can be set by driver
else
- grpatch->mipmap.grInfo.format = picmode2GR[pic->mode];
+ grpatch->mipmap->grInfo.format = picmode2GR[pic->mode];
- Z_Free(grpatch->mipmap.grInfo.data);
+ Z_Free(grpatch->mipmap->grInfo.data);
// allocate block
- block = MakeBlock(&grpatch->mipmap);
+ block = MakeBlock(grpatch->mipmap);
// if rounddown, rounddown patches as well as textures
if (cv_grrounddown.value)
@@ -1292,18 +1229,6 @@ GLPatch_t *HWR_GetPic(lumpnum_t lumpnum)
newwidth = blockwidth;
newheight = blockheight;
}
- else if (cv_voodoocompatibility.value) // Only scales down textures that exceed 256x256.
- {
- // no rounddown, do not size up patches, so they don't look 'scaled'
- newwidth = min(SHORT(pic->width),blockwidth);
- newheight = min(SHORT(pic->height),blockheight);
-
- if (newwidth > 256 || newheight > 256)
- {
- newwidth = blockwidth;
- newheight = blockheight;
- }
- }
else
{
// no rounddown, do not size up patches, so they don't look 'scaled'
@@ -1314,25 +1239,25 @@ GLPatch_t *HWR_GetPic(lumpnum_t lumpnum)
if (grpatch->width == blockwidth &&
grpatch->height == blockheight &&
- format2bpp[grpatch->mipmap.grInfo.format] == format2bpp[picmode2GR[pic->mode]])
+ format2bpp[grpatch->mipmap->grInfo.format] == format2bpp[picmode2GR[pic->mode]])
{
// no conversion needed
- M_Memcpy(grpatch->mipmap.grInfo.data, pic->data,len);
+ M_Memcpy(grpatch->mipmap->grInfo.data, pic->data,len);
}
else
HWR_DrawPicInCache(block, newwidth, newheight,
- blockwidth*format2bpp[grpatch->mipmap.grInfo.format],
+ blockwidth*format2bpp[grpatch->mipmap->grInfo.format],
pic,
- format2bpp[grpatch->mipmap.grInfo.format]);
+ format2bpp[grpatch->mipmap->grInfo.format]);
Z_Unlock(pic);
Z_ChangeTag(block, PU_HWRCACHE_UNLOCKED);
- grpatch->mipmap.flags = 0;
+ grpatch->mipmap->flags = 0;
grpatch->max_s = (float)newwidth / (float)blockwidth;
grpatch->max_t = (float)newheight / (float)blockheight;
}
- HWD.pfnSetTexture(&grpatch->mipmap);
+ HWD.pfnSetTexture(grpatch->mipmap);
//CONS_Debug(DBG_RENDER, "picloaded at %x as texture %d\n",grpatch->mipmap.grInfo.data, grpatch->mipmap.downloaded);
return grpatch;
@@ -1348,6 +1273,7 @@ GLPatch_t *HWR_GetCachedGLPatchPwad(UINT16 wadnum, UINT16 lumpnum)
grpatch = Z_Calloc(sizeof(GLPatch_t), PU_HWRPATCHINFO, NULL);
grpatch->wadnum = wadnum;
grpatch->lumpnum = lumpnum;
+ grpatch->mipmap = Z_Calloc(sizeof(GLMipmap_t), PU_HWRPATCHINFO, NULL);
M_AATreeSet(hwrcache, lumpnum, grpatch);
}
@@ -1454,7 +1380,7 @@ void HWR_GetFadeMask(lumpnum_t fademasklumpnum)
if (needpatchflush)
W_FlushCachedPatches();
- grmip = &HWR_GetCachedGLPatch(fademasklumpnum)->mipmap;
+ grmip = HWR_GetCachedGLPatch(fademasklumpnum)->mipmap;
if (!grmip->downloaded && !grmip->grInfo.data)
HWR_CacheFadeMask(grmip, fademasklumpnum);
diff --git a/src/hardware/hw_clip.c b/src/hardware/hw_clip.c
index 6d120efe72c4ca251b61dfa5c68be1b206719d31..4bdc753ec870e750c1f9fc3768d46defbc0a788a 100644
--- a/src/hardware/hw_clip.c
+++ b/src/hardware/hw_clip.c
@@ -77,8 +77,8 @@
#include "r_opengl/r_opengl.h"
#ifdef HAVE_SPHEREFRUSTRUM
-static GLdouble viewMatrix[16];
-static GLdouble projMatrix[16];
+static GLfloat viewMatrix[16];
+static GLfloat projMatrix[16];
float frustum[6][4];
#endif
@@ -380,8 +380,8 @@ void gld_FrustrumSetup(void)
float t;
float clip[16];
- pglGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
- pglGetDoublev(GL_MODELVIEW_MATRIX, viewMatrix);
+ pglGeFloatv(GL_PROJECTION_MATRIX, projMatrix);
+ pglGetFloatv(GL_MODELVIEW_MATRIX, viewMatrix);
clip[0] = CALCMATRIX(0, 0, 1, 4, 2, 8, 3, 12);
clip[1] = CALCMATRIX(0, 1, 1, 5, 2, 9, 3, 13);
diff --git a/src/hardware/hw_data.h b/src/hardware/hw_data.h
index 44929dd67ba00267173afde6f4fa55a50440c107..629861c23309b6bfd6db289cc0b6ad80ce88b8d2 100644
--- a/src/hardware/hw_data.h
+++ b/src/hardware/hw_data.h
@@ -83,8 +83,8 @@ struct GLPatch_s
float max_s,max_t;
UINT16 wadnum; // the software patch lump num for when the hardware patch
UINT16 lumpnum; // was flushed, and we need to re-create it
- GLMipmap_t mipmap;
-};
+ GLMipmap_t *mipmap;
+} ATTRPACK;
typedef struct GLPatch_s GLPatch_t;
#endif //_HWR_DATA_
diff --git a/src/hardware/hw_defs.h b/src/hardware/hw_defs.h
index 5dcead77cb9c59ed4d192feadf64ecde878802ad..83d601b8745e979003ea7ac8832dafdb7527fae9 100644
--- a/src/hardware/hw_defs.h
+++ b/src/hardware/hw_defs.h
@@ -95,14 +95,29 @@ typedef struct
//Hurdler: Transform (coords + angles)
//BP: transform order : scale(rotation_x(rotation_y(translation(v))))
+
+// Kart features
+//#define USE_FTRANSFORM_ANGLEZ
+//#define USE_FTRANSFORM_MIRROR
+
+// Vanilla features
+#define USE_MODEL_NEXTFRAME
+
typedef struct
{
FLOAT x,y,z; // position
+#ifdef USE_FTRANSFORM_ANGLEZ
+ FLOAT anglex,angley,anglez; // aimingangle / viewangle
+#else
FLOAT anglex,angley; // aimingangle / viewangle
+#endif
FLOAT scalex,scaley,scalez;
FLOAT fovxangle, fovyangle;
- INT32 splitscreen;
+ UINT8 splitscreen;
boolean flip; // screenflip
+#ifdef USE_FTRANSFORM_MIRROR
+ boolean mirror; // SRB2Kart: Encore Mode
+#endif
} FTransform;
// Transformed vector, as passed to HWR API
@@ -145,7 +160,7 @@ enum EPolyFlags
// When set, pass the color constant into the FSurfaceInfo -> FlatColor
PF_NoTexture = 0x00002000, // Use the small white texture
PF_Corona = 0x00004000, // Tell the rendrer we are drawing a corona
- PF_MD2 = 0x00008000, // Tell the rendrer we are drawing an MD2
+ PF_Unused = 0x00008000, // Unused
PF_RemoveYWrap = 0x00010000, // Force clamp texture on Y
PF_ForceWrapX = 0x00020000, // Force repeat texture on X
PF_ForceWrapY = 0x00040000, // Force repeat texture on Y
@@ -203,8 +218,6 @@ enum hwdsetspecialstate
HWD_SET_FOG_COLOR,
HWD_SET_FOG_DENSITY,
HWD_SET_FOV,
- HWD_SET_POLYGON_SMOOTH,
- HWD_SET_PALETTECOLOR,
HWD_SET_TEXTUREFILTERMODE,
HWD_SET_TEXTUREANISOTROPICMODE,
HWD_NUMSTATE
diff --git a/src/hardware/hw_dll.h b/src/hardware/hw_dll.h
index 452e9037c2dab8f14bf1798113a22b87f3f95049..3fa5852d88d844060f6a3601e148d1a540461493 100644
--- a/src/hardware/hw_dll.h
+++ b/src/hardware/hw_dll.h
@@ -61,9 +61,6 @@ typedef void (*I_Error_t) (const char *error, ...) FUNCIERROR;
// ==========================================================================
// Constants
-#ifndef M_PIl
-#define M_PIl 3.1415926535897932384626433832795029L
-#endif
#define DEGREE (0.017453292519943295769236907684883l) // 2*PI/360
void DBG_Printf(const char *lpFmt, ...) /*FUNCPRINTF*/;
diff --git a/src/hardware/hw_draw.c b/src/hardware/hw_draw.c
index ea3183aa1a01b3577e46ccc96f12f1462439c027..809effb5ba702d25a8750edd64fe891a1607a289 100644
--- a/src/hardware/hw_draw.c
+++ b/src/hardware/hw_draw.c
@@ -647,7 +647,7 @@ void HWR_DrawFlatFill (INT32 x, INT32 y, INT32 w, INT32 h, lumpnum_t flatlumpnum
v[0].tow = v[1].tow = (float)((y & flatflag)/dflatsize);
v[2].tow = v[3].tow = (float)(v[0].tow + h/dflatsize);
- HWR_GetFlat(flatlumpnum);
+ HWR_LiterallyGetFlat(flatlumpnum);
//Hurdler: Boris, the same comment as above... but maybe for pics
// it not a problem since they don't have any transparent pixel
diff --git a/src/hardware/hw_drv.h b/src/hardware/hw_drv.h
index e2fa90eb035de94d0b5ad7d81de624ed0fbe4341..aed1611f111176ba0ab9c907362e154421894825 100644
--- a/src/hardware/hw_drv.h
+++ b/src/hardware/hw_drv.h
@@ -47,6 +47,7 @@ EXPORT void HWRAPI(SetPalette) (RGBA_t *ppal, RGBA_t *pgamma);
EXPORT void HWRAPI(FinishUpdate) (INT32 waitvbl);
EXPORT void HWRAPI(Draw2DLine) (F2DCoord *v1, F2DCoord *v2, RGBA_t Color);
EXPORT void HWRAPI(DrawPolygon) (FSurfaceInfo *pSurf, FOutVector *pOutVerts, FUINT iNumPts, FBITFIELD PolyFlags);
+EXPORT void HWRAPI(RenderSkyDome) (INT32 tex, INT32 texture_width, INT32 texture_height, FTransform transform);
EXPORT void HWRAPI(SetBlend) (FBITFIELD PolyFlags);
EXPORT void HWRAPI(ClearBuffer) (FBOOLEAN ColorMask, FBOOLEAN DepthMask, FRGBAFloat *ClearColor);
EXPORT void HWRAPI(SetTexture) (FTextureInfo *TexInfo);
@@ -58,20 +59,18 @@ EXPORT void HWRAPI(ClearMipMapCache) (void);
EXPORT void HWRAPI(SetSpecialState) (hwdspecialstate_t IdState, INT32 Value);
//Hurdler: added for new development
-EXPORT void HWRAPI(DrawMD2) (INT32 *gl_cmd_buffer, md2_frame_t *frame, FTransform *pos, float scale);
-EXPORT void HWRAPI(DrawMD2i) (INT32 *gl_cmd_buffer, md2_frame_t *frame, INT32 duration, INT32 tics, md2_frame_t *nextframe, FTransform *pos, float scale, UINT8 flipped, UINT8 *color);
+EXPORT void HWRAPI(DrawModel) (model_t *model, INT32 frameIndex, INT32 duration, INT32 tics, INT32 nextFrameIndex, FTransform *pos, float scale, UINT8 flipped, UINT8 *color);
+EXPORT void HWRAPI(CreateModelVBOs) (model_t *model);
EXPORT void HWRAPI(SetTransform) (FTransform *ptransform);
EXPORT INT32 HWRAPI(GetTextureUsed) (void);
EXPORT INT32 HWRAPI(GetRenderVersion) (void);
-#ifdef SHUFFLE
#define SCREENVERTS 10
EXPORT void HWRAPI(PostImgRedraw) (float points[SCREENVERTS][SCREENVERTS][2]);
-#endif
EXPORT void HWRAPI(FlushScreenTextures) (void);
EXPORT void HWRAPI(StartScreenWipe) (void);
EXPORT void HWRAPI(EndScreenWipe) (void);
-EXPORT void HWRAPI(DoScreenWipe) (float alpha);
+EXPORT void HWRAPI(DoScreenWipe) (void);
EXPORT void HWRAPI(DrawIntermissionBG) (void);
EXPORT void HWRAPI(MakeScreenTexture) (void);
EXPORT void HWRAPI(MakeScreenFinalTexture) (void);
@@ -89,6 +88,7 @@ struct hwdriver_s
FinishUpdate pfnFinishUpdate;
Draw2DLine pfnDraw2DLine;
DrawPolygon pfnDrawPolygon;
+ RenderSkyDome pfnRenderSkyDome;
SetBlend pfnSetBlend;
ClearBuffer pfnClearBuffer;
SetTexture pfnSetTexture;
@@ -96,8 +96,8 @@ struct hwdriver_s
GClipRect pfnGClipRect;
ClearMipMapCache pfnClearMipMapCache;
SetSpecialState pfnSetSpecialState;//Hurdler: added for backward compatibility
- DrawMD2 pfnDrawMD2;
- DrawMD2i pfnDrawMD2i;
+ DrawModel pfnDrawModel;
+ CreateModelVBOs pfnCreateModelVBOs;
SetTransform pfnSetTransform;
GetTextureUsed pfnGetTextureUsed;
GetRenderVersion pfnGetRenderVersion;
@@ -107,9 +107,7 @@ struct hwdriver_s
#ifndef HAVE_SDL
Shutdown pfnShutdown;
#endif
-#ifdef SHUFFLE
PostImgRedraw pfnPostImgRedraw;
-#endif
FlushScreenTextures pfnFlushScreenTextures;
StartScreenWipe pfnStartScreenWipe;
EndScreenWipe pfnEndScreenWipe;
diff --git a/src/hardware/hw_glob.h b/src/hardware/hw_glob.h
index 2701a01b7c325796f5c1e89c017b8b0d32023127..c6fce9ebd9ec0338945806f3ab0cacc992bf1d5c 100644
--- a/src/hardware/hw_glob.h
+++ b/src/hardware/hw_glob.h
@@ -23,6 +23,7 @@
#include "hw_defs.h"
#include "hw_main.h"
#include "../m_misc.h"
+#include "../p_setup.h"
// the original aspect ratio of Doom graphics isn't square
#define ORIGINAL_ASPECT (320.0f/200.0f)
@@ -101,8 +102,8 @@ void HWR_FreeTextureCache(void);
void HWR_FreeColormaps(void);
void HWR_FreeExtraSubsectors(void);
-void HWR_GetFlat(lumpnum_t flatlumpnum);
-void HWR_GetTextureFlat(INT32 texturenum);
+void HWR_GetLevelFlat(levelflat_t *levelflat);
+void HWR_LiterallyGetFlat(lumpnum_t flatlumpnum);
GLTexture_t *HWR_GetTexture(INT32 tex);
void HWR_GetPatch(GLPatch_t *gpatch);
void HWR_GetMappedPatch(GLPatch_t *gpatch, const UINT8 *colormap);
@@ -116,8 +117,6 @@ void HWR_GetFadeMask(lumpnum_t fademasklumpnum);
// --------
// hw_draw.c
// --------
-extern lumpnum_t gr_patchflat;
-
extern float gr_patch_scalex;
extern float gr_patch_scaley;
diff --git a/src/hardware/hw_light.c b/src/hardware/hw_light.c
index b613fdae1d641de30d762d0e0e7f1d8dc38d7ce9..491cb739f999a82c8013c68fcbe45e7ad3798568 100644
--- a/src/hardware/hw_light.c
+++ b/src/hardware/hw_light.c
@@ -162,6 +162,8 @@ light_t *t_lspr[NUMSPRITES] =
&lspr[NOLIGHT], // SPR_TURR
&lspr[NOLIGHT], // SPR_SHRP
&lspr[NOLIGHT], // SPR_CRAB
+ &lspr[NOLIGHT], // SPR_CR2B
+ &lspr[NOLIGHT], // SPR_CSPR
&lspr[NOLIGHT], // SPR_JJAW
&lspr[NOLIGHT], // SPR_SNLR
&lspr[NOLIGHT], // SPR_VLTR
@@ -180,6 +182,8 @@ light_t *t_lspr[NUMSPRITES] =
&lspr[NOLIGHT], // SPR_UNID
&lspr[NOLIGHT], // SPR_CANA
&lspr[NOLIGHT], // SPR_CANG
+ &lspr[NOLIGHT], // SPR_PYRE
+ &lspr[NOLIGHT], // SPR_PTER
// Generic Boos Items
&lspr[JETLIGHT_L], // SPR_JETF // Boss jet fumes
@@ -197,7 +201,7 @@ light_t *t_lspr[NUMSPRITES] =
&lspr[NOLIGHT], // SPR_EGGO
&lspr[NOLIGHT], // SPR_SEBH
&lspr[NOLIGHT], // SPR_FAKE
- &lspr[NOLIGHT], // SPR_SHCK
+ &lspr[LBLUESHINE_L],// SPR_SHCK
// Boss 4 (Castle Eggman)
&lspr[NOLIGHT], // SPR_EGGP
@@ -260,6 +264,7 @@ light_t *t_lspr[NUMSPRITES] =
&lspr[NOLIGHT], // SPR_WSPB
&lspr[NOLIGHT], // SPR_STPT
&lspr[NOLIGHT], // SPR_BMNE
+ &lspr[NOLIGHT], // SPR_PUMI
// Monitor Boxes
&lspr[NOLIGHT], // SPR_MSTV
@@ -377,6 +382,10 @@ light_t *t_lspr[NUMSPRITES] =
// Red Volcano Scenery
&lspr[REDBALL_L], // SPR_FLME
&lspr[REDBALL_L], // SPR_DFLM
+ &lspr[NOLIGHT], // SPR_LFAL
+ &lspr[NOLIGHT], // SPR_JPLA
+ &lspr[NOLIGHT], // SPR_TFLO
+ &lspr[NOLIGHT], // SPR_WVIN
// Dark City Scenery
@@ -388,7 +397,9 @@ light_t *t_lspr[NUMSPRITES] =
&lspr[NOLIGHT], // SPR_XMS3
&lspr[NOLIGHT], // SPR_XMS4
&lspr[NOLIGHT], // SPR_XMS5
+ &lspr[NOLIGHT], // SPR_XMS6
&lspr[NOLIGHT], // SPR_FHZI
+ &lspr[NOLIGHT], // SPR_ROSY
// Halloween Scenery
&lspr[RINGLIGHT_L], // SPR_PUMK
@@ -396,6 +407,11 @@ light_t *t_lspr[NUMSPRITES] =
&lspr[NOLIGHT], // SPR_SHRM
&lspr[NOLIGHT], // SPR_HHZM
+ // Azure Temple Scenery
+ &lspr[NOLIGHT], // SPR_BGAR
+ &lspr[NOLIGHT], // SPR_RCRY
+ &lspr[GREENBALL_L], // SPR_CFLM
+
// Botanic Serenity Scenery
&lspr[NOLIGHT], // SPR_BSZ1
&lspr[NOLIGHT], // SPR_BSZ2
@@ -415,7 +431,6 @@ light_t *t_lspr[NUMSPRITES] =
// Misc Scenery
&lspr[NOLIGHT], // SPR_STLG
&lspr[NOLIGHT], // SPR_DBAL
- &lspr[NOLIGHT], // SPR_RCRY
// Powerup Indicators
&lspr[NOLIGHT], // SPR_ARMA
@@ -469,11 +484,14 @@ light_t *t_lspr[NUMSPRITES] =
&lspr[NOLIGHT], // SPR_SSWY
&lspr[NOLIGHT], // SPR_SSWR
&lspr[NOLIGHT], // SPR_SSWB
+ &lspr[NOLIGHT], // SPR_BSTY
+ &lspr[NOLIGHT], // SPR_BSTR
// Environmental Effects
&lspr[NOLIGHT], // SPR_RAIN
&lspr[NOLIGHT], // SPR_SNO1
&lspr[NOLIGHT], // SPR_SPLH
+ &lspr[NOLIGHT], // SPR_LSPL
&lspr[NOLIGHT], // SPR_SPLA
&lspr[NOLIGHT], // SPR_SMOK
&lspr[NOLIGHT], // SPR_BUBL
@@ -1187,7 +1205,8 @@ void HWR_DL_AddLight(gr_vissprite_t *spr, GLPatch_t *patch)
dynlights->nb++;
}
-static GLPatch_t lightmappatch;
+static GLMipmap_t lightmappatchmipmap;
+static GLPatch_t lightmappatch = { .mipmap = &lightmappatchmipmap };
void HWR_InitLight(void)
{
@@ -1197,7 +1216,7 @@ void HWR_InitLight(void)
for (i = 0;i < NUMLIGHTS;i++)
lspr[i].dynamic_sqrradius = lspr[i].dynamic_radius*lspr[i].dynamic_radius;
- lightmappatch.mipmap.downloaded = false;
+ lightmappatch.mipmap->downloaded = false;
coronalumpnum = W_CheckNumForName("CORONA");
}
@@ -1208,10 +1227,10 @@ static void HWR_SetLight(void)
{
int i, j;
- if (!lightmappatch.mipmap.downloaded && !lightmappatch.mipmap.grInfo.data)
+ if (!lightmappatch.mipmap->downloaded && !lightmappatch.mipmap->grInfo.data)
{
- UINT16 *Data = Z_Malloc(129*128*sizeof (UINT16), PU_HWRCACHE, &lightmappatch.mipmap.grInfo.data);
+ UINT16 *Data = Z_Malloc(129*128*sizeof (UINT16), PU_HWRCACHE, &lightmappatch.mipmap->grInfo.data);
for (i = 0; i < 128; i++)
{
@@ -1224,23 +1243,23 @@ static void HWR_SetLight(void)
Data[i*128+j] = 0;
}
}
- lightmappatch.mipmap.grInfo.format = GR_TEXFMT_ALPHA_INTENSITY_88;
+ lightmappatch.mipmap->grInfo.format = GR_TEXFMT_ALPHA_INTENSITY_88;
lightmappatch.width = 128;
lightmappatch.height = 128;
- lightmappatch.mipmap.width = 128;
- lightmappatch.mipmap.height = 128;
+ lightmappatch.mipmap->width = 128;
+ lightmappatch.mipmap->height = 128;
#ifdef GLIDE_API_COMPATIBILITY
- lightmappatch.mipmap.grInfo.smallLodLog2 = GR_LOD_LOG2_128;
- lightmappatch.mipmap.grInfo.largeLodLog2 = GR_LOD_LOG2_128;
- lightmappatch.mipmap.grInfo.aspectRatioLog2 = GR_ASPECT_LOG2_1x1;
+ lightmappatch.mipmap->grInfo.smallLodLog2 = GR_LOD_LOG2_128;
+ lightmappatch.mipmap->grInfo.largeLodLog2 = GR_LOD_LOG2_128;
+ lightmappatch.mipmap->grInfo.aspectRatioLog2 = GR_ASPECT_LOG2_1x1;
#endif
- lightmappatch.mipmap.flags = 0; //TF_WRAPXY; // DEBUG: view the overdraw !
+ lightmappatch.mipmap->flags = 0; //TF_WRAPXY; // DEBUG: view the overdraw !
}
- HWD.pfnSetTexture(&lightmappatch.mipmap);
+ HWD.pfnSetTexture(lightmappatch.mipmap);
// The system-memory data can be purged now.
- Z_ChangeTag(lightmappatch.mipmap.grInfo.data, PU_HWRCACHE_UNLOCKED);
+ Z_ChangeTag(lightmappatch.mipmap->grInfo.data, PU_HWRCACHE_UNLOCKED);
}
//**********************************************************
diff --git a/src/hardware/hw_main.c b/src/hardware/hw_main.c
index 9b9ffe3c4ea023a60461ca4f2ac690b46f408fcc..238b29e2605e20221a7777fe2efa9fa45a4a40f8 100644
--- a/src/hardware/hw_main.c
+++ b/src/hardware/hw_main.c
@@ -70,12 +70,12 @@ static void HWR_ProjectPrecipitationSprite(precipmobj_t *thing);
#endif
#ifdef SORTING
-void HWR_AddTransparentFloor(lumpnum_t lumpnum, INT32 texturenum, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight,
+void HWR_AddTransparentFloor(levelflat_t *levelflat, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight,
INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap);
-void HWR_AddTransparentPolyobjectFloor(lumpnum_t lumpnum, INT32 texturenum, polyobj_t *polysector, boolean isceiling, fixed_t fixedheight,
+void HWR_AddTransparentPolyobjectFloor(levelflat_t *levelflat, polyobj_t *polysector, boolean isceiling, fixed_t fixedheight,
INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, extracolormap_t *planecolormap);
#else
-static void HWR_Add3DWater(lumpnum_t lumpnum, extrasubsector_t *xsub, fixed_t fixedheight,
+static void HWR_Add3DWater(levelflat_t *levelflat, extrasubsector_t *xsub, fixed_t fixedheight,
INT32 lightlevel, INT32 alpha, sector_t *FOFSector);
static void HWR_Render3DWater(void);
static void HWR_RenderTransparentWalls(void);
@@ -522,7 +522,7 @@ static UINT8 HWR_FogBlockAlpha(INT32 light, UINT32 color) // Let's see if this c
// HWR_RenderPlane : Render a floor or ceiling convex polygon
// -----------------+
static void HWR_RenderPlane(sector_t *sector, extrasubsector_t *xsub, boolean isceiling, fixed_t fixedheight,
- FBITFIELD PolyFlags, INT32 lightlevel, lumpnum_t lumpnum, INT32 texturenum, sector_t *FOFsector, UINT8 alpha, boolean fogplane, extracolormap_t *planecolormap)
+ FBITFIELD PolyFlags, INT32 lightlevel, levelflat_t *levelflat, sector_t *FOFsector, UINT8 alpha, boolean fogplane, extracolormap_t *planecolormap)
{
polyvertex_t * pv;
float height; //constant y for all points on the convex flat polygon
@@ -530,9 +530,9 @@ static void HWR_RenderPlane(sector_t *sector, extrasubsector_t *xsub, boolean is
INT32 nrPlaneVerts; //verts original define of convex flat polygon
INT32 i;
float flatxref,flatyref;
- float fflatwidth, fflatheight;
- INT32 flatflag;
- boolean texflat = true;
+ float fflatwidth = 64.0f, fflatheight = 64.0f;
+ INT32 flatflag = 63;
+ boolean texflat = false;
size_t len;
float scrollx = 0.0f, scrolly = 0.0f;
angle_t angle = 0;
@@ -541,7 +541,6 @@ static void HWR_RenderPlane(sector_t *sector, extrasubsector_t *xsub, boolean is
#ifdef ESLOPE
pslope_t *slope = NULL;
#endif
- patch_t *patch;
static FOutVector *planeVerts = NULL;
static UINT16 numAllocedPlaneVerts = 0;
@@ -597,48 +596,49 @@ static void HWR_RenderPlane(sector_t *sector, extrasubsector_t *xsub, boolean is
Z_Malloc(numAllocedPlaneVerts * sizeof (FOutVector), PU_LEVEL, &planeVerts);
}
- len = W_LumpLength(lumpnum);
-
- switch (len)
+ // set texture for polygon
+ if (levelflat != NULL)
{
- case 4194304: // 2048x2048 lump
- fflatwidth = fflatheight = 2048.0f;
- break;
- case 1048576: // 1024x1024 lump
- fflatwidth = fflatheight = 1024.0f;
- break;
- case 262144:// 512x512 lump
- fflatwidth = fflatheight = 512.0f;
- break;
- case 65536: // 256x256 lump
- fflatwidth = fflatheight = 256.0f;
- break;
- case 16384: // 128x128 lump
- fflatwidth = fflatheight = 128.0f;
- break;
- case 1024: // 32x32 lump
- fflatwidth = fflatheight = 32.0f;
- break;
- default: // 64x64 lump
- fflatwidth = fflatheight = 64.0f;
- break;
- }
+ if (levelflat->type == LEVELFLAT_TEXTURE)
+ {
+ fflatwidth = textures[levelflat->u.texture.num]->width;
+ fflatheight = textures[levelflat->u.texture.num]->height;
+ texflat = true;
+ }
+ else if (levelflat->type == LEVELFLAT_FLAT)
+ {
+ len = W_LumpLength(levelflat->u.flat.lumpnum);
- flatflag = ((INT32)fflatwidth)-1;
+ switch (len)
+ {
+ case 4194304: // 2048x2048 lump
+ fflatwidth = fflatheight = 2048.0f;
+ break;
+ case 1048576: // 1024x1024 lump
+ fflatwidth = fflatheight = 1024.0f;
+ break;
+ case 262144:// 512x512 lump
+ fflatwidth = fflatheight = 512.0f;
+ break;
+ case 65536: // 256x256 lump
+ fflatwidth = fflatheight = 256.0f;
+ break;
+ case 16384: // 128x128 lump
+ fflatwidth = fflatheight = 128.0f;
+ break;
+ case 1024: // 32x32 lump
+ fflatwidth = fflatheight = 32.0f;
+ break;
+ default: // 64x64 lump
+ fflatwidth = fflatheight = 64.0f;
+ break;
+ }
- if (texturenum != 0 && texturenum != -1)
- {
- fflatwidth = textures[texturenum]->width;
- fflatheight = textures[texturenum]->height;
- }
- else if (gr_patchflat && R_CheckIfPatch(gr_patchflat)) // Just in case?
- {
- patch = (patch_t *)W_CacheLumpNum(gr_patchflat, PU_STATIC);
- fflatwidth = SHORT(patch->width);
- fflatheight = SHORT(patch->height);
+ flatflag = ((INT32)fflatwidth)-1;
+ }
}
- else
- texflat = false;
+ else // set no texture
+ HWD.pfnSetTexture(NULL);
// reference point for flat texture coord for each vertex around the polygon
flatxref = (float)(((fixed_t)pv->x & (~flatflag)) / fflatwidth);
@@ -1972,7 +1972,7 @@ static void HWR_StoreWallRange(double startfrac, double endfrac)
{
// Single sided line... Deal only with the middletexture (if one exists)
gr_midtexture = R_GetTextureNum(gr_sidedef->midtexture);
- if (gr_midtexture)
+ if (gr_midtexture && gr_linedef->special != 41) // Ignore horizon line for OGL
{
{
fixed_t texturevpeg;
@@ -3183,23 +3183,22 @@ static inline void HWR_AddPolyObjectSegs(void)
#ifdef POLYOBJECTS_PLANES
static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling, fixed_t fixedheight,
- FBITFIELD blendmode, UINT8 lightlevel, lumpnum_t lumpnum, INT32 texturenum, sector_t *FOFsector,
+ FBITFIELD blendmode, UINT8 lightlevel, levelflat_t *levelflat, sector_t *FOFsector,
UINT8 alpha, extracolormap_t *planecolormap)
{
float height; //constant y for all points on the convex flat polygon
FOutVector *v3d;
INT32 i;
float flatxref,flatyref;
- float fflatwidth, fflatheight;
- INT32 flatflag;
- boolean texflat = true;
+ float fflatwidth = 64.0f, fflatheight = 64.0f;
+ INT32 flatflag = 63;
+ boolean texflat = false;
size_t len;
float scrollx = 0.0f, scrolly = 0.0f;
angle_t angle = 0;
FSurfaceInfo Surf;
fixed_t tempxsow, tempytow;
size_t nrPlaneVerts;
- patch_t *patch;
static FOutVector *planeVerts = NULL;
static UINT16 numAllocedPlaneVerts = 0;
@@ -3225,48 +3224,49 @@ static void HWR_RenderPolyObjectPlane(polyobj_t *polysector, boolean isceiling,
Z_Malloc(numAllocedPlaneVerts * sizeof (FOutVector), PU_LEVEL, &planeVerts);
}
- len = W_LumpLength(lumpnum);
-
- switch (len)
+ // set texture for polygon
+ if (levelflat != NULL)
{
- case 4194304: // 2048x2048 lump
- fflatwidth = fflatheight = 2048.0f;
- break;
- case 1048576: // 1024x1024 lump
- fflatwidth = fflatheight = 1024.0f;
- break;
- case 262144:// 512x512 lump
- fflatwidth = fflatheight = 512.0f;
- break;
- case 65536: // 256x256 lump
- fflatwidth = fflatheight = 256.0f;
- break;
- case 16384: // 128x128 lump
- fflatwidth = fflatheight = 128.0f;
- break;
- case 1024: // 32x32 lump
- fflatwidth = fflatheight = 32.0f;
- break;
- default: // 64x64 lump
- fflatwidth = fflatheight = 64.0f;
- break;
- }
+ if (levelflat->type == LEVELFLAT_TEXTURE)
+ {
+ fflatwidth = textures[levelflat->u.texture.num]->width;
+ fflatheight = textures[levelflat->u.texture.num]->height;
+ texflat = true;
+ }
+ else if (levelflat->type == LEVELFLAT_FLAT)
+ {
+ len = W_LumpLength(levelflat->u.flat.lumpnum);
- flatflag = ((INT32)fflatwidth)-1;
+ switch (len)
+ {
+ case 4194304: // 2048x2048 lump
+ fflatwidth = fflatheight = 2048.0f;
+ break;
+ case 1048576: // 1024x1024 lump
+ fflatwidth = fflatheight = 1024.0f;
+ break;
+ case 262144:// 512x512 lump
+ fflatwidth = fflatheight = 512.0f;
+ break;
+ case 65536: // 256x256 lump
+ fflatwidth = fflatheight = 256.0f;
+ break;
+ case 16384: // 128x128 lump
+ fflatwidth = fflatheight = 128.0f;
+ break;
+ case 1024: // 32x32 lump
+ fflatwidth = fflatheight = 32.0f;
+ break;
+ default: // 64x64 lump
+ fflatwidth = fflatheight = 64.0f;
+ break;
+ }
- if (texturenum != 0 && texturenum != -1)
- {
- fflatwidth = textures[texturenum]->width;
- fflatheight = textures[texturenum]->height;
- }
- else if (gr_patchflat && R_CheckIfPatch(gr_patchflat)) // Just in case?
- {
- patch = (patch_t *)W_CacheLumpNum(gr_patchflat, PU_STATIC);
- fflatwidth = SHORT(patch->width);
- fflatheight = SHORT(patch->height);
+ flatflag = ((INT32)fflatwidth)-1;
+ }
}
- else
- texflat = false;
+ else // set no texture
+ HWD.pfnSetTexture(NULL);
// reference point for flat texture coord for each vertex around the polygon
flatxref = (float)((polysector->origVerts[0].x & (~flatflag)) / fflatwidth);
@@ -3400,15 +3400,14 @@ static void HWR_AddPolyObjectPlanes(void)
FBITFIELD blendmode;
memset(&Surf, 0x00, sizeof(Surf));
blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf);
- HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->floorpic].lumpnum, levelflats[polyobjsector->floorpic].texturenum, po_ptrs[i], false, polyobjsector->floorheight,
+ HWR_AddTransparentPolyobjectFloor(&levelflats[polyobjsector->floorpic], po_ptrs[i], false, polyobjsector->floorheight,
(light == -1 ? gr_frontsector->lightlevel : *gr_frontsector->lightlist[light].lightlevel), Surf.FlatColor.s.alpha, polyobjsector, blendmode, (light == -1 ? gr_frontsector->extra_colormap : *gr_frontsector->lightlist[light].extra_colormap));
}
else
{
- HWR_GetFlat(levelflats[polyobjsector->floorpic].lumpnum);
- HWR_GetTextureFlat(levelflats[polyobjsector->floorpic].texturenum);
+ HWR_GetLevelFlat(&levelflats[polyobjsector->floorpic]);
HWR_RenderPolyObjectPlane(po_ptrs[i], false, polyobjsector->floorheight, PF_Occlude,
- (light == -1 ? gr_frontsector->lightlevel : *gr_frontsector->lightlist[light].lightlevel), levelflats[polyobjsector->floorpic].lumpnum, levelflats[polyobjsector->floorpic].texturenum,
+ (light == -1 ? gr_frontsector->lightlevel : *gr_frontsector->lightlist[light].lightlevel), &levelflats[polyobjsector->floorpic],
polyobjsector, 255, (light == -1 ? gr_frontsector->extra_colormap : *gr_frontsector->lightlist[light].extra_colormap));
}
}
@@ -3424,15 +3423,14 @@ static void HWR_AddPolyObjectPlanes(void)
FBITFIELD blendmode;
memset(&Surf, 0x00, sizeof(Surf));
blendmode = HWR_TranstableToAlpha(po_ptrs[i]->translucency, &Surf);
- HWR_AddTransparentPolyobjectFloor(levelflats[polyobjsector->ceilingpic].lumpnum, levelflats[polyobjsector->floorpic].texturenum, po_ptrs[i], true, polyobjsector->ceilingheight,
+ HWR_AddTransparentPolyobjectFloor(&levelflats[polyobjsector->ceilingpic], po_ptrs[i], true, polyobjsector->ceilingheight,
(light == -1 ? gr_frontsector->lightlevel : *gr_frontsector->lightlist[light].lightlevel), Surf.FlatColor.s.alpha, polyobjsector, blendmode, (light == -1 ? gr_frontsector->extra_colormap : *gr_frontsector->lightlist[light].extra_colormap));
}
else
{
- HWR_GetFlat(levelflats[polyobjsector->ceilingpic].lumpnum);
- HWR_GetTextureFlat(levelflats[polyobjsector->ceilingpic].texturenum);
+ HWR_GetLevelFlat(&levelflats[polyobjsector->ceilingpic]);
HWR_RenderPolyObjectPlane(po_ptrs[i], true, polyobjsector->ceilingheight, PF_Occlude,
- (light == -1 ? gr_frontsector->lightlevel : *gr_frontsector->lightlist[light].lightlevel), levelflats[polyobjsector->floorpic].lumpnum, levelflats[polyobjsector->floorpic].texturenum,
+ (light == -1 ? gr_frontsector->lightlevel : *gr_frontsector->lightlist[light].lightlevel), &levelflats[polyobjsector->floorpic],
polyobjsector, 255, (light == -1 ? gr_frontsector->extra_colormap : *gr_frontsector->lightlist[light].extra_colormap));
}
}
@@ -3583,13 +3581,12 @@ static void HWR_Subsector(size_t num)
{
if (sub->validcount != validcount)
{
- HWR_GetFlat(levelflats[gr_frontsector->floorpic].lumpnum);
- HWR_GetTextureFlat(levelflats[gr_frontsector->floorpic].texturenum);
+ HWR_GetLevelFlat(&levelflats[gr_frontsector->floorpic]);
HWR_RenderPlane(gr_frontsector, &extrasubsectors[num], false,
// Hack to make things continue to work around slopes.
locFloorHeight == cullFloorHeight ? locFloorHeight : gr_frontsector->floorheight,
// We now return you to your regularly scheduled rendering.
- PF_Occlude, floorlightlevel, levelflats[gr_frontsector->floorpic].lumpnum, levelflats[gr_frontsector->floorpic].texturenum, NULL, 255, false, floorcolormap);
+ PF_Occlude, floorlightlevel, &levelflats[gr_frontsector->floorpic], NULL, 255, false, floorcolormap);
}
}
else
@@ -3606,13 +3603,12 @@ static void HWR_Subsector(size_t num)
{
if (sub->validcount != validcount)
{
- HWR_GetFlat(levelflats[gr_frontsector->ceilingpic].lumpnum);
- HWR_GetTextureFlat(levelflats[gr_frontsector->ceilingpic].texturenum);
+ HWR_GetLevelFlat(&levelflats[gr_frontsector->ceilingpic]);
HWR_RenderPlane(NULL, &extrasubsectors[num], true,
// Hack to make things continue to work around slopes.
locCeilingHeight == cullCeilingHeight ? locCeilingHeight : gr_frontsector->ceilingheight,
// We now return you to your regularly scheduled rendering.
- PF_Occlude, ceilinglightlevel, levelflats[gr_frontsector->ceilingpic].lumpnum, levelflats[gr_frontsector->ceilingpic].texturenum, NULL, 255, false, ceilingcolormap);
+ PF_Occlude, ceilinglightlevel, &levelflats[gr_frontsector->ceilingpic], NULL, 255, false, ceilingcolormap);
}
}
else
@@ -3671,7 +3667,7 @@ static void HWR_Subsector(size_t num)
else
alpha = HWR_FogBlockAlpha(*gr_frontsector->lightlist[light].lightlevel, NORMALFOG);
- HWR_AddTransparentFloor(0, 0,
+ HWR_AddTransparentFloor(NULL,
&extrasubsectors[num],
false,
*rover->bottomheight,
@@ -3683,14 +3679,13 @@ static void HWR_Subsector(size_t num)
{
light = R_GetPlaneLight(gr_frontsector, centerHeight, dup_viewz < cullHeight ? true : false);
#ifndef SORTING
- HWR_Add3DWater(levelflats[*rover->bottompic].lumpnum,
+ HWR_Add3DWater(&levelflats[*rover->bottompic],
&extrasubsectors[num],
*rover->bottomheight,
*gr_frontsector->lightlist[light].lightlevel,
rover->alpha-1, rover->master->frontsector);
#else
- HWR_AddTransparentFloor(levelflats[*rover->bottompic].lumpnum,
- levelflats[*rover->bottompic].texturenum,
+ HWR_AddTransparentFloor(&levelflats[*rover->bottompic],
&extrasubsectors[num],
false,
*rover->bottomheight,
@@ -3701,10 +3696,9 @@ static void HWR_Subsector(size_t num)
}
else
{
- HWR_GetFlat(levelflats[*rover->bottompic].lumpnum);
- HWR_GetTextureFlat(levelflats[*rover->bottompic].texturenum);
+ HWR_GetLevelFlat(&levelflats[*rover->bottompic]);
light = R_GetPlaneLight(gr_frontsector, centerHeight, dup_viewz < cullHeight ? true : false);
- HWR_RenderPlane(NULL, &extrasubsectors[num], false, *rover->bottomheight, PF_Occlude, *gr_frontsector->lightlist[light].lightlevel, levelflats[*rover->bottompic].lumpnum, levelflats[*rover->bottompic].texturenum,
+ HWR_RenderPlane(NULL, &extrasubsectors[num], false, *rover->bottomheight, PF_Occlude, *gr_frontsector->lightlist[light].lightlevel, &levelflats[*rover->bottompic],
rover->master->frontsector, 255, false, *gr_frontsector->lightlist[light].extra_colormap);
}
}
@@ -3736,7 +3730,7 @@ static void HWR_Subsector(size_t num)
else
alpha = HWR_FogBlockAlpha(*gr_frontsector->lightlist[light].lightlevel, NORMALFOG);
- HWR_AddTransparentFloor(0, 0,
+ HWR_AddTransparentFloor(NULL,
&extrasubsectors[num],
true,
*rover->topheight,
@@ -3748,14 +3742,13 @@ static void HWR_Subsector(size_t num)
{
light = R_GetPlaneLight(gr_frontsector, centerHeight, dup_viewz < cullHeight ? true : false);
#ifndef SORTING
- HWR_Add3DWater(levelflats[*rover->toppic].lumpnum,
+ HWR_Add3DWater(&levelflats[*rover->toppic],
&extrasubsectors[num],
*rover->topheight,
*gr_frontsector->lightlist[light].lightlevel,
rover->alpha-1, rover->master->frontsector);
#else
- HWR_AddTransparentFloor(levelflats[*rover->toppic].lumpnum,
- levelflats[*rover->bottompic].texturenum,
+ HWR_AddTransparentFloor(&levelflats[*rover->toppic],
&extrasubsectors[num],
true,
*rover->topheight,
@@ -3767,10 +3760,9 @@ static void HWR_Subsector(size_t num)
}
else
{
- HWR_GetFlat(levelflats[*rover->toppic].lumpnum);
- HWR_GetTextureFlat(levelflats[*rover->toppic].texturenum);
+ HWR_GetLevelFlat(&levelflats[*rover->toppic]);
light = R_GetPlaneLight(gr_frontsector, centerHeight, dup_viewz < cullHeight ? true : false);
- HWR_RenderPlane(NULL, &extrasubsectors[num], true, *rover->topheight, PF_Occlude, *gr_frontsector->lightlist[light].lightlevel, levelflats[*rover->toppic].lumpnum, levelflats[*rover->toppic].texturenum,
+ HWR_RenderPlane(NULL, &extrasubsectors[num], true, *rover->topheight, PF_Occlude, *gr_frontsector->lightlist[light].lightlevel, &levelflats[*rover->toppic],
rover->master->frontsector, 255, false, *gr_frontsector->lightlist[light].extra_colormap);
}
}
@@ -5098,8 +5090,7 @@ typedef struct
boolean isceiling;
fixed_t fixedheight;
INT32 lightlevel;
- lumpnum_t lumpnum;
- INT32 texturenum;
+ levelflat_t *levelflat;
INT32 alpha;
sector_t *FOFSector;
FBITFIELD blend;
@@ -5117,8 +5108,7 @@ typedef struct
boolean isceiling;
fixed_t fixedheight;
INT32 lightlevel;
- lumpnum_t lumpnum;
- INT32 texturenum;
+ levelflat_t *levelflat;
INT32 alpha;
sector_t *FOFSector;
FBITFIELD blend;
@@ -5149,7 +5139,7 @@ static INT32 drawcount = 0;
#define MAX_TRANSPARENTFLOOR 512
// This will likely turn into a copy of HWR_Add3DWater and replace it.
-void HWR_AddTransparentFloor(lumpnum_t lumpnum, INT32 texturenum, extrasubsector_t *xsub, boolean isceiling,
+void HWR_AddTransparentFloor(levelflat_t *levelflat, extrasubsector_t *xsub, boolean isceiling,
fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, boolean fogplane, extracolormap_t *planecolormap)
{
static size_t allocedplanes = 0;
@@ -5167,8 +5157,7 @@ void HWR_AddTransparentFloor(lumpnum_t lumpnum, INT32 texturenum, extrasubsector
planeinfo[numplanes].isceiling = isceiling;
planeinfo[numplanes].fixedheight = fixedheight;
planeinfo[numplanes].lightlevel = lightlevel;
- planeinfo[numplanes].lumpnum = lumpnum;
- planeinfo[numplanes].texturenum = texturenum;
+ planeinfo[numplanes].levelflat = levelflat;
planeinfo[numplanes].xsub = xsub;
planeinfo[numplanes].alpha = alpha;
planeinfo[numplanes].FOFSector = FOFSector;
@@ -5182,7 +5171,7 @@ void HWR_AddTransparentFloor(lumpnum_t lumpnum, INT32 texturenum, extrasubsector
// Adding this for now until I can create extrasubsector info for polyobjects
// When that happens it'll just be done through HWR_AddTransparentFloor and HWR_RenderPlane
-void HWR_AddTransparentPolyobjectFloor(lumpnum_t lumpnum, INT32 texturenum, polyobj_t *polysector, boolean isceiling,
+void HWR_AddTransparentPolyobjectFloor(levelflat_t *levelflat, polyobj_t *polysector, boolean isceiling,
fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector, FBITFIELD blend, extracolormap_t *planecolormap)
{
static size_t allocedpolyplanes = 0;
@@ -5200,8 +5189,7 @@ void HWR_AddTransparentPolyobjectFloor(lumpnum_t lumpnum, INT32 texturenum, poly
polyplaneinfo[numpolyplanes].isceiling = isceiling;
polyplaneinfo[numpolyplanes].fixedheight = fixedheight;
polyplaneinfo[numpolyplanes].lightlevel = lightlevel;
- polyplaneinfo[numpolyplanes].lumpnum = lumpnum;
- polyplaneinfo[numpolyplanes].texturenum = texturenum;
+ polyplaneinfo[numpolyplanes].levelflat = levelflat;
polyplaneinfo[numpolyplanes].polysector = polysector;
polyplaneinfo[numpolyplanes].alpha = alpha;
polyplaneinfo[numpolyplanes].FOFSector = FOFSector;
@@ -5363,12 +5351,9 @@ static void HWR_CreateDrawNodes(void)
gr_frontsector = NULL;
if (!(sortnode[sortindex[i]].plane->blend & PF_NoTexture))
- {
- HWR_GetFlat(sortnode[sortindex[i]].plane->lumpnum);
- HWR_GetTextureFlat(sortnode[sortindex[i]].plane->texturenum);
- }
+ HWR_GetLevelFlat(sortnode[sortindex[i]].plane->levelflat);
HWR_RenderPlane(NULL, sortnode[sortindex[i]].plane->xsub, sortnode[sortindex[i]].plane->isceiling, sortnode[sortindex[i]].plane->fixedheight, sortnode[sortindex[i]].plane->blend, sortnode[sortindex[i]].plane->lightlevel,
- sortnode[sortindex[i]].plane->lumpnum, sortnode[sortindex[i]].plane->texturenum, sortnode[sortindex[i]].plane->FOFSector, sortnode[sortindex[i]].plane->alpha, sortnode[sortindex[i]].plane->fogplane, sortnode[sortindex[i]].plane->planecolormap);
+ sortnode[sortindex[i]].plane->levelflat, sortnode[sortindex[i]].plane->FOFSector, sortnode[sortindex[i]].plane->alpha, sortnode[sortindex[i]].plane->fogplane, sortnode[sortindex[i]].plane->planecolormap);
}
else if (sortnode[sortindex[i]].polyplane)
{
@@ -5376,12 +5361,9 @@ static void HWR_CreateDrawNodes(void)
gr_frontsector = NULL;
if (!(sortnode[sortindex[i]].polyplane->blend & PF_NoTexture))
- {
- HWR_GetFlat(sortnode[sortindex[i]].polyplane->lumpnum);
- HWR_GetTextureFlat(sortnode[sortindex[i]].polyplane->texturenum);
- }
+ HWR_GetLevelFlat(sortnode[sortindex[i]].polyplane->levelflat);
HWR_RenderPolyObjectPlane(sortnode[sortindex[i]].polyplane->polysector, sortnode[sortindex[i]].polyplane->isceiling, sortnode[sortindex[i]].polyplane->fixedheight, sortnode[sortindex[i]].polyplane->blend, sortnode[sortindex[i]].polyplane->lightlevel,
- sortnode[sortindex[i]].polyplane->lumpnum, sortnode[sortindex[i]].polyplane->texturenum, sortnode[sortindex[i]].polyplane->FOFSector, sortnode[sortindex[i]].polyplane->alpha, sortnode[sortindex[i]].polyplane->planecolormap);
+ sortnode[sortindex[i]].polyplane->levelflat, sortnode[sortindex[i]].polyplane->FOFSector, sortnode[sortindex[i]].polyplane->alpha, sortnode[sortindex[i]].polyplane->planecolormap);
}
else if (sortnode[sortindex[i]].wall)
{
@@ -5426,17 +5408,17 @@ static void HWR_DrawSprites(void)
#endif
if (spr->mobj && spr->mobj->skin && spr->mobj->sprite == SPR_PLAY)
{
- if (!cv_grmd2.value || md2_playermodels[(skin_t*)spr->mobj->skin-skins].notfound || md2_playermodels[(skin_t*)spr->mobj->skin-skins].scale < 0.0f)
+ if (!cv_grmodels.value || md2_playermodels[(skin_t*)spr->mobj->skin-skins].notfound || md2_playermodels[(skin_t*)spr->mobj->skin-skins].scale < 0.0f)
HWR_DrawSprite(spr);
else
- HWR_DrawMD2(spr);
+ HWR_DrawModel(spr);
}
else
{
- if (!cv_grmd2.value || md2_models[spr->mobj->sprite].notfound || md2_models[spr->mobj->sprite].scale < 0.0f)
+ if (!cv_grmodels.value || md2_models[spr->mobj->sprite].notfound || md2_models[spr->mobj->sprite].scale < 0.0f)
HWR_DrawSprite(spr);
else
- HWR_DrawMD2(spr);
+ HWR_DrawModel(spr);
}
}
}
@@ -5454,7 +5436,7 @@ static void HWR_AddSprites(sector_t *sec)
#ifdef HWPRECIP
precipmobj_t *precipthing;
#endif
- fixed_t approx_dist, limit_dist;
+ fixed_t approx_dist, limit_dist, hoop_limit_dist;
// BSP is traversed by subsector.
// A sector might have been split into several
@@ -5471,7 +5453,9 @@ static void HWR_AddSprites(sector_t *sec)
// Handle all things in sector.
// If a limit exists, handle things a tiny bit different.
- if ((limit_dist = (fixed_t)((maptol & TOL_NIGHTS) ? cv_drawdist_nights.value : cv_drawdist.value) << FRACBITS))
+ limit_dist = (fixed_t)(cv_drawdist.value) << FRACBITS;
+ hoop_limit_dist = (fixed_t)(cv_drawdist_nights.value) << FRACBITS;
+ if (limit_dist || hoop_limit_dist)
{
for (thing = sec->thinglist; thing; thing = thing->snext)
{
@@ -5480,8 +5464,16 @@ static void HWR_AddSprites(sector_t *sec)
approx_dist = P_AproxDistance(viewx-thing->x, viewy-thing->y);
- if (approx_dist > limit_dist)
- continue;
+ if (thing->sprite == SPR_HOOP)
+ {
+ if (hoop_limit_dist && approx_dist > hoop_limit_dist)
+ continue;
+ }
+ else
+ {
+ if (limit_dist && approx_dist > limit_dist)
+ continue;
+ }
HWR_ProjectSprite(thing);
}
@@ -5554,7 +5546,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
tz = (tr_x * gr_viewcos) + (tr_y * gr_viewsin);
// thing is behind view plane?
- if (tz < ZCLIP_PLANE && !papersprite && (!cv_grmd2.value || md2_models[thing->sprite].notfound == true)) //Yellow: Only MD2's dont disappear
+ if (tz < ZCLIP_PLANE && !papersprite && (!cv_grmodels.value || md2_models[thing->sprite].notfound == true)) //Yellow: Only MD2's dont disappear
return;
// The above can stay as it works for cutting sprites that are too close
@@ -5711,6 +5703,13 @@ static void HWR_ProjectSprite(mobj_t *thing)
return;
}
+ if ((thing->flags2 & MF2_LINKDRAW) && thing->tracer)
+ {
+ // bodge support - not nearly as comprehensive as r_things.c, but better than nothing
+ if (thing->tracer->sprite == SPR_NULL || thing->tracer->flags2 & MF2_DONTDRAW)
+ return;
+ }
+
// store information in a vissprite
vis = HWR_NewVisSprite();
vis->x1 = x1;
@@ -5724,7 +5723,7 @@ static void HWR_ProjectSprite(mobj_t *thing)
vis->z2 = z2;
//Hurdler: 25/04/2000: now support colormap in hardware mode
- if ((vis->mobj->flags & MF_BOSS) && (vis->mobj->flags2 & MF2_FRET) && !(vis->mobj->flags & MF_GRENADEBOUNCE) && (leveltime & 1)) // Bosses "flash"
+ if ((vis->mobj->flags & (MF_ENEMY|MF_BOSS)) && (vis->mobj->flags2 & MF2_FRET) && !(vis->mobj->flags & MF_GRENADEBOUNCE) && (leveltime & 1)) // Bosses "flash"
{
if (vis->mobj->type == MT_CYBRAKDEMON || vis->mobj->colorized)
vis->colormap = R_GetTranslationColormap(TC_ALLWHITE, 0, GTC_CACHE);
@@ -5738,6 +5737,15 @@ static void HWR_ProjectSprite(mobj_t *thing)
// New colormap stuff for skins Tails 06-07-2002
if (thing->colorized)
vis->colormap = R_GetTranslationColormap(TC_RAINBOW, thing->color, GTC_CACHE);
+ else if (thing->player && thing->player->dashmode >= DASHMODE_THRESHOLD
+ && (thing->player->charflags & SF_DASHMODE)
+ && ((leveltime/2) & 1))
+ {
+ if (thing->player->charflags & SF_MACHINE)
+ vis->colormap = R_GetTranslationColormap(TC_DASHMODE, 0, GTC_CACHE);
+ else
+ vis->colormap = R_GetTranslationColormap(TC_RAINBOW, thing->color, GTC_CACHE);
+ }
else if (thing->skin && thing->sprite == SPR_PLAY) // This thing is a player!
{
size_t skinnum = (skin_t*)thing->skin-skins;
@@ -5869,86 +5877,122 @@ static void HWR_ProjectPrecipitationSprite(precipmobj_t *thing)
// ==========================================================================
//
// ==========================================================================
-static void HWR_DrawSkyBackground(void)
+static void HWR_DrawSkyBackground(player_t *player)
{
- FOutVector v[4];
- angle_t angle;
- float dimensionmultiply;
- float aspectratio;
- float angleturn;
+ if (cv_grskydome.value)
+ {
+ FTransform transform;
+ const float fpov = FIXED_TO_FLOAT(cv_grfov.value+player->fovadd);
+ postimg_t *type;
- HWR_GetTexture(texturetranslation[skytexture]);
- aspectratio = (float)vid.width/(float)vid.height;
+ if (splitscreen && player == &players[secondarydisplayplayer])
+ type = &postimgtype2;
+ else
+ type = &postimgtype;
- //Hurdler: the sky is the only texture who need 4.0f instead of 1.0
- // because it's called just after clearing the screen
- // and thus, the near clipping plane is set to 3.99
- // Sryder: Just use the near clipping plane value then
+ memset(&transform, 0x00, sizeof(FTransform));
- // 3--2
- // | /|
- // |/ |
- // 0--1
- v[0].x = v[3].x = -ZCLIP_PLANE-1;
- v[1].x = v[2].x = ZCLIP_PLANE+1;
- v[0].y = v[1].y = -ZCLIP_PLANE-1;
- v[2].y = v[3].y = ZCLIP_PLANE+1;
+ //04/01/2000: Hurdler: added for T&L
+ // It should replace all other gr_viewxxx when finished
+ transform.anglex = (float)(aimingangle>>ANGLETOFINESHIFT)*(360.0f/(float)FINEANGLES);
+ transform.angley = (float)((viewangle-ANGLE_270)>>ANGLETOFINESHIFT)*(360.0f/(float)FINEANGLES);
- v[0].z = v[1].z = v[2].z = v[3].z = ZCLIP_PLANE+1;
+ if (*type == postimg_flip)
+ transform.flip = true;
+ else
+ transform.flip = false;
- // X
+ transform.scalex = 1;
+ transform.scaley = (float)vid.width/vid.height;
+ transform.scalez = 1;
+ transform.fovxangle = fpov; // Tails
+ transform.fovyangle = fpov; // Tails
+ transform.splitscreen = splitscreen;
- // NOTE: This doesn't work right with texture widths greater than 1024
- // software doesn't draw any further than 1024 for skies anyway, but this doesn't overlap properly
- // The only time this will probably be an issue is when a sky wider than 1024 is used as a sky AND a regular wall texture
+ HWR_GetTexture(texturetranslation[skytexture]);
+ HWD.pfnRenderSkyDome(skytexture, textures[skytexture]->width, textures[skytexture]->height, transform);
+ }
+ else
+ {
+ FOutVector v[4];
+ angle_t angle;
+ float dimensionmultiply;
+ float aspectratio;
+ float angleturn;
- angle = (dup_viewangle + gr_xtoviewangle[0]);
+ HWR_GetTexture(texturetranslation[skytexture]);
+ aspectratio = (float)vid.width/(float)vid.height;
- dimensionmultiply = ((float)textures[texturetranslation[skytexture]]->width/256.0f);
+ //Hurdler: the sky is the only texture who need 4.0f instead of 1.0
+ // because it's called just after clearing the screen
+ // and thus, the near clipping plane is set to 3.99
+ // Sryder: Just use the near clipping plane value then
- v[0].sow = v[3].sow = (-1.0f * angle) / ((ANGLE_90-1)*dimensionmultiply); // left
- v[2].sow = v[1].sow = v[0].sow + (1.0f/dimensionmultiply); // right (or left + 1.0f)
- // use +angle and -1.0f above instead if you wanted old backwards behavior
+ // 3--2
+ // | /|
+ // |/ |
+ // 0--1
+ v[0].x = v[3].x = -ZCLIP_PLANE-1;
+ v[1].x = v[2].x = ZCLIP_PLANE+1;
+ v[0].y = v[1].y = -ZCLIP_PLANE-1;
+ v[2].y = v[3].y = ZCLIP_PLANE+1;
- // Y
- angle = aimingangle;
- dimensionmultiply = ((float)textures[texturetranslation[skytexture]]->height/(128.0f*aspectratio));
+ v[0].z = v[1].z = v[2].z = v[3].z = ZCLIP_PLANE+1;
- if (splitscreen)
- {
- dimensionmultiply *= 2;
- angle *= 2;
- }
+ // X
- // Middle of the sky should always be at angle 0
- // need to keep correct aspect ratio with X
- if (atransform.flip)
- {
- // During vertical flip the sky should be flipped and it's y movement should also be flipped obviously
- v[3].tow = v[2].tow = -(0.5f-(0.5f/dimensionmultiply)); // top
- v[0].tow = v[1].tow = v[3].tow - (1.0f/dimensionmultiply); // bottom (or top - 1.0f)
- }
- else
- {
- v[0].tow = v[1].tow = -(0.5f-(0.5f/dimensionmultiply)); // bottom
- v[3].tow = v[2].tow = v[0].tow - (1.0f/dimensionmultiply); // top (or bottom - 1.0f)
- }
+ // NOTE: This doesn't work right with texture widths greater than 1024
+ // software doesn't draw any further than 1024 for skies anyway, but this doesn't overlap properly
+ // The only time this will probably be an issue is when a sky wider than 1024 is used as a sky AND a regular wall texture
- angleturn = (((float)ANGLE_45-1.0f)*aspectratio)*dimensionmultiply;
+ angle = (dup_viewangle + gr_xtoviewangle[0]);
- if (angle > ANGLE_180) // Do this because we don't want the sky to suddenly teleport when crossing over 0 to 360 and vice versa
- {
- angle = InvAngle(angle);
- v[3].tow = v[2].tow += ((float) angle / angleturn);
- v[0].tow = v[1].tow += ((float) angle / angleturn);
- }
- else
- {
- v[3].tow = v[2].tow -= ((float) angle / angleturn);
- v[0].tow = v[1].tow -= ((float) angle / angleturn);
- }
+ dimensionmultiply = ((float)textures[texturetranslation[skytexture]]->width/256.0f);
+
+ v[0].sow = v[3].sow = (-1.0f * angle) / ((ANGLE_90-1)*dimensionmultiply); // left
+ v[2].sow = v[1].sow = v[0].sow + (1.0f/dimensionmultiply); // right (or left + 1.0f)
+ // use +angle and -1.0f above instead if you wanted old backwards behavior
+
+ // Y
+ angle = aimingangle;
+ dimensionmultiply = ((float)textures[texturetranslation[skytexture]]->height/(128.0f*aspectratio));
+
+ if (splitscreen)
+ {
+ dimensionmultiply *= 2;
+ angle *= 2;
+ }
+
+ // Middle of the sky should always be at angle 0
+ // need to keep correct aspect ratio with X
+ if (atransform.flip)
+ {
+ // During vertical flip the sky should be flipped and it's y movement should also be flipped obviously
+ v[3].tow = v[2].tow = -(0.5f-(0.5f/dimensionmultiply)); // top
+ v[0].tow = v[1].tow = v[3].tow - (1.0f/dimensionmultiply); // bottom (or top - 1.0f)
+ }
+ else
+ {
+ v[0].tow = v[1].tow = -(0.5f-(0.5f/dimensionmultiply)); // bottom
+ v[3].tow = v[2].tow = v[0].tow - (1.0f/dimensionmultiply); // top (or bottom - 1.0f)
+ }
+
+ angleturn = (((float)ANGLE_45-1.0f)*aspectratio)*dimensionmultiply;
+
+ if (angle > ANGLE_180) // Do this because we don't want the sky to suddenly teleport when crossing over 0 to 360 and vice versa
+ {
+ angle = InvAngle(angle);
+ v[3].tow = v[2].tow += ((float) angle / angleturn);
+ v[0].tow = v[1].tow += ((float) angle / angleturn);
+ }
+ else
+ {
+ v[3].tow = v[2].tow -= ((float) angle / angleturn);
+ v[0].tow = v[1].tow -= ((float) angle / angleturn);
+ }
- HWD.pfnDrawPolygon(NULL, v, 4, 0);
+ HWD.pfnDrawPolygon(NULL, v, 4, 0);
+ }
}
@@ -6100,7 +6144,7 @@ if (0)
}
if (drawsky)
- HWR_DrawSkyBackground();
+ HWR_DrawSkyBackground(player);
//Hurdler: it doesn't work in splitscreen mode
drawsky = splitscreen;
@@ -6254,6 +6298,7 @@ void HWR_RenderPlayerView(INT32 viewnumber, player_t *player)
// note: sets viewangle, viewx, viewy, viewz
R_SetupFrame(player);
+ framecount++; // timedemo
// copy view cam position for local use
dup_viewx = viewx;
@@ -6317,7 +6362,7 @@ if (0)
}
if (!skybox && drawsky) // Don't draw the regular sky if there's a skybox
- HWR_DrawSkyBackground();
+ HWR_DrawSkyBackground(player);
//Hurdler: it doesn't work in splitscreen mode
drawsky = splitscreen;
@@ -6555,13 +6600,13 @@ void HWR_Startup(void)
// do this once
if (!startupdone)
{
- CONS_Printf("HWR_Startup()\n");
+ CONS_Printf("HWR_Startup()...\n");
HWR_InitPolyPool();
// add console cmds & vars
HWR_AddEngineCommands();
HWR_InitTextureCache();
- HWR_InitMD2();
+ HWR_InitModels();
#ifdef ALAM_LIGHTING
HWR_InitLight();
@@ -6613,10 +6658,11 @@ void transform(float *cx, float *cy, float *cz)
//Hurdler: 3D Water stuff
+#ifndef SORTING
+
#define MAX_3DWATER 512
-#ifndef SORTING
-static void HWR_Add3DWater(lumpnum_t lumpnum, extrasubsector_t *xsub,
+static void HWR_Add3DWater(levelflat_t *levelflat, extrasubsector_t *xsub,
fixed_t fixedheight, INT32 lightlevel, INT32 alpha, sector_t *FOFSector)
{
static size_t allocedplanes = 0;
@@ -6632,17 +6678,15 @@ static void HWR_Add3DWater(lumpnum_t lumpnum, extrasubsector_t *xsub,
}
planeinfo[numfloors].fixedheight = fixedheight;
planeinfo[numfloors].lightlevel = lightlevel;
- planeinfo[numfloors].lumpnum = lumpnum;
+ planeinfo[numfloors].levelflat = levelflat;
planeinfo[numfloors].xsub = xsub;
planeinfo[numfloors].alpha = alpha;
planeinfo[numfloors].FOFSector = FOFSector;
numfloors++;
}
-#endif
#define DIST_PLANE(i) ABS(planeinfo[(i)].fixedheight-dup_viewz)
-#if 0
static void HWR_QuickSortPlane(INT32 start, INT32 finish)
{
INT32 left = start;
@@ -6672,9 +6716,7 @@ static void HWR_QuickSortPlane(INT32 start, INT32 finish)
if (start < right) HWR_QuickSortPlane(start, right);
if (left < finish) HWR_QuickSortPlane(left, finish);
}
-#endif
-#ifndef SORTING
static void HWR_Render3DWater(void)
{
size_t i;
@@ -6705,8 +6747,8 @@ static void HWR_Render3DWater(void)
gr_frontsector = NULL; //Hurdler: gr_fronsector is no longer valid
for (i = 0; i < numfloors; i++)
{
- HWR_GetFlat(planeinfo[i].lumpnum);
- HWR_RenderPlane(NULL, planeinfo[i].xsub, planeinfo[i].isceiling, planeinfo[i].fixedheight, PF_Translucent, planeinfo[i].lightlevel, planeinfo[i].lumpnum,
+ HWR_GetLevelFlat(planeinfo[i].levelflat);
+ HWR_RenderPlane(NULL, planeinfo[i].xsub, planeinfo[i].isceiling, planeinfo[i].fixedheight, PF_Translucent, planeinfo[i].lightlevel, planeinfo[i].levelflat,
planeinfo[i].FOFSector, planeinfo[i].alpha, planeinfo[i].fogplane, planeinfo[i].planecolormap);
}
numfloors = 0;
@@ -6739,6 +6781,7 @@ static void HWR_AddTransparentWall(wallVert3D *wallVerts, FSurfaceInfo *pSurf, I
wallinfo[numwalls].wallcolormap = wallcolormap;
numwalls++;
}
+
#ifndef SORTING
static void HWR_RenderTransparentWalls(void)
{
@@ -6771,6 +6814,7 @@ static void HWR_RenderTransparentWalls(void)
numwalls = 0;
}
#endif
+
static void HWR_RenderWall(wallVert3D *wallVerts, FSurfaceInfo *pSurf, FBITFIELD blend, boolean fogwall, INT32 lightlevel, extracolormap_t *wallcolormap)
{
FOutVector trVerts[4];
@@ -6829,11 +6873,6 @@ static void HWR_RenderWall(wallVert3D *wallVerts, FSurfaceInfo *pSurf, FBITFIE
#endif
}
-void HWR_SetPaletteColor(INT32 palcolor)
-{
- HWD.pfnSetSpecialState(HWD_SET_PALETTECOLOR, palcolor);
-}
-
INT32 HWR_GetTextureUsed(void)
{
return HWD.pfnGetTextureUsed();
@@ -6880,7 +6919,6 @@ void HWR_DoPostProcessor(player_t *player)
if (splitscreen) // Not supported in splitscreen - someone want to add support?
return;
-#ifdef SHUFFLE
// Drunken vision! WooOOooo~
if (*type == postimg_water || *type == postimg_heat)
{
@@ -6923,7 +6961,6 @@ void HWR_DoPostProcessor(player_t *player)
HWD.pfnMakeScreenTexture();
}
// Flipping of the screen isn't done here anymore
-#endif // SHUFFLE
}
void HWR_StartScreenWipe(void)
@@ -6970,7 +7007,7 @@ void HWR_DoWipe(UINT8 wipenum, UINT8 scrnnum)
HWR_GetFadeMask(lumpnum);
- HWD.pfnDoScreenWipe(HWRWipeCounter); // Still send in wipecounter since old stuff might not support multitexturing
+ HWD.pfnDoScreenWipe();
HWRWipeCounter += 0.05f; // increase opacity of end screen
diff --git a/src/hardware/hw_main.h b/src/hardware/hw_main.h
index f8524990f9d6f3096150ae76e505400c5708cb8e..3a0a58427fbb1d2d8bed6173cb04430b32c45541 100644
--- a/src/hardware/hw_main.h
+++ b/src/hardware/hw_main.h
@@ -60,7 +60,6 @@ void HWR_AddCommands(void);
void HWR_CorrectSWTricks(void);
void transform(float *cx, float *cy, float *cz);
FBITFIELD HWR_TranstableToAlpha(INT32 transtablenum, FSurfaceInfo *pSurf);
-void HWR_SetPaletteColor(INT32 palcolor);
INT32 HWR_GetTextureUsed(void);
void HWR_DoPostProcessor(player_t *player);
void HWR_StartScreenWipe(void);
@@ -83,7 +82,8 @@ extern consvar_t cv_grcoronas;
extern consvar_t cv_grcoronasize;
#endif
extern consvar_t cv_grfov;
-extern consvar_t cv_grmd2;
+extern consvar_t cv_grmodels;
+extern consvar_t cv_grmodelinterpolation;
extern consvar_t cv_grfog;
extern consvar_t cv_grfogcolor;
extern consvar_t cv_grfogdensity;
@@ -94,10 +94,10 @@ extern consvar_t cv_grgammablue;
extern consvar_t cv_grfiltermode;
extern consvar_t cv_granisotropicmode;
extern consvar_t cv_grcorrecttricks;
-extern consvar_t cv_voodoocompatibility;
extern consvar_t cv_grfovchange;
extern consvar_t cv_grsolvetjoin;
extern consvar_t cv_grspritebillboarding;
+extern consvar_t cv_grskydome;
extern float gr_viewwidth, gr_viewheight, gr_baseviewwindowy;
diff --git a/src/hardware/hw_md2.c b/src/hardware/hw_md2.c
index 442b4b8c7be128bcb41bebe3c7080acf38526649..cb93f33e9535863dc3eba604354a7c10871e561c 100644
--- a/src/hardware/hw_md2.c
+++ b/src/hardware/hw_md2.c
@@ -35,6 +35,7 @@
#include "hw_drv.h"
#include "hw_light.h"
#include "hw_md2.h"
+#include "../d_main.h"
#include "../r_bsp.h"
#include "../r_main.h"
#include "../m_misc.h"
@@ -43,6 +44,7 @@
#include "../r_things.h"
#include "../r_draw.h"
#include "../p_tick.h"
+#include "hw_model.h"
#include "hw_main.h"
#include "../v_video.h"
@@ -75,172 +77,6 @@
#include "errno.h"
#endif
-#define NUMVERTEXNORMALS 162
-float avertexnormals[NUMVERTEXNORMALS][3] = {
-{-0.525731f, 0.000000f, 0.850651f},
-{-0.442863f, 0.238856f, 0.864188f},
-{-0.295242f, 0.000000f, 0.955423f},
-{-0.309017f, 0.500000f, 0.809017f},
-{-0.162460f, 0.262866f, 0.951056f},
-{0.000000f, 0.000000f, 1.000000f},
-{0.000000f, 0.850651f, 0.525731f},
-{-0.147621f, 0.716567f, 0.681718f},
-{0.147621f, 0.716567f, 0.681718f},
-{0.000000f, 0.525731f, 0.850651f},
-{0.309017f, 0.500000f, 0.809017f},
-{0.525731f, 0.000000f, 0.850651f},
-{0.295242f, 0.000000f, 0.955423f},
-{0.442863f, 0.238856f, 0.864188f},
-{0.162460f, 0.262866f, 0.951056f},
-{-0.681718f, 0.147621f, 0.716567f},
-{-0.809017f, 0.309017f, 0.500000f},
-{-0.587785f, 0.425325f, 0.688191f},
-{-0.850651f, 0.525731f, 0.000000f},
-{-0.864188f, 0.442863f, 0.238856f},
-{-0.716567f, 0.681718f, 0.147621f},
-{-0.688191f, 0.587785f, 0.425325f},
-{-0.500000f, 0.809017f, 0.309017f},
-{-0.238856f, 0.864188f, 0.442863f},
-{-0.425325f, 0.688191f, 0.587785f},
-{-0.716567f, 0.681718f, -0.147621f},
-{-0.500000f, 0.809017f, -0.309017f},
-{-0.525731f, 0.850651f, 0.000000f},
-{0.000000f, 0.850651f, -0.525731f},
-{-0.238856f, 0.864188f, -0.442863f},
-{0.000000f, 0.955423f, -0.295242f},
-{-0.262866f, 0.951056f, -0.162460f},
-{0.000000f, 1.000000f, 0.000000f},
-{0.000000f, 0.955423f, 0.295242f},
-{-0.262866f, 0.951056f, 0.162460f},
-{0.238856f, 0.864188f, 0.442863f},
-{0.262866f, 0.951056f, 0.162460f},
-{0.500000f, 0.809017f, 0.309017f},
-{0.238856f, 0.864188f, -0.442863f},
-{0.262866f, 0.951056f, -0.162460f},
-{0.500000f, 0.809017f, -0.309017f},
-{0.850651f, 0.525731f, 0.000000f},
-{0.716567f, 0.681718f, 0.147621f},
-{0.716567f, 0.681718f, -0.147621f},
-{0.525731f, 0.850651f, 0.000000f},
-{0.425325f, 0.688191f, 0.587785f},
-{0.864188f, 0.442863f, 0.238856f},
-{0.688191f, 0.587785f, 0.425325f},
-{0.809017f, 0.309017f, 0.500000f},
-{0.681718f, 0.147621f, 0.716567f},
-{0.587785f, 0.425325f, 0.688191f},
-{0.955423f, 0.295242f, 0.000000f},
-{1.000000f, 0.000000f, 0.000000f},
-{0.951056f, 0.162460f, 0.262866f},
-{0.850651f, -0.525731f, 0.000000f},
-{0.955423f, -0.295242f, 0.000000f},
-{0.864188f, -0.442863f, 0.238856f},
-{0.951056f, -0.162460f, 0.262866f},
-{0.809017f, -0.309017f, 0.500000f},
-{0.681718f, -0.147621f, 0.716567f},
-{0.850651f, 0.000000f, 0.525731f},
-{0.864188f, 0.442863f, -0.238856f},
-{0.809017f, 0.309017f, -0.500000f},
-{0.951056f, 0.162460f, -0.262866f},
-{0.525731f, 0.000000f, -0.850651f},
-{0.681718f, 0.147621f, -0.716567f},
-{0.681718f, -0.147621f, -0.716567f},
-{0.850651f, 0.000000f, -0.525731f},
-{0.809017f, -0.309017f, -0.500000f},
-{0.864188f, -0.442863f, -0.238856f},
-{0.951056f, -0.162460f, -0.262866f},
-{0.147621f, 0.716567f, -0.681718f},
-{0.309017f, 0.500000f, -0.809017f},
-{0.425325f, 0.688191f, -0.587785f},
-{0.442863f, 0.238856f, -0.864188f},
-{0.587785f, 0.425325f, -0.688191f},
-{0.688191f, 0.587785f, -0.425325f},
-{-0.147621f, 0.716567f, -0.681718f},
-{-0.309017f, 0.500000f, -0.809017f},
-{0.000000f, 0.525731f, -0.850651f},
-{-0.525731f, 0.000000f, -0.850651f},
-{-0.442863f, 0.238856f, -0.864188f},
-{-0.295242f, 0.000000f, -0.955423f},
-{-0.162460f, 0.262866f, -0.951056f},
-{0.000000f, 0.000000f, -1.000000f},
-{0.295242f, 0.000000f, -0.955423f},
-{0.162460f, 0.262866f, -0.951056f},
-{-0.442863f, -0.238856f, -0.864188f},
-{-0.309017f, -0.500000f, -0.809017f},
-{-0.162460f, -0.262866f, -0.951056f},
-{0.000000f, -0.850651f, -0.525731f},
-{-0.147621f, -0.716567f, -0.681718f},
-{0.147621f, -0.716567f, -0.681718f},
-{0.000000f, -0.525731f, -0.850651f},
-{0.309017f, -0.500000f, -0.809017f},
-{0.442863f, -0.238856f, -0.864188f},
-{0.162460f, -0.262866f, -0.951056f},
-{0.238856f, -0.864188f, -0.442863f},
-{0.500000f, -0.809017f, -0.309017f},
-{0.425325f, -0.688191f, -0.587785f},
-{0.716567f, -0.681718f, -0.147621f},
-{0.688191f, -0.587785f, -0.425325f},
-{0.587785f, -0.425325f, -0.688191f},
-{0.000000f, -0.955423f, -0.295242f},
-{0.000000f, -1.000000f, 0.000000f},
-{0.262866f, -0.951056f, -0.162460f},
-{0.000000f, -0.850651f, 0.525731f},
-{0.000000f, -0.955423f, 0.295242f},
-{0.238856f, -0.864188f, 0.442863f},
-{0.262866f, -0.951056f, 0.162460f},
-{0.500000f, -0.809017f, 0.309017f},
-{0.716567f, -0.681718f, 0.147621f},
-{0.525731f, -0.850651f, 0.000000f},
-{-0.238856f, -0.864188f, -0.442863f},
-{-0.500000f, -0.809017f, -0.309017f},
-{-0.262866f, -0.951056f, -0.162460f},
-{-0.850651f, -0.525731f, 0.000000f},
-{-0.716567f, -0.681718f, -0.147621f},
-{-0.716567f, -0.681718f, 0.147621f},
-{-0.525731f, -0.850651f, 0.000000f},
-{-0.500000f, -0.809017f, 0.309017f},
-{-0.238856f, -0.864188f, 0.442863f},
-{-0.262866f, -0.951056f, 0.162460f},
-{-0.864188f, -0.442863f, 0.238856f},
-{-0.809017f, -0.309017f, 0.500000f},
-{-0.688191f, -0.587785f, 0.425325f},
-{-0.681718f, -0.147621f, 0.716567f},
-{-0.442863f, -0.238856f, 0.864188f},
-{-0.587785f, -0.425325f, 0.688191f},
-{-0.309017f, -0.500000f, 0.809017f},
-{-0.147621f, -0.716567f, 0.681718f},
-{-0.425325f, -0.688191f, 0.587785f},
-{-0.162460f, -0.262866f, 0.951056f},
-{0.442863f, -0.238856f, 0.864188f},
-{0.162460f, -0.262866f, 0.951056f},
-{0.309017f, -0.500000f, 0.809017f},
-{0.147621f, -0.716567f, 0.681718f},
-{0.000000f, -0.525731f, 0.850651f},
-{0.425325f, -0.688191f, 0.587785f},
-{0.587785f, -0.425325f, 0.688191f},
-{0.688191f, -0.587785f, 0.425325f},
-{-0.955423f, 0.295242f, 0.000000f},
-{-0.951056f, 0.162460f, 0.262866f},
-{-1.000000f, 0.000000f, 0.000000f},
-{-0.850651f, 0.000000f, 0.525731f},
-{-0.955423f, -0.295242f, 0.000000f},
-{-0.951056f, -0.162460f, 0.262866f},
-{-0.864188f, 0.442863f, -0.238856f},
-{-0.951056f, 0.162460f, -0.262866f},
-{-0.809017f, 0.309017f, -0.500000f},
-{-0.864188f, -0.442863f, -0.238856f},
-{-0.951056f, -0.162460f, -0.262866f},
-{-0.809017f, -0.309017f, -0.500000f},
-{-0.681718f, 0.147621f, -0.716567f},
-{-0.681718f, -0.147621f, -0.716567f},
-{-0.850651f, 0.000000f, -0.525731f},
-{-0.688191f, 0.587785f, -0.425325f},
-{-0.587785f, 0.425325f, -0.688191f},
-{-0.425325f, 0.688191f, -0.587785f},
-{-0.425325f, -0.688191f, -0.587785f},
-{-0.587785f, -0.425325f, -0.688191f},
-{-0.688191f, -0.587785f, -0.425325f},
-};
-
md2_t md2_models[NUMSPRITES];
md2_t md2_playermodels[MAXSKINS];
@@ -248,230 +84,25 @@ md2_t md2_playermodels[MAXSKINS];
/*
* free model
*/
-static void md2_freeModel (md2_model_t *model)
+#if 0
+static void md2_freeModel (model_t *model)
{
- if (model)
- {
- if (model->skins)
- free(model->skins);
-
- if (model->texCoords)
- free(model->texCoords);
-
- if (model->triangles)
- free(model->triangles);
-
- if (model->frames)
- {
- size_t i;
-
- for (i = 0; i < model->header.numFrames; i++)
- {
- if (model->frames[i].vertices)
- free(model->frames[i].vertices);
- }
- free(model->frames);
- }
-
- if (model->spr2frames)
- free(model->spr2frames);
-
- if (model->glCommandBuffer)
- free(model->glCommandBuffer);
-
- free(model);
- }
+ UnloadModel(model);
}
+#endif
//
// load model
//
// Hurdler: the current path is the Legacy.exe path
-static md2_model_t *md2_readModel(const char *filename)
+static model_t *md2_readModel(const char *filename)
{
- FILE *file;
- md2_model_t *model;
- UINT8 buffer[MD2_MAX_FRAMESIZE];
- size_t i;
-
- model = calloc(1, sizeof (*model));
- if (model == NULL)
- return 0;
-
//Filename checking fixed ~Monster Iestyn and Golden
- file = fopen(va("%s"PATHSEP"%s", srb2home, filename), "rb");
- if (!file)
- {
- free(model);
- return 0;
- }
-
- // initialize model and read header
-
- if (fread(&model->header, sizeof (model->header), 1, file) != 1
- || model->header.magic != MD2_IDENT
- || model->header.version != MD2_VERSION)
- {
- fclose(file);
- free(model);
- return 0;
- }
-
- model->header.numSkins = 1;
-
-#define MD2LIMITCHECK(field, max, msgname) \
- if (field > max) \
- { \
- CONS_Alert(CONS_ERROR, "md2_readModel: %s has too many " msgname " (# found: %d, maximum: %d)\n", filename, field, max); \
- md2_freeModel (model); \
- fclose(file); \
- return 0; \
- }
-
- // Uncomment if these are actually needed
-// MD2LIMITCHECK(model->header.numSkins, MD2_MAX_SKINS, "skins")
-// MD2LIMITCHECK(model->header.numTexCoords, MD2_MAX_TEXCOORDS, "texture coordinates")
- MD2LIMITCHECK(model->header.numTriangles, MD2_MAX_TRIANGLES, "triangles")
- MD2LIMITCHECK(model->header.numFrames, MD2_MAX_FRAMES, "frames")
- MD2LIMITCHECK(model->header.numVertices, MD2_MAX_VERTICES, "vertices")
-
-#undef MD2LIMITCHECK
-
- // read skins
- fseek(file, model->header.offsetSkins, SEEK_SET);
- if (model->header.numSkins > 0)
- {
- model->skins = calloc(sizeof (md2_skin_t), model->header.numSkins);
- if (!model->skins || model->header.numSkins !=
- fread(model->skins, sizeof (md2_skin_t), model->header.numSkins, file))
- {
- md2_freeModel (model);
- fclose(file);
- return 0;
- }
- }
-
- // read texture coordinates
- fseek(file, model->header.offsetTexCoords, SEEK_SET);
- if (model->header.numTexCoords > 0)
- {
- model->texCoords = calloc(sizeof (md2_textureCoordinate_t), model->header.numTexCoords);
- if (!model->texCoords || model->header.numTexCoords !=
- fread(model->texCoords, sizeof (md2_textureCoordinate_t), model->header.numTexCoords, file))
- {
- md2_freeModel (model);
- fclose(file);
- return 0;
- }
- }
-
- // read triangles
- fseek(file, model->header.offsetTriangles, SEEK_SET);
- if (model->header.numTriangles > 0)
- {
- model->triangles = calloc(sizeof (md2_triangle_t), model->header.numTriangles);
- if (!model->triangles || model->header.numTriangles !=
- fread(model->triangles, sizeof (md2_triangle_t), model->header.numTriangles, file))
- {
- md2_freeModel (model);
- fclose(file);
- return 0;
- }
- }
-
- // read alias frames
- fseek(file, model->header.offsetFrames, SEEK_SET);
- if (model->header.numFrames > 0)
- {
- model->frames = calloc(sizeof (md2_frame_t), model->header.numFrames);
- if (!model->frames)
- {
- md2_freeModel (model);
- fclose(file);
- return 0;
- }
-
- for (i = 0; i < model->header.numFrames; i++)
- {
- md2_alias_frame_t *frame = (md2_alias_frame_t *)(void *)buffer;
- size_t j;
-
- model->frames[i].vertices = calloc(sizeof (md2_triangleVertex_t), model->header.numVertices);
- if (!model->frames[i].vertices || model->header.frameSize !=
- fread(frame, 1, model->header.frameSize, file))
- {
- md2_freeModel (model);
- fclose(file);
- return 0;
- }
-
- strcpy(model->frames[i].name, frame->name);
- if (frame->name[0] == 'S')
- {
- boolean super;
- if ((super = (fastncmp("UPER", frame->name+1, 4))) // SUPER
- || fastncmp("PR2_", frame->name+1, 4)) // SPR2_
- {
- UINT8 spr2;
- for (spr2 = 0; spr2 < free_spr2; spr2++)
- if (fastncmp(frame->name+5,spr2names[spr2],3)
- && ((frame->name[8] == spr2names[spr2][3])
- || (frame->name[8] == '.' && spr2names[spr2][3] == '_')))
- break;
-
- if (spr2 < free_spr2)
- {
- if (!model->spr2frames)
- {
- model->spr2frames = calloc(sizeof (size_t), 2*NUMPLAYERSPRITES*2);
- if (!model->spr2frames)
- {
- md2_freeModel (model);
- fclose(file);
- return 0;
- }
- }
- if (super)
- spr2 |= FF_SPR2SUPER;
- if (model->spr2frames[spr2*2 + 1]++ == 0) // numspr2frames
- model->spr2frames[spr2*2] = i; // starting frame
- CONS_Debug(DBG_RENDER, "frame %s, sprite2 %s - starting frame %s, number of frames %s\n", frame->name, spr2names[spr2 & ~FF_SPR2SUPER], sizeu1(model->spr2frames[spr2*2]), sizeu2(model->spr2frames[spr2*2 + 1]));
- }
- }
- }
- for (j = 0; j < model->header.numVertices; j++)
- {
- model->frames[i].vertices[j].vertex[0] = (float) ((INT32) frame->alias_vertices[j].vertex[0]) * frame->scale[0] + frame->translate[0];
- model->frames[i].vertices[j].vertex[2] = -1* ((float) ((INT32) frame->alias_vertices[j].vertex[1]) * frame->scale[1] + frame->translate[1]);
- model->frames[i].vertices[j].vertex[1] = (float) ((INT32) frame->alias_vertices[j].vertex[2]) * frame->scale[2] + frame->translate[2];
- model->frames[i].vertices[j].normal[0] = avertexnormals[frame->alias_vertices[j].lightNormalIndex][0];
- model->frames[i].vertices[j].normal[1] = avertexnormals[frame->alias_vertices[j].lightNormalIndex][1];
- model->frames[i].vertices[j].normal[2] = avertexnormals[frame->alias_vertices[j].lightNormalIndex][2];
- }
- }
- }
-
- // read gl commands
- fseek(file, model->header.offsetGlCommands, SEEK_SET);
- if (model->header.numGlCommands)
- {
- model->glCommandBuffer = calloc(sizeof (INT32), model->header.numGlCommands);
- if (!model->glCommandBuffer || model->header.numGlCommands !=
- fread(model->glCommandBuffer, sizeof (INT32), model->header.numGlCommands, file))
- {
- md2_freeModel (model);
- fclose(file);
- return 0;
- }
- }
-
- fclose(file);
-
- return model;
+ return LoadModel(va("%s"PATHSEP"%s", srb2home, filename), PU_STATIC);
}
-static inline void md2_printModelInfo (md2_model_t *model)
+static inline void md2_printModelInfo (model_t *model)
{
#if 0
INT32 i;
@@ -530,7 +161,7 @@ static GrTextureFormat_t PNG_Load(const char *filename, int *w, int *h, GLPatch_
#endif
png_FILE_p png_FILE;
//Filename checking fixed ~Monster Iestyn and Golden
- char *pngfilename = va("%s"PATHSEP"md2"PATHSEP"%s", srb2home, filename);
+ char *pngfilename = va("%s"PATHSEP"models"PATHSEP"%s", srb2home, filename);
FIL_ForceExtension(pngfilename, ".png");
png_FILE = fopen(pngfilename, "rb");
@@ -567,7 +198,7 @@ static GrTextureFormat_t PNG_Load(const char *filename, int *w, int *h, GLPatch_
//CONS_Debug(DBG_RENDER, "libpng load error on %s\n", filename);
png_destroy_read_struct(&png_ptr, &png_info_ptr, NULL);
fclose(png_FILE);
- Z_Free(grpatch->mipmap.grInfo.data);
+ Z_Free(grpatch->mipmap->grInfo.data);
return 0;
}
#ifdef USE_FAR_KEYWORD
@@ -608,7 +239,7 @@ static GrTextureFormat_t PNG_Load(const char *filename, int *w, int *h, GLPatch_
{
png_uint_32 i, pitch = png_get_rowbytes(png_ptr, png_info_ptr);
- png_bytep PNG_image = Z_Malloc(pitch*height, PU_HWRCACHE, &grpatch->mipmap.grInfo.data);
+ png_bytep PNG_image = Z_Malloc(pitch*height, PU_HWRCACHE, &grpatch->mipmap->grInfo.data);
png_bytepp row_pointers = png_malloc(png_ptr, height * sizeof (png_bytep));
for (i = 0; i < height; i++)
row_pointers[i] = PNG_image + i*pitch;
@@ -659,7 +290,7 @@ static GrTextureFormat_t PCX_Load(const char *filename, int *w, int *h,
INT32 ch, rep;
FILE *file;
//Filename checking fixed ~Monster Iestyn and Golden
- char *pcxfilename = va("%s"PATHSEP"md2"PATHSEP"%s", srb2home, filename);
+ char *pcxfilename = va("%s"PATHSEP"models"PATHSEP"%s", srb2home, filename);
FIL_ForceExtension(pcxfilename, ".pcx");
file = fopen(pcxfilename, "rb");
@@ -682,7 +313,7 @@ static GrTextureFormat_t PCX_Load(const char *filename, int *w, int *h,
pw = *w = header.xmax - header.xmin + 1;
ph = *h = header.ymax - header.ymin + 1;
- image = Z_Malloc(pw*ph*4, PU_HWRCACHE, &grpatch->mipmap.grInfo.data);
+ image = Z_Malloc(pw*ph*4, PU_HWRCACHE, &grpatch->mipmap->grInfo.data);
if (fread(palette, sizeof (UINT8), PALSIZE, file) != PALSIZE)
{
@@ -720,7 +351,7 @@ static GrTextureFormat_t PCX_Load(const char *filename, int *w, int *h,
}
// -----------------+
-// md2_loadTexture : Download a pcx or png texture for MD2 models
+// md2_loadTexture : Download a pcx or png texture for models
// -----------------+
static void md2_loadTexture(md2_t *model)
{
@@ -730,39 +361,42 @@ static void md2_loadTexture(md2_t *model)
if (model->grpatch)
{
grpatch = model->grpatch;
- Z_Free(grpatch->mipmap.grInfo.data);
+ Z_Free(grpatch->mipmap->grInfo.data);
}
else
+ {
grpatch = Z_Calloc(sizeof *grpatch, PU_HWRPATCHINFO,
&(model->grpatch));
+ grpatch->mipmap = Z_Calloc(sizeof (GLMipmap_t), PU_HWRPATCHINFO, NULL);
+ }
- if (!grpatch->mipmap.downloaded && !grpatch->mipmap.grInfo.data)
+ if (!grpatch->mipmap->downloaded && !grpatch->mipmap->grInfo.data)
{
int w = 0, h = 0;
#ifdef HAVE_PNG
- grpatch->mipmap.grInfo.format = PNG_Load(filename, &w, &h, grpatch);
- if (grpatch->mipmap.grInfo.format == 0)
+ grpatch->mipmap->grInfo.format = PNG_Load(filename, &w, &h, grpatch);
+ if (grpatch->mipmap->grInfo.format == 0)
#endif
- grpatch->mipmap.grInfo.format = PCX_Load(filename, &w, &h, grpatch);
- if (grpatch->mipmap.grInfo.format == 0)
+ grpatch->mipmap->grInfo.format = PCX_Load(filename, &w, &h, grpatch);
+ if (grpatch->mipmap->grInfo.format == 0)
return;
- grpatch->mipmap.downloaded = 0;
- grpatch->mipmap.flags = 0;
+ grpatch->mipmap->downloaded = 0;
+ grpatch->mipmap->flags = 0;
grpatch->width = (INT16)w;
grpatch->height = (INT16)h;
- grpatch->mipmap.width = (UINT16)w;
- grpatch->mipmap.height = (UINT16)h;
+ grpatch->mipmap->width = (UINT16)w;
+ grpatch->mipmap->height = (UINT16)h;
#ifdef GLIDE_API_COMPATIBILITY
// not correct!
- grpatch->mipmap.grInfo.smallLodLog2 = GR_LOD_LOG2_256;
- grpatch->mipmap.grInfo.largeLodLog2 = GR_LOD_LOG2_256;
- grpatch->mipmap.grInfo.aspectRatioLog2 = GR_ASPECT_LOG2_1x1;
+ grpatch->mipmap->grInfo.smallLodLog2 = GR_LOD_LOG2_256;
+ grpatch->mipmap->grInfo.largeLodLog2 = GR_LOD_LOG2_256;
+ grpatch->mipmap->grInfo.aspectRatioLog2 = GR_ASPECT_LOG2_1x1;
#endif
}
- HWD.pfnSetTexture(&grpatch->mipmap);
+ HWD.pfnSetTexture(grpatch->mipmap);
HWR_UnlockCachedPatch(grpatch);
}
@@ -780,42 +414,45 @@ static void md2_loadBlendTexture(md2_t *model)
if (model->blendgrpatch)
{
grpatch = model->blendgrpatch;
- Z_Free(grpatch->mipmap.grInfo.data);
+ Z_Free(grpatch->mipmap->grInfo.data);
}
else
+ {
grpatch = Z_Calloc(sizeof *grpatch, PU_HWRPATCHINFO,
&(model->blendgrpatch));
+ grpatch->mipmap = Z_Calloc(sizeof (GLMipmap_t), PU_HWRPATCHINFO, NULL);
+ }
- if (!grpatch->mipmap.downloaded && !grpatch->mipmap.grInfo.data)
+ if (!grpatch->mipmap->downloaded && !grpatch->mipmap->grInfo.data)
{
int w = 0, h = 0;
#ifdef HAVE_PNG
- grpatch->mipmap.grInfo.format = PNG_Load(filename, &w, &h, grpatch);
- if (grpatch->mipmap.grInfo.format == 0)
+ grpatch->mipmap->grInfo.format = PNG_Load(filename, &w, &h, grpatch);
+ if (grpatch->mipmap->grInfo.format == 0)
#endif
- grpatch->mipmap.grInfo.format = PCX_Load(filename, &w, &h, grpatch);
- if (grpatch->mipmap.grInfo.format == 0)
+ grpatch->mipmap->grInfo.format = PCX_Load(filename, &w, &h, grpatch);
+ if (grpatch->mipmap->grInfo.format == 0)
{
Z_Free(filename);
return;
}
- grpatch->mipmap.downloaded = 0;
- grpatch->mipmap.flags = 0;
+ grpatch->mipmap->downloaded = 0;
+ grpatch->mipmap->flags = 0;
grpatch->width = (INT16)w;
grpatch->height = (INT16)h;
- grpatch->mipmap.width = (UINT16)w;
- grpatch->mipmap.height = (UINT16)h;
+ grpatch->mipmap->width = (UINT16)w;
+ grpatch->mipmap->height = (UINT16)h;
#ifdef GLIDE_API_COMPATIBILITY
// not correct!
- grpatch->mipmap.grInfo.smallLodLog2 = GR_LOD_LOG2_256;
- grpatch->mipmap.grInfo.largeLodLog2 = GR_LOD_LOG2_256;
- grpatch->mipmap.grInfo.aspectRatioLog2 = GR_ASPECT_LOG2_1x1;
+ grpatch->mipmap->grInfo.smallLodLog2 = GR_LOD_LOG2_256;
+ grpatch->mipmap->grInfo.largeLodLog2 = GR_LOD_LOG2_256;
+ grpatch->mipmap->grInfo.aspectRatioLog2 = GR_ASPECT_LOG2_1x1;
#endif
}
- HWD.pfnSetTexture(&grpatch->mipmap); // We do need to do this so that it can be cleared and knows to recreate it when necessary
+ HWD.pfnSetTexture(grpatch->mipmap); // We do need to do this so that it can be cleared and knows to recreate it when necessary
HWR_UnlockCachedPatch(grpatch);
Z_Free(filename);
@@ -824,7 +461,7 @@ static void md2_loadBlendTexture(md2_t *model)
// Don't spam the console, or the OS with fopen requests!
static boolean nomd2s = false;
-void HWR_InitMD2(void)
+void HWR_InitModels(void)
{
size_t i;
INT32 s;
@@ -832,7 +469,7 @@ void HWR_InitMD2(void)
char name[18], filename[32];
float scale, offset;
- CONS_Printf("InitMD2()...\n");
+ CONS_Printf("HWR_InitModels()...\n");
for (s = 0; s < MAXSKINS; s++)
{
md2_playermodels[s].scale = -1.0f;
@@ -852,13 +489,13 @@ void HWR_InitMD2(void)
md2_models[i].error = false;
}
- // read the md2.dat file
+ // read the models.dat file
//Filename checking fixed ~Monster Iestyn and Golden
- f = fopen(va("%s"PATHSEP"%s", srb2home, "md2.dat"), "rt");
+ f = fopen(va("%s"PATHSEP"%s", srb2home, "models.dat"), "rt");
if (!f)
{
- CONS_Printf("%s %s\n", M_GetText("Error while loading md2.dat:"), strerror(errno));
+ CONS_Printf("%s %s\n", M_GetText("Error while loading models.dat:"), strerror(errno));
nomd2s = true;
return;
}
@@ -866,7 +503,7 @@ void HWR_InitMD2(void)
{
if (stricmp(name, "PLAY") == 0)
{
- CONS_Printf("MD2 for sprite PLAY detected in md2.dat, use a player skin instead!\n");
+ CONS_Printf("Model for sprite PLAY detected in models.dat, use a player skin instead!\n");
continue;
}
@@ -900,7 +537,7 @@ void HWR_InitMD2(void)
}
}
// no sprite/player skin name found?!?
- //CONS_Printf("Unknown sprite/player skin %s detected in md2.dat\n", name);
+ //CONS_Printf("Unknown sprite/player skin %s detected in models.dat\n", name);
md2found:
// move on to next line...
continue;
@@ -908,7 +545,7 @@ md2found:
fclose(f);
}
-void HWR_AddPlayerMD2(int skin) // For MD2's that were added after startup
+void HWR_AddPlayerModel(int skin) // For skins that were added after startup
{
FILE *f;
char name[18], filename[32];
@@ -917,20 +554,20 @@ void HWR_AddPlayerMD2(int skin) // For MD2's that were added after startup
if (nomd2s)
return;
- CONS_Printf("AddPlayerMD2()...\n");
+ //CONS_Printf("HWR_AddPlayerModel()...\n");
- // read the md2.dat file
+ // read the models.dat file
//Filename checking fixed ~Monster Iestyn and Golden
- f = fopen(va("%s"PATHSEP"%s", srb2home, "md2.dat"), "rt");
+ f = fopen(va("%s"PATHSEP"%s", srb2home, "models.dat"), "rt");
if (!f)
{
- CONS_Printf("Error while loading md2.dat\n");
+ CONS_Printf("Error while loading models.dat\n");
nomd2s = true;
return;
}
- // Check for any MD2s that match the names of player skins!
+ // Check for any model that match the names of player skins!
while (fscanf(f, "%19s %31s %f %f", name, filename, &scale, &offset) == 4)
{
if (stricmp(name, skins[skin].name) == 0)
@@ -944,17 +581,16 @@ void HWR_AddPlayerMD2(int skin) // For MD2's that were added after startup
}
}
- //CONS_Printf("MD2 for player skin %s not found\n", skins[skin].name);
+ //CONS_Printf("Model for player skin %s not found\n", skins[skin].name);
md2_playermodels[skin].notfound = true;
playermd2found:
fclose(f);
}
-
-void HWR_AddSpriteMD2(size_t spritenum) // For MD2s that were added after startup
+void HWR_AddSpriteModel(size_t spritenum) // For sprites that were added after startup
{
FILE *f;
- // name[18] is used to check for names in the md2.dat file that match with sprites or player skins
+ // name[18] is used to check for names in the models.dat file that match with sprites or player skins
// sprite names are always 4 characters long, and names is for player skins can be up to 19 characters long
char name[18], filename[32];
float scale, offset;
@@ -965,18 +601,18 @@ void HWR_AddSpriteMD2(size_t spritenum) // For MD2s that were added after startu
if (spritenum == SPR_PLAY) // Handled already NEWMD2: Per sprite, per-skin check
return;
- // Read the md2.dat file
+ // Read the models.dat file
//Filename checking fixed ~Monster Iestyn and Golden
- f = fopen(va("%s"PATHSEP"%s", srb2home, "md2.dat"), "rt");
+ f = fopen(va("%s"PATHSEP"%s", srb2home, "models.dat"), "rt");
if (!f)
{
- CONS_Printf("Error while loading md2.dat\n");
+ CONS_Printf("Error while loading models.dat\n");
nomd2s = true;
return;
}
- // Check for any MD2s that match the names of player skins!
+ // Check for any MD2s that match the names of sprite names!
while (fscanf(f, "%19s %31s %f %f", name, filename, &scale, &offset) == 4)
{
if (stricmp(name, sprnames[spritenum]) == 0)
@@ -1000,7 +636,6 @@ spritemd2found:
// 0.2126 to red
// 0.7152 to green
// 0.0722 to blue
-// (See this same define in k_kart.c!)
#define SETBRIGHTNESS(brightness,r,g,b) \
brightness = (UINT8)(((1063*((UINT16)r)/5000) + (3576*((UINT16)g)/5000) + (361*((UINT16)b)/5000)) / 3)
@@ -1029,8 +664,8 @@ static void HWR_CreateBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch,
cur = Z_Malloc(size*4, PU_HWRCACHE, &grmip->grInfo.data);
memset(cur, 0x00, size*4);
- image = gpatch->mipmap.grInfo.data;
- blendimage = blendgpatch->mipmap.grInfo.data;
+ image = gpatch->mipmap->grInfo.data;
+ blendimage = blendgpatch->mipmap->grInfo.data;
// Average all of the translation's colors
if (color == SKINCOLOR_NONE || color >= MAXTRANSLATIONS)
@@ -1145,13 +780,13 @@ static void HWR_GetBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch, INT
if (colormap == colormaps || colormap == NULL)
{
// Don't do any blending
- HWD.pfnSetTexture(&gpatch->mipmap);
+ HWD.pfnSetTexture(gpatch->mipmap);
return;
}
// search for the mimmap
// skip the first (no colormap translated)
- for (grmip = &gpatch->mipmap; grmip->nextcolormap; )
+ for (grmip = gpatch->mipmap; grmip->nextcolormap; )
{
grmip = grmip->nextcolormap;
if (grmip->colormap == colormap)
@@ -1184,39 +819,40 @@ static void HWR_GetBlendedTexture(GLPatch_t *gpatch, GLPatch_t *blendgpatch, INT
Z_ChangeTag(newmip->grInfo.data, PU_HWRCACHE_UNLOCKED);
}
+#define NORMALFOG 0x00000000
+#define FADEFOG 0x19000000
+static boolean HWR_CanInterpolateModel(mobj_t *mobj, model_t *model)
+{
+ if (cv_grmodelinterpolation.value == 2) // Always interpolate
+ return true;
+ return model->interpolate[(mobj->frame & FF_FRAMEMASK)];
+}
-// -----------------+
-// HWR_DrawMD2 : Draw MD2
-// : (monsters, bonuses, weapons, lights, ...)
-// Returns :
-// -----------------+
- /*
- wait/stand
- death
- pain
- walk
- shoot/fire
-
- die?
- atka?
- atkb?
- attacka/b/c/d?
- res?
- run?
- */
-
-static UINT8 P_GetModelSprite2(md2_t *md2, skin_t *skin, UINT8 spr2, player_t *player)
+static boolean HWR_CanInterpolateSprite2(modelspr2frames_t *spr2frame)
+{
+ if (cv_grmodelinterpolation.value == 2) // Always interpolate
+ return true;
+ return spr2frame->interpolate;
+}
+
+//
+// HWR_GetModelSprite2 (see P_GetSkinSprite2)
+// For non-super players, tries each sprite2's immediate predecessor until it finds one with a number of frames or ends up at standing.
+// For super players, does the same as above - but tries the super equivalent for each sprite2 before the non-super version.
+//
+
+static UINT8 HWR_GetModelSprite2(md2_t *md2, skin_t *skin, UINT8 spr2, player_t *player)
{
UINT8 super = 0, i = 0;
- if (!md2 || !skin)
+ if (!md2 || !md2->model || !md2->model->spr2frames || !skin)
return 0;
if ((playersprite_t)(spr2 & ~FF_SPR2SUPER) >= free_spr2)
return 0;
- while (!(md2->model->spr2frames[spr2*2 + 1])
+ while (!md2->model->spr2frames[spr2].numframes
&& spr2 != SPR2_STND
&& ++i != 32) // recursion limiter
{
@@ -1257,19 +893,23 @@ static UINT8 P_GetModelSprite2(md2_t *md2, skin_t *skin, UINT8 spr2, player_t *p
return spr2;
}
-#define NORMALFOG 0x00000000
-#define FADEFOG 0x19000000
-void HWR_DrawMD2(gr_vissprite_t *spr)
+//
+// HWR_DrawModel
+//
+
+void HWR_DrawModel(gr_vissprite_t *spr)
{
FSurfaceInfo Surf;
char filename[64];
- INT32 frame;
+ INT32 frame = 0;
+ INT32 nextFrame = -1;
+ UINT8 spr2 = 0;
FTransform p;
md2_t *md2;
UINT8 color[4];
- if (!cv_grmd2.value)
+ if (!cv_grmodels.value)
return;
if (spr->precip)
@@ -1277,6 +917,7 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
// MD2 colormap fix
// colormap test
+ if (spr->mobj->subsector)
{
sector_t *sector = spr->mobj->subsector->sector;
UINT8 lightlevel = 255;
@@ -1308,17 +949,19 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
else
Surf.FlatColor.rgba = HWR_Lighting(lightlevel, NORMALFOG, FADEFOG, false, false);
}
+ else
+ Surf.FlatColor.rgba = 0xFFFFFFFF;
// Look at HWR_ProjectSprite for more
{
GLPatch_t *gpatch;
- INT32 *buff;
INT32 durs = spr->mobj->state->tics;
INT32 tics = spr->mobj->tics;
- md2_frame_t *curr, *next = NULL;
+ //mdlframe_t *next = NULL;
const UINT8 flip = (UINT8)(!(spr->mobj->eflags & MFE_VERTICALFLIP) != !(spr->mobj->frame & FF_VERTICALFLIP));
spritedef_t *sprdef;
spriteframe_t *sprframe;
+ INT32 mod;
float finalscale;
// Apparently people don't like jump frames like that, so back it goes
@@ -1349,13 +992,14 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
return; // we already failed loading this before :(
if (!md2->model)
{
- //CONS_Debug(DBG_RENDER, "Loading MD2... (%s)", sprnames[spr->mobj->sprite]);
- sprintf(filename, "md2/%s", md2->filename);
+ //CONS_Debug(DBG_RENDER, "Loading model... (%s)", sprnames[spr->mobj->sprite]);
+ sprintf(filename, "models/%s", md2->filename);
md2->model = md2_readModel(filename);
if (md2->model)
{
md2_printModelInfo(md2->model);
+ HWD.pfnCreateModelVBOs(md2->model);
}
else
{
@@ -1368,18 +1012,18 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
finalscale = md2->scale;
//Hurdler: arf, I don't like that implementation at all... too much crappy
gpatch = md2->grpatch;
- if (!gpatch || !gpatch->mipmap.grInfo.format || !gpatch->mipmap.downloaded)
+ if (!gpatch || !gpatch->mipmap->grInfo.format || !gpatch->mipmap->downloaded)
md2_loadTexture(md2);
gpatch = md2->grpatch; // Load it again, because it isn't being loaded into gpatch after md2_loadtexture...
- if ((gpatch && gpatch->mipmap.grInfo.format) // don't load the blend texture if the base texture isn't available
- && (!md2->blendgrpatch || !((GLPatch_t *)md2->blendgrpatch)->mipmap.grInfo.format || !((GLPatch_t *)md2->blendgrpatch)->mipmap.downloaded))
+ if ((gpatch && gpatch->mipmap->grInfo.format) // don't load the blend texture if the base texture isn't available
+ && (!md2->blendgrpatch || !((GLPatch_t *)md2->blendgrpatch)->mipmap->grInfo.format || !((GLPatch_t *)md2->blendgrpatch)->mipmap->downloaded))
md2_loadBlendTexture(md2);
- if (gpatch && gpatch->mipmap.grInfo.format) // else if meant that if a texture couldn't be loaded, it would just end up using something else's texture
+ if (gpatch && gpatch->mipmap->grInfo.format) // else if meant that if a texture couldn't be loaded, it would just end up using something else's texture
{
if ((skincolors_t)spr->mobj->color != SKINCOLOR_NONE &&
- md2->blendgrpatch && ((GLPatch_t *)md2->blendgrpatch)->mipmap.grInfo.format
+ md2->blendgrpatch && ((GLPatch_t *)md2->blendgrpatch)->mipmap->grInfo.format
&& gpatch->width == ((GLPatch_t *)md2->blendgrpatch)->width && gpatch->height == ((GLPatch_t *)md2->blendgrpatch)->height)
{
INT32 skinnum = TC_DEFAULT;
@@ -1394,23 +1038,28 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
}
else if (spr->mobj->color)
{
- if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY)
+ if (spr->mobj->colorized)
+ skinnum = TC_RAINBOW;
+ else if (spr->mobj->player && spr->mobj->player->dashmode >= DASHMODE_THRESHOLD
+ && (spr->mobj->player->charflags & SF_DASHMODE)
+ && ((leveltime/2) & 1))
{
- if (spr->mobj->colorized)
- skinnum = TC_RAINBOW;
+ if (spr->mobj->player->charflags & SF_MACHINE)
+ skinnum = TC_DASHMODE;
else
- {
- skinnum = (INT32)((skin_t*)spr->mobj->skin-skins);
- }
+ skinnum = TC_RAINBOW;
}
- else skinnum = TC_DEFAULT;
+ else if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY)
+ skinnum = (INT32)((skin_t*)spr->mobj->skin-skins);
+ else
+ skinnum = TC_DEFAULT;
}
HWR_GetBlendedTexture(gpatch, (GLPatch_t *)md2->blendgrpatch, skinnum, spr->colormap, (skincolors_t)spr->mobj->color);
}
else
{
// This is safe, since we know the texture has been downloaded
- HWD.pfnSetTexture(&gpatch->mipmap);
+ HWD.pfnSetTexture(gpatch->mipmap);
}
}
else
@@ -1427,70 +1076,69 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
tics = spr->mobj->anim_duration;
}
-#define INTERPOLERATION_LIMIT TICRATE/4
-
+ frame = (spr->mobj->frame & FF_FRAMEMASK);
if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY && md2->model->spr2frames)
{
- UINT8 spr2 = P_GetModelSprite2(md2, spr->mobj->skin, spr->mobj->sprite2, spr->mobj->player);
- UINT8 mod = md2->model->spr2frames[spr2*2 + 1] ? md2->model->spr2frames[spr2*2 + 1] : md2->model->header.numFrames;
- if (mod > ((skin_t *)spr->mobj->skin)->sprites[spr2].numframes)
+ spr2 = HWR_GetModelSprite2(md2, spr->mobj->skin, spr->mobj->sprite2, spr->mobj->player);
+ mod = md2->model->spr2frames[spr2].numframes;
+#ifndef DONTHIDEDIFFANIMLENGTH // by default, different anim length is masked by the mod
+ if (mod > (INT32)((skin_t *)spr->mobj->skin)->sprites[spr2].numframes)
mod = ((skin_t *)spr->mobj->skin)->sprites[spr2].numframes;
- //FIXME: this is not yet correct
- frame = (spr->mobj->frame & FF_FRAMEMASK);
- if (frame >= mod)
- frame = 0;
- buff = md2->model->glCommandBuffer;
- curr = &md2->model->frames[md2->model->spr2frames[spr2*2] + frame];
- if (cv_grmd2.value == 1 && tics <= durs && tics <= INTERPOLERATION_LIMIT)
- {
- if (durs > INTERPOLERATION_LIMIT)
- durs = INTERPOLERATION_LIMIT;
+#endif
+ if (!mod)
+ mod = 1;
+ frame = md2->model->spr2frames[spr2].frames[frame%mod];
+ }
+ else
+ {
+ mod = md2->model->meshes[0].numFrames;
+ if (!mod)
+ mod = 1;
+ }
- if (spr->mobj->frame & FF_ANIMATE
+#ifdef USE_MODEL_NEXTFRAME
+#define INTERPOLERATION_LIMIT TICRATE/4
+ if (cv_grmodelinterpolation.value && tics <= durs && tics <= INTERPOLERATION_LIMIT)
+ {
+ if (durs > INTERPOLERATION_LIMIT)
+ durs = INTERPOLERATION_LIMIT;
+
+ if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY && md2->model->spr2frames)
+ {
+ if (HWR_CanInterpolateSprite2(&md2->model->spr2frames[spr2])
+ && (spr->mobj->frame & FF_ANIMATE
|| (spr->mobj->state->nextstate != S_NULL
- && states[spr->mobj->state->nextstate].sprite == spr->mobj->sprite
- && (states[spr->mobj->state->nextstate].frame & FF_FRAMEMASK) == spr->mobj->sprite2))
+ && states[spr->mobj->state->nextstate].sprite == SPR_PLAY
+ && ((P_GetSkinSprite2(spr->mobj->skin, (((spr->mobj->player && spr->mobj->player->powers[pw_super]) ? FF_SPR2SUPER : 0)|states[spr->mobj->state->nextstate].frame) & FF_FRAMEMASK, spr->mobj->player) == spr->mobj->sprite2)))))
{
- if (++frame >= mod)
- frame = 0;
+ nextFrame = (spr->mobj->frame & FF_FRAMEMASK) + 1;
+ if (nextFrame >= mod)
+ nextFrame = 0;
if (frame || !(spr->mobj->state->frame & FF_SPR2ENDSTATE))
- next = &md2->model->frames[md2->model->spr2frames[spr2*2] + frame];
+ nextFrame = md2->model->spr2frames[spr2].frames[nextFrame];
+ else
+ nextFrame = -1;
}
}
- }
- else
- {
- //FIXME: this is not yet correct
- frame = (spr->mobj->frame & FF_FRAMEMASK) % md2->model->header.numFrames;
- buff = md2->model->glCommandBuffer;
- curr = &md2->model->frames[frame];
- if (cv_grmd2.value == 1 && tics <= durs && tics <= INTERPOLERATION_LIMIT)
+ else if (HWR_CanInterpolateModel(spr->mobj, md2->model))
{
- if (durs > INTERPOLERATION_LIMIT)
- durs = INTERPOLERATION_LIMIT;
-
// frames are handled differently for states with FF_ANIMATE, so get the next frame differently for the interpolation
if (spr->mobj->frame & FF_ANIMATE)
{
- UINT32 nextframe = (spr->mobj->frame & FF_FRAMEMASK) + 1;
- if (nextframe >= (UINT32)spr->mobj->state->var1)
- nextframe = (spr->mobj->state->frame & FF_FRAMEMASK);
- nextframe %= md2->model->header.numFrames;
- next = &md2->model->frames[nextframe];
+ nextFrame = (spr->mobj->frame & FF_FRAMEMASK) + 1;
+ if (nextFrame >= (INT32)(spr->mobj->state->var1 + (spr->mobj->state->frame & FF_FRAMEMASK)))
+ nextFrame = (spr->mobj->state->frame & FF_FRAMEMASK) % mod;
}
else
{
- if (spr->mobj->state->nextstate != S_NULL
- && states[spr->mobj->state->nextstate].sprite == spr->mobj->sprite)
- {
- const UINT32 nextframe = (states[spr->mobj->state->nextstate].frame & FF_FRAMEMASK) % md2->model->header.numFrames;
- next = &md2->model->frames[nextframe];
- }
+ if (spr->mobj->state->nextstate != S_NULL && states[spr->mobj->state->nextstate].sprite != SPR_NULL
+ && !(spr->mobj->player && (spr->mobj->state->nextstate == S_PLAY_WAIT) && spr->mobj->state == &states[S_PLAY_STND]))
+ nextFrame = (states[spr->mobj->state->nextstate].frame & FF_FRAMEMASK) % mod;
}
}
}
-
#undef INTERPOLERATION_LIMIT
+#endif
//Hurdler: it seems there is still a small problem with mobj angle
p.x = FIXED_TO_FLOAT(spr->mobj->x);
@@ -1510,7 +1158,13 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
if (sprframe->rotate)
{
- const fixed_t anglef = AngleFixed((spr->mobj->player ? spr->mobj->player->drawangle : spr->mobj->angle));
+ fixed_t anglef = AngleFixed(spr->mobj->angle);
+
+ if (spr->mobj->player)
+ anglef = AngleFixed(spr->mobj->player->drawangle);
+ else
+ anglef = AngleFixed(spr->mobj->angle);
+
p.angley = FIXED_TO_FLOAT(anglef);
}
else
@@ -1519,6 +1173,20 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
p.angley = FIXED_TO_FLOAT(anglef);
}
p.anglex = 0.0f;
+#ifdef USE_FTRANSFORM_ANGLEZ
+ // Slope rotation from Kart
+ p.anglez = 0.0f;
+ if (spr->mobj->standingslope)
+ {
+ fixed_t tempz = spr->mobj->standingslope->normal.z;
+ fixed_t tempy = spr->mobj->standingslope->normal.y;
+ fixed_t tempx = spr->mobj->standingslope->normal.x;
+ fixed_t tempangle = AngleFixed(R_PointToAngle2(0, 0, FixedSqrt(FixedMul(tempy, tempy) + FixedMul(tempz, tempz)), tempx));
+ p.anglez = FIXED_TO_FLOAT(tempangle);
+ tempangle = -AngleFixed(R_PointToAngle2(0, 0, tempz, tempy));
+ p.anglex = FIXED_TO_FLOAT(tempangle);
+ }
+#endif
color[0] = Surf.FlatColor.s.red;
color[1] = Surf.FlatColor.s.green;
@@ -1529,8 +1197,11 @@ void HWR_DrawMD2(gr_vissprite_t *spr)
finalscale *= FIXED_TO_FLOAT(spr->mobj->scale);
p.flip = atransform.flip;
+#ifdef USE_FTRANSFORM_MIRROR
+ p.mirror = atransform.mirror; // from Kart
+#endif
- HWD.pfnDrawMD2i(buff, curr, durs, tics, next, &p, finalscale, flip, color);
+ HWD.pfnDrawModel(md2->model, frame, durs, tics, nextFrame, &p, finalscale, flip, color);
}
}
diff --git a/src/hardware/hw_md2.h b/src/hardware/hw_md2.h
index 24a5639330c12fe59ed1aae43ace60d54139c0f3..a5f5fc1174b1e0bc1e9a69fa8e5b75f0d78b9234 100644
--- a/src/hardware/hw_md2.h
+++ b/src/hardware/hw_md2.h
@@ -22,104 +22,7 @@
#define _HW_MD2_H_
#include "hw_glob.h"
-#include "../info.h"
-
-// magic number "IDP2" or 844121161
-#define MD2_IDENT (INT32)(('2' << 24) + ('P' << 16) + ('D' << 8) + 'I')
-// model version
-#define MD2_VERSION 8
-
-// magic number "IDP2" or 844121161
-#define MD2_IDENT (INT32)(('2' << 24) + ('P' << 16) + ('D' << 8) + 'I')
-// model version
-#define MD2_VERSION 8
-
-#define MD2_MAX_TRIANGLES 8192
-#define MD2_MAX_VERTICES 4096
-#define MD2_MAX_TEXCOORDS 4096
-#define MD2_MAX_FRAMES 512
-#define MD2_MAX_SKINS 32
-#define MD2_MAX_FRAMESIZE (MD2_MAX_VERTICES * 4 + 128)
-
-#if defined(_MSC_VER)
-#pragma pack(1)
-#endif
-typedef struct
-{
- UINT32 magic;
- UINT32 version;
- UINT32 skinWidth;
- UINT32 skinHeight;
- UINT32 frameSize;
- UINT32 numSkins;
- UINT32 numVertices;
- UINT32 numTexCoords;
- UINT32 numTriangles;
- UINT32 numGlCommands;
- UINT32 numFrames;
- UINT32 offsetSkins;
- UINT32 offsetTexCoords;
- UINT32 offsetTriangles;
- UINT32 offsetFrames;
- UINT32 offsetGlCommands;
- UINT32 offsetEnd;
-} ATTRPACK md2_header_t; //NOTE: each of md2_header's members are 4 unsigned bytes
-
-typedef struct
-{
- UINT8 vertex[3];
- UINT8 lightNormalIndex;
-} ATTRPACK md2_alias_triangleVertex_t;
-
-typedef struct
-{
- float vertex[3];
- float normal[3];
-} ATTRPACK md2_triangleVertex_t;
-
-typedef struct
-{
- INT16 vertexIndices[3];
- INT16 textureIndices[3];
-} ATTRPACK md2_triangle_t;
-
-typedef struct
-{
- INT16 s, t;
-} ATTRPACK md2_textureCoordinate_t;
-
-typedef struct
-{
- float scale[3];
- float translate[3];
- char name[16];
- md2_alias_triangleVertex_t alias_vertices[1];
-} ATTRPACK md2_alias_frame_t;
-
-typedef struct
-{
- char name[16];
- md2_triangleVertex_t *vertices;
-} ATTRPACK md2_frame_t;
-
-typedef char md2_skin_t[64];
-
-typedef struct
-{
- float s, t;
- INT32 vertexIndex;
-} ATTRPACK md2_glCommandVertex_t;
-
-typedef struct
-{
- md2_header_t header;
- md2_skin_t *skins;
- md2_textureCoordinate_t *texCoords;
- md2_triangle_t *triangles;
- md2_frame_t *frames;
- size_t *spr2frames; // size_t spr2frames[2*NUMPLAYERSPRITES][2];
- INT32 *glCommandBuffer;
-} ATTRPACK md2_model_t;
+#include "hw_model.h"
#if defined(_MSC_VER)
#pragma pack()
@@ -130,7 +33,7 @@ typedef struct
char filename[32];
float scale;
float offset;
- md2_model_t *model;
+ model_t *model;
void *grpatch;
void *blendgrpatch;
boolean notfound;
@@ -141,9 +44,9 @@ typedef struct
extern md2_t md2_models[NUMSPRITES];
extern md2_t md2_playermodels[MAXSKINS];
-void HWR_InitMD2(void);
-void HWR_DrawMD2(gr_vissprite_t *spr);
-void HWR_AddPlayerMD2(INT32 skin);
-void HWR_AddSpriteMD2(size_t spritenum);
+void HWR_InitModels(void);
+void HWR_DrawModel(gr_vissprite_t *spr);
+void HWR_AddPlayerModel(INT32 skin);
+void HWR_AddSpriteModel(size_t spritenum);
#endif // _HW_MD2_H_
diff --git a/src/hardware/hw_md2load.c b/src/hardware/hw_md2load.c
new file mode 100644
index 0000000000000000000000000000000000000000..fed81e411dacc6b3f87ccb985cb49c0331381770
--- /dev/null
+++ b/src/hardware/hw_md2load.c
@@ -0,0 +1,576 @@
+/*
+ From the 'Wizard2' engine by Spaddlewit Inc. ( http://www.spaddlewit.com )
+ An experimental work-in-progress.
+
+ Donated to Sonic Team Junior and adapted to work with
+ Sonic Robo Blast 2. The license of this code matches whatever
+ the licensing is for Sonic Robo Blast 2.
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "../doomdef.h"
+#include "hw_md2load.h"
+#include "hw_model.h"
+#include "../z_zone.h"
+
+#define NUMVERTEXNORMALS 162
+
+// Quake 2 normals are indexed. Use avertexnormals[normalindex][x/y/z] and
+// you'll have your normals.
+float avertexnormals[NUMVERTEXNORMALS][3] = {
+{-0.525731f, 0.000000f, 0.850651f},
+{-0.442863f, 0.238856f, 0.864188f},
+{-0.295242f, 0.000000f, 0.955423f},
+{-0.309017f, 0.500000f, 0.809017f},
+{-0.162460f, 0.262866f, 0.951056f},
+{0.000000f, 0.000000f, 1.000000f},
+{0.000000f, 0.850651f, 0.525731f},
+{-0.147621f, 0.716567f, 0.681718f},
+{0.147621f, 0.716567f, 0.681718f},
+{0.000000f, 0.525731f, 0.850651f},
+{0.309017f, 0.500000f, 0.809017f},
+{0.525731f, 0.000000f, 0.850651f},
+{0.295242f, 0.000000f, 0.955423f},
+{0.442863f, 0.238856f, 0.864188f},
+{0.162460f, 0.262866f, 0.951056f},
+{-0.681718f, 0.147621f, 0.716567f},
+{-0.809017f, 0.309017f, 0.500000f},
+{-0.587785f, 0.425325f, 0.688191f},
+{-0.850651f, 0.525731f, 0.000000f},
+{-0.864188f, 0.442863f, 0.238856f},
+{-0.716567f, 0.681718f, 0.147621f},
+{-0.688191f, 0.587785f, 0.425325f},
+{-0.500000f, 0.809017f, 0.309017f},
+{-0.238856f, 0.864188f, 0.442863f},
+{-0.425325f, 0.688191f, 0.587785f},
+{-0.716567f, 0.681718f, -0.147621f},
+{-0.500000f, 0.809017f, -0.309017f},
+{-0.525731f, 0.850651f, 0.000000f},
+{0.000000f, 0.850651f, -0.525731f},
+{-0.238856f, 0.864188f, -0.442863f},
+{0.000000f, 0.955423f, -0.295242f},
+{-0.262866f, 0.951056f, -0.162460f},
+{0.000000f, 1.000000f, 0.000000f},
+{0.000000f, 0.955423f, 0.295242f},
+{-0.262866f, 0.951056f, 0.162460f},
+{0.238856f, 0.864188f, 0.442863f},
+{0.262866f, 0.951056f, 0.162460f},
+{0.500000f, 0.809017f, 0.309017f},
+{0.238856f, 0.864188f, -0.442863f},
+{0.262866f, 0.951056f, -0.162460f},
+{0.500000f, 0.809017f, -0.309017f},
+{0.850651f, 0.525731f, 0.000000f},
+{0.716567f, 0.681718f, 0.147621f},
+{0.716567f, 0.681718f, -0.147621f},
+{0.525731f, 0.850651f, 0.000000f},
+{0.425325f, 0.688191f, 0.587785f},
+{0.864188f, 0.442863f, 0.238856f},
+{0.688191f, 0.587785f, 0.425325f},
+{0.809017f, 0.309017f, 0.500000f},
+{0.681718f, 0.147621f, 0.716567f},
+{0.587785f, 0.425325f, 0.688191f},
+{0.955423f, 0.295242f, 0.000000f},
+{1.000000f, 0.000000f, 0.000000f},
+{0.951056f, 0.162460f, 0.262866f},
+{0.850651f, -0.525731f, 0.000000f},
+{0.955423f, -0.295242f, 0.000000f},
+{0.864188f, -0.442863f, 0.238856f},
+{0.951056f, -0.162460f, 0.262866f},
+{0.809017f, -0.309017f, 0.500000f},
+{0.681718f, -0.147621f, 0.716567f},
+{0.850651f, 0.000000f, 0.525731f},
+{0.864188f, 0.442863f, -0.238856f},
+{0.809017f, 0.309017f, -0.500000f},
+{0.951056f, 0.162460f, -0.262866f},
+{0.525731f, 0.000000f, -0.850651f},
+{0.681718f, 0.147621f, -0.716567f},
+{0.681718f, -0.147621f, -0.716567f},
+{0.850651f, 0.000000f, -0.525731f},
+{0.809017f, -0.309017f, -0.500000f},
+{0.864188f, -0.442863f, -0.238856f},
+{0.951056f, -0.162460f, -0.262866f},
+{0.147621f, 0.716567f, -0.681718f},
+{0.309017f, 0.500000f, -0.809017f},
+{0.425325f, 0.688191f, -0.587785f},
+{0.442863f, 0.238856f, -0.864188f},
+{0.587785f, 0.425325f, -0.688191f},
+{0.688191f, 0.587785f, -0.425325f},
+{-0.147621f, 0.716567f, -0.681718f},
+{-0.309017f, 0.500000f, -0.809017f},
+{0.000000f, 0.525731f, -0.850651f},
+{-0.525731f, 0.000000f, -0.850651f},
+{-0.442863f, 0.238856f, -0.864188f},
+{-0.295242f, 0.000000f, -0.955423f},
+{-0.162460f, 0.262866f, -0.951056f},
+{0.000000f, 0.000000f, -1.000000f},
+{0.295242f, 0.000000f, -0.955423f},
+{0.162460f, 0.262866f, -0.951056f},
+{-0.442863f, -0.238856f, -0.864188f},
+{-0.309017f, -0.500000f, -0.809017f},
+{-0.162460f, -0.262866f, -0.951056f},
+{0.000000f, -0.850651f, -0.525731f},
+{-0.147621f, -0.716567f, -0.681718f},
+{0.147621f, -0.716567f, -0.681718f},
+{0.000000f, -0.525731f, -0.850651f},
+{0.309017f, -0.500000f, -0.809017f},
+{0.442863f, -0.238856f, -0.864188f},
+{0.162460f, -0.262866f, -0.951056f},
+{0.238856f, -0.864188f, -0.442863f},
+{0.500000f, -0.809017f, -0.309017f},
+{0.425325f, -0.688191f, -0.587785f},
+{0.716567f, -0.681718f, -0.147621f},
+{0.688191f, -0.587785f, -0.425325f},
+{0.587785f, -0.425325f, -0.688191f},
+{0.000000f, -0.955423f, -0.295242f},
+{0.000000f, -1.000000f, 0.000000f},
+{0.262866f, -0.951056f, -0.162460f},
+{0.000000f, -0.850651f, 0.525731f},
+{0.000000f, -0.955423f, 0.295242f},
+{0.238856f, -0.864188f, 0.442863f},
+{0.262866f, -0.951056f, 0.162460f},
+{0.500000f, -0.809017f, 0.309017f},
+{0.716567f, -0.681718f, 0.147621f},
+{0.525731f, -0.850651f, 0.000000f},
+{-0.238856f, -0.864188f, -0.442863f},
+{-0.500000f, -0.809017f, -0.309017f},
+{-0.262866f, -0.951056f, -0.162460f},
+{-0.850651f, -0.525731f, 0.000000f},
+{-0.716567f, -0.681718f, -0.147621f},
+{-0.716567f, -0.681718f, 0.147621f},
+{-0.525731f, -0.850651f, 0.000000f},
+{-0.500000f, -0.809017f, 0.309017f},
+{-0.238856f, -0.864188f, 0.442863f},
+{-0.262866f, -0.951056f, 0.162460f},
+{-0.864188f, -0.442863f, 0.238856f},
+{-0.809017f, -0.309017f, 0.500000f},
+{-0.688191f, -0.587785f, 0.425325f},
+{-0.681718f, -0.147621f, 0.716567f},
+{-0.442863f, -0.238856f, 0.864188f},
+{-0.587785f, -0.425325f, 0.688191f},
+{-0.309017f, -0.500000f, 0.809017f},
+{-0.147621f, -0.716567f, 0.681718f},
+{-0.425325f, -0.688191f, 0.587785f},
+{-0.162460f, -0.262866f, 0.951056f},
+{0.442863f, -0.238856f, 0.864188f},
+{0.162460f, -0.262866f, 0.951056f},
+{0.309017f, -0.500000f, 0.809017f},
+{0.147621f, -0.716567f, 0.681718f},
+{0.000000f, -0.525731f, 0.850651f},
+{0.425325f, -0.688191f, 0.587785f},
+{0.587785f, -0.425325f, 0.688191f},
+{0.688191f, -0.587785f, 0.425325f},
+{-0.955423f, 0.295242f, 0.000000f},
+{-0.951056f, 0.162460f, 0.262866f},
+{-1.000000f, 0.000000f, 0.000000f},
+{-0.850651f, 0.000000f, 0.525731f},
+{-0.955423f, -0.295242f, 0.000000f},
+{-0.951056f, -0.162460f, 0.262866f},
+{-0.864188f, 0.442863f, -0.238856f},
+{-0.951056f, 0.162460f, -0.262866f},
+{-0.809017f, 0.309017f, -0.500000f},
+{-0.864188f, -0.442863f, -0.238856f},
+{-0.951056f, -0.162460f, -0.262866f},
+{-0.809017f, -0.309017f, -0.500000f},
+{-0.681718f, 0.147621f, -0.716567f},
+{-0.681718f, -0.147621f, -0.716567f},
+{-0.850651f, 0.000000f, -0.525731f},
+{-0.688191f, 0.587785f, -0.425325f},
+{-0.587785f, 0.425325f, -0.688191f},
+{-0.425325f, 0.688191f, -0.587785f},
+{-0.425325f, -0.688191f, -0.587785f},
+{-0.587785f, -0.425325f, -0.688191f},
+{-0.688191f, -0.587785f, -0.425325f},
+};
+
+typedef struct
+{
+ int ident; // A "magic number" that's used to identify the .md2 file
+ int version; // The version of the file, always 8
+ int skinwidth; // Width of the skin(s) in pixels
+ int skinheight; // Height of the skin(s) in pixels
+ int framesize; // Size of each frame in bytes
+ int numSkins; // Number of skins with the model
+ int numXYZ; // Number of vertices in each frame
+ int numST; // Number of texture coordinates in each frame.
+ int numTris; // Number of triangles in each frame
+ int numGLcmds; // Number of dwords (4 bytes) in the gl command list.
+ int numFrames; // Number of frames
+ int offsetSkins; // Offset, in bytes from the start of the file, to the list of skin names.
+ int offsetST; // Offset, in bytes from the start of the file, to the list of texture coordinates
+ int offsetTris; // Offset, in bytes from the start of the file, to the list of triangles
+ int offsetFrames; // Offset, in bytes from the start of the file, to the list of frames
+ int offsetGLcmds; // Offset, in bytes from the start of the file, to the list of gl commands
+ int offsetEnd; // Offset, in bytes from the start of the file, to the end of the file (filesize)
+} md2header_t;
+
+typedef struct
+{
+ unsigned short meshIndex[3]; // indices into the array of vertices in each frames
+ unsigned short stIndex[3]; // indices into the array of texture coordinates
+} md2triangle_t;
+
+typedef struct
+{
+ short s;
+ short t;
+} md2texcoord_t;
+
+typedef struct
+{
+ unsigned char v[3]; // Scaled vertices. You'll need to multiply them with scale[x] to make them normal.
+ unsigned char lightNormalIndex; // Index to the array of normals
+} md2vertex_t;
+
+typedef struct
+{
+ float scale[3]; // Used by the v member in the md2framePoint structure
+ float translate[3]; // Used by the v member in the md2framePoint structure
+ char name[16]; // Name of the frame
+} md2frame_t;
+
+// Load the model
+model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat)
+{
+ FILE *f;
+
+ model_t *retModel = NULL;
+ md2header_t *header;
+
+ size_t fileLen;
+ int i, j;
+ size_t namelen;
+ char *texturefilename;
+ const char *texPos;
+
+ char *buffer;
+
+ const float WUNITS = 1.0f;
+ float dataScale = WUNITS;
+
+ md2triangle_t *tris;
+ md2texcoord_t *texcoords;
+ md2frame_t *frames;
+ char *fname = NULL;
+ int foffset = 0;
+
+ int t;
+
+ // MD2 currently does not work with tinyframes, so force useFloat = true
+ //
+ // <SSNTails>
+ // the UV coordinates in MD2 are not compatible with glDrawElements like MD3 is. So they need to be loaded as full float.
+ //
+ // MD2 is intended to be draw in triangle strips and fans
+ // not very compatible with a modern GL implementation, either
+ // so the idea would be to full float expand it, and put it in a vertex buffer object
+ // I'm sure there's a way to convert the UVs to 'tinyframes', but maybe that's a job for someone else.
+ // You'd have to decompress the model, then recompress, reindexing the triangles and weeding out duplicate coordinates
+ // I already have the decompression work done
+
+ useFloat = true;
+
+ f = fopen(fileName, "rb");
+
+ if (!f)
+ return NULL;
+
+ retModel = (model_t*)Z_Calloc(sizeof(model_t), ztag, 0);
+
+ //size_t fileLen;
+
+ //int i, j;
+
+ //size_t namelen;
+ //char *texturefilename;
+ texPos = strchr(fileName, '/');
+
+ if (texPos)
+ {
+ texPos++;
+ namelen = strlen(texPos) + 1;
+ texturefilename = (char*)Z_Malloc(namelen, PU_CACHE, 0);
+ strcpy(texturefilename, texPos);
+ }
+ else
+ {
+ namelen = strlen(fileName) + 1;
+ texturefilename = (char*)Z_Malloc(namelen, PU_CACHE, 0);
+ strcpy(texturefilename, fileName);
+ }
+
+ texturefilename[namelen - 2] = 'z';
+ texturefilename[namelen - 3] = 'u';
+ texturefilename[namelen - 4] = 'b';
+
+ // find length of file
+ fseek(f, 0, SEEK_END);
+ fileLen = ftell(f);
+ fseek(f, 0, SEEK_SET);
+
+ // read in file
+ buffer = malloc(fileLen);
+ if (fread(buffer, fileLen, 1, f)) { } // squash ignored fread error
+ fclose(f);
+
+ // get pointer to file header
+ header = (md2header_t*)buffer;
+
+ retModel->numMeshes = 1; // MD2 only has one mesh
+ retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t) * retModel->numMeshes, ztag, 0);
+ retModel->meshes[0].numFrames = header->numFrames;
+ // const float WUNITS = 1.0f;
+ // float dataScale = WUNITS;
+
+ // Tris and ST are simple structures that can be straight-copied
+ tris = (md2triangle_t*)&buffer[header->offsetTris];
+ texcoords = (md2texcoord_t*)&buffer[header->offsetST];
+ frames = (md2frame_t*)&buffer[header->offsetFrames];
+
+ retModel->framenames = (char*)Z_Calloc(header->numFrames*16, ztag, 0);
+ fname = retModel->framenames;
+ for (i = 0; i < header->numFrames; i++)
+ {
+ md2frame_t *fr = (md2frame_t*)&buffer[header->offsetFrames + foffset];
+ memcpy(fname, fr->name, 16);
+ foffset += sizeof(md2frame_t) + (sizeof(md2vertex_t) * header->numXYZ);
+ fname += 16;
+ }
+
+ // Read in textures
+ retModel->numMaterials = header->numSkins;
+
+ if (retModel->numMaterials <= 0) // Always at least one skin, duh
+ retModel->numMaterials = 1;
+
+ retModel->materials = (material_t*)Z_Calloc(sizeof(material_t)*retModel->numMaterials, ztag, 0);
+
+ // int t;
+ for (t = 0; t < retModel->numMaterials; t++)
+ {
+ retModel->materials[t].ambient[0] = 0.8f;
+ retModel->materials[t].ambient[1] = 0.8f;
+ retModel->materials[t].ambient[2] = 0.8f;
+ retModel->materials[t].ambient[3] = 1.0f;
+ retModel->materials[t].diffuse[0] = 0.8f;
+ retModel->materials[t].diffuse[1] = 0.8f;
+ retModel->materials[t].diffuse[2] = 0.8f;
+ retModel->materials[t].diffuse[3] = 1.0f;
+ retModel->materials[t].emissive[0] = 0.0f;
+ retModel->materials[t].emissive[1] = 0.0f;
+ retModel->materials[t].emissive[2] = 0.0f;
+ retModel->materials[t].emissive[3] = 1.0f;
+ retModel->materials[t].specular[0] = 0.0f;
+ retModel->materials[t].specular[1] = 0.0f;
+ retModel->materials[t].specular[2] = 0.0f;
+ retModel->materials[t].specular[3] = 1.0f;
+ retModel->materials[t].shininess = 0.0f;
+ retModel->materials[t].spheremap = false;
+
+ /* retModel->materials[t].texture = Texture::ReadTexture((char*)texturefilename, ZT_TEXTURE);
+
+ if (!systemSucks)
+ {
+ // Check for a normal map...??
+ char openfilename[1024];
+ char normalMapName[1024];
+ strcpy(normalMapName, texturefilename);
+ size_t len = strlen(normalMapName);
+ char *ptr = &normalMapName[len];
+ ptr--; // z
+ ptr--; // u
+ ptr--; // b
+ ptr--; // .
+ *ptr++ = '_';
+ *ptr++ = 'n';
+ *ptr++ = '.';
+ *ptr++ = 'b';
+ *ptr++ = 'u';
+ *ptr++ = 'z';
+ *ptr++ = '\0';
+
+ sprintf(openfilename, "%s/%s", "textures", normalMapName);
+ // Convert backslashes to forward slashes
+ for (int k = 0; k < 1024; k++)
+ {
+ if (openfilename[k] == '\0')
+ break;
+
+ if (openfilename[k] == '\\')
+ openfilename[k] = '/';
+ }
+
+ Resource::resource_t *res = Resource::Open(openfilename);
+ if (res)
+ {
+ Resource::Close(res);
+ retModel->materials[t].lightmap = Texture::ReadTexture(normalMapName, ZT_TEXTURE);
+ }
+ }*/
+ }
+
+ retModel->meshes[0].numTriangles = header->numTris;
+
+ if (!useFloat) // Decompress to MD3 'tinyframe' space
+ {
+ char *ptr;
+
+ md2triangle_t *trisPtr;
+ unsigned short *indexptr;
+ float *uvptr;
+
+ dataScale = 0.015624f; // 1 / 64.0f
+ retModel->meshes[0].tinyframes = (tinyframe_t*)Z_Calloc(sizeof(tinyframe_t)*header->numFrames, ztag, 0);
+ retModel->meshes[0].numVertices = header->numXYZ;
+ retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, 0);
+
+ ptr = (char*)frames;
+ for (i = 0; i < header->numFrames; i++, ptr += header->framesize)
+ {
+ short *vertptr;
+ char *normptr;
+ // char *tanptr;
+
+ md2vertex_t *vertex;
+
+ md2frame_t *framePtr = (md2frame_t*)ptr;
+ retModel->meshes[0].tinyframes[i].vertices = (short*)Z_Malloc(sizeof(short) * 3 * header->numXYZ, ztag, 0);
+ retModel->meshes[0].tinyframes[i].normals = (char*)Z_Malloc(sizeof(char) * 3 * header->numXYZ, ztag, 0);
+
+ // if (retModel->materials[0].lightmap)
+ // retModel->meshes[0].tinyframes[i].tangents = (char*)malloc(sizeof(char));//(char*)Z_Malloc(sizeof(char)*3*header->numVerts, ztag);
+ retModel->meshes[0].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * header->numTris, ztag, 0);
+
+ vertptr = retModel->meshes[0].tinyframes[i].vertices;
+ normptr = retModel->meshes[0].tinyframes[i].normals;
+
+ // tanptr = retModel->meshes[0].tinyframes[i].tangents;
+ retModel->meshes[0].tinyframes[i].material = &retModel->materials[0];
+
+ framePtr++; // Advance to vertex list
+ vertex = (md2vertex_t*)framePtr;
+ framePtr--;
+ for (j = 0; j < header->numXYZ; j++, vertex++)
+ {
+ *vertptr = (short)(((vertex->v[0] * framePtr->scale[0]) + framePtr->translate[0]) / dataScale);
+ vertptr++;
+ *vertptr = (short)(((vertex->v[2] * framePtr->scale[2]) + framePtr->translate[2]) / dataScale);
+ vertptr++;
+ *vertptr = -1.0f * (short)(((vertex->v[1] * framePtr->scale[1]) + framePtr->translate[1]) / dataScale);
+ vertptr++;
+
+ // Normal
+ *normptr++ = (char)(avertexnormals[vertex->lightNormalIndex][0] * 127);
+ *normptr++ = (char)(avertexnormals[vertex->lightNormalIndex][2] * 127);
+ *normptr++ = (char)(avertexnormals[vertex->lightNormalIndex][1] * 127);
+ }
+ }
+
+ // This doesn't need to be done every frame!
+ trisPtr = tris;
+ indexptr = retModel->meshes[0].indices;
+ uvptr = (float*)retModel->meshes[0].uvs;
+ for (j = 0; j < header->numTris; j++, trisPtr++)
+ {
+ *indexptr = trisPtr->meshIndex[0];
+ indexptr++;
+ *indexptr = trisPtr->meshIndex[1];
+ indexptr++;
+ *indexptr = trisPtr->meshIndex[2];
+ indexptr++;
+
+ uvptr[trisPtr->meshIndex[0] * 2] = texcoords[trisPtr->stIndex[0]].s / (float)header->skinwidth;
+ uvptr[trisPtr->meshIndex[0] * 2 + 1] = (texcoords[trisPtr->stIndex[0]].t / (float)header->skinheight);
+ uvptr[trisPtr->meshIndex[1] * 2] = texcoords[trisPtr->stIndex[1]].s / (float)header->skinwidth;
+ uvptr[trisPtr->meshIndex[1] * 2 + 1] = (texcoords[trisPtr->stIndex[1]].t / (float)header->skinheight);
+ uvptr[trisPtr->meshIndex[2] * 2] = texcoords[trisPtr->stIndex[2]].s / (float)header->skinwidth;
+ uvptr[trisPtr->meshIndex[2] * 2 + 1] = (texcoords[trisPtr->stIndex[2]].t / (float)header->skinheight);
+ }
+ }
+ else // Full float loading method
+ {
+ md2triangle_t *trisPtr;
+ float *uvptr;
+
+ char *ptr;
+
+ retModel->meshes[0].numVertices = header->numTris * 3;
+ retModel->meshes[0].frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t)*header->numFrames, ztag, 0);
+ retModel->meshes[0].uvs = (float*)Z_Malloc(sizeof(float) * 2 * retModel->meshes[0].numVertices, ztag, 0);
+
+ trisPtr = tris;
+ uvptr = retModel->meshes[0].uvs;
+ for (i = 0; i < retModel->meshes[0].numTriangles; i++, trisPtr++)
+ {
+ *uvptr++ = texcoords[trisPtr->stIndex[0]].s / (float)header->skinwidth;
+ *uvptr++ = (texcoords[trisPtr->stIndex[0]].t / (float)header->skinheight);
+ *uvptr++ = texcoords[trisPtr->stIndex[1]].s / (float)header->skinwidth;
+ *uvptr++ = (texcoords[trisPtr->stIndex[1]].t / (float)header->skinheight);
+ *uvptr++ = texcoords[trisPtr->stIndex[2]].s / (float)header->skinwidth;
+ *uvptr++ = (texcoords[trisPtr->stIndex[2]].t / (float)header->skinheight);
+ }
+
+ ptr = (char*)frames;
+ for (i = 0; i < header->numFrames; i++, ptr += header->framesize)
+ {
+ float *vertptr, *normptr;
+
+ md2vertex_t *vertex;
+
+ md2frame_t *framePtr = (md2frame_t*)ptr;
+ retModel->meshes[0].frames[i].normals = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, 0);
+ retModel->meshes[0].frames[i].vertices = (float*)Z_Malloc(sizeof(float) * 3 * header->numTris * 3, ztag, 0);
+ // if (retModel->materials[0].lightmap)
+ // retModel->meshes[0].frames[i].tangents = (float*)malloc(sizeof(float));//(float*)Z_Malloc(sizeof(float)*3*header->numTris*3, ztag);
+ //float *vertptr, *normptr;
+ normptr = (float*)retModel->meshes[0].frames[i].normals;
+ vertptr = (float*)retModel->meshes[0].frames[i].vertices;
+ trisPtr = tris;
+
+ retModel->meshes[0].frames[i].material = &retModel->materials[0];
+
+ framePtr++; // Advance to vertex list
+ vertex = (md2vertex_t*)framePtr;
+ framePtr--;
+ for (j = 0; j < header->numTris; j++, trisPtr++)
+ {
+ *vertptr = ((vertex[trisPtr->meshIndex[0]].v[0] * framePtr->scale[0]) + framePtr->translate[0]) * WUNITS;
+ vertptr++;
+ *vertptr = ((vertex[trisPtr->meshIndex[0]].v[2] * framePtr->scale[2]) + framePtr->translate[2]) * WUNITS;
+ vertptr++;
+ *vertptr = -1.0f * ((vertex[trisPtr->meshIndex[0]].v[1] * framePtr->scale[1]) + framePtr->translate[1]) * WUNITS;
+ vertptr++;
+
+ *vertptr = ((vertex[trisPtr->meshIndex[1]].v[0] * framePtr->scale[0]) + framePtr->translate[0]) * WUNITS;
+ vertptr++;
+ *vertptr = ((vertex[trisPtr->meshIndex[1]].v[2] * framePtr->scale[2]) + framePtr->translate[2]) * WUNITS;
+ vertptr++;
+ *vertptr = -1.0f * ((vertex[trisPtr->meshIndex[1]].v[1] * framePtr->scale[1]) + framePtr->translate[1]) * WUNITS;
+ vertptr++;
+
+ *vertptr = ((vertex[trisPtr->meshIndex[2]].v[0] * framePtr->scale[0]) + framePtr->translate[0]) * WUNITS;
+ vertptr++;
+ *vertptr = ((vertex[trisPtr->meshIndex[2]].v[2] * framePtr->scale[2]) + framePtr->translate[2]) * WUNITS;
+ vertptr++;
+ *vertptr = -1.0f * ((vertex[trisPtr->meshIndex[2]].v[1] * framePtr->scale[1]) + framePtr->translate[1]) * WUNITS;
+ vertptr++;
+
+ *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[0]].lightNormalIndex][0];
+ *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[0]].lightNormalIndex][2];
+ *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[0]].lightNormalIndex][1];
+
+ *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[1]].lightNormalIndex][0];
+ *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[1]].lightNormalIndex][2];
+ *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[1]].lightNormalIndex][1];
+
+ *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[2]].lightNormalIndex][0];
+ *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[2]].lightNormalIndex][2];
+ *normptr++ = avertexnormals[vertex[trisPtr->meshIndex[2]].lightNormalIndex][1];
+ }
+ }
+ }
+
+ free(buffer);
+ return retModel;
+}
diff --git a/src/hardware/hw_md2load.h b/src/hardware/hw_md2load.h
new file mode 100644
index 0000000000000000000000000000000000000000..1662d6471eca6780ebd0213595b8985e4968da20
--- /dev/null
+++ b/src/hardware/hw_md2load.h
@@ -0,0 +1,19 @@
+/*
+ From the 'Wizard2' engine by Spaddlewit Inc. ( http://www.spaddlewit.com )
+ An experimental work-in-progress.
+
+ Donated to Sonic Team Junior and adapted to work with
+ Sonic Robo Blast 2. The license of this code matches whatever
+ the licensing is for Sonic Robo Blast 2.
+*/
+
+#ifndef _HW_MD2LOAD_H_
+#define _HW_MD2LOAD_H_
+
+#include "hw_model.h"
+#include "../doomtype.h"
+
+// Load the Model
+model_t *MD2_LoadModel(const char *fileName, int ztag, boolean useFloat);
+
+#endif
diff --git a/src/hardware/hw_md3load.c b/src/hardware/hw_md3load.c
new file mode 100644
index 0000000000000000000000000000000000000000..87931d27ba104e1f9a4109515f6497ad19bae453
--- /dev/null
+++ b/src/hardware/hw_md3load.c
@@ -0,0 +1,522 @@
+/*
+ From the 'Wizard2' engine by Spaddlewit Inc. ( http://www.spaddlewit.com )
+ An experimental work-in-progress.
+
+ Donated to Sonic Team Junior and adapted to work with
+ Sonic Robo Blast 2. The license of this code matches whatever
+ the licensing is for Sonic Robo Blast 2.
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "../doomdef.h"
+#include "hw_md3load.h"
+#include "hw_model.h"
+#include "../z_zone.h"
+
+typedef struct
+{
+ int ident; // A "magic number" that's used to identify the .md3 file
+ int version; // The version of the file, always 15
+ char name[64];
+ int flags;
+ int numFrames; // Number of frames
+ int numTags;
+ int numSurfaces;
+ int numSkins; // Number of skins with the model
+ int offsetFrames;
+ int offsetTags;
+ int offsetSurfaces;
+ int offsetEnd; // Offset, in bytes from the start of the file, to the end of the file (filesize)
+} md3modelHeader;
+
+typedef struct
+{
+ float minBounds[3]; // First corner of the bounding box
+ float maxBounds[3]; // Second corner of the bounding box
+ float localOrigin[3]; // Local origin, usually (0, 0, 0)
+ float radius; // Radius of bounding sphere
+ char name[16]; // Name of frame
+} md3Frame;
+
+typedef struct
+{
+ char name[64]; // Name of tag
+ float origin[3]; // Coordinates of tag
+ float axis[9]; // Orientation of tag object
+} md3Tag;
+
+typedef struct
+{
+ int ident;
+ char name[64]; // Name of this surface
+ int flags;
+ int numFrames; // # of keyframes
+ int numShaders; // # of shaders
+ int numVerts; // # of vertices
+ int numTriangles; // # of triangles
+ int offsetTriangles; // Relative offset from start of this struct to where the list of Triangles start
+ int offsetShaders; // Relative offset from start of this struct to where the list of Shaders start
+ int offsetST; // Relative offset from start of this struct to where the list of tex coords start
+ int offsetXYZNormal; // Relative offset from start of this struct to where the list of vertices start
+ int offsetEnd; // Relative offset from start of this struct to where this surface ends
+} md3Surface;
+
+typedef struct
+{
+ char name[64]; // Name of this shader
+ int shaderIndex; // Shader index number
+} md3Shader;
+
+typedef struct
+{
+ int index[3]; // List of offset values into the list of Vertex objects that constitute the corners of the Triangle object.
+} md3Triangle;
+
+typedef struct
+{
+ float st[2];
+} md3TexCoord;
+
+typedef struct
+{
+ short x, y, z, n;
+} md3Vertex;
+
+static float latlnglookup[256][256][3];
+
+static void GetNormalFromLatLong(short latlng, float *out)
+{
+ float *lookup = latlnglookup[(unsigned char)(latlng >> 8)][(unsigned char)(latlng & 255)];
+
+ out[0] = *lookup++;
+ out[1] = *lookup++;
+ out[2] = *lookup++;
+}
+
+#if 0
+static void NormalToLatLng(float *n, short *out)
+{
+ // Special cases
+ if (0.0f == n[0] && 0.0f == n[1])
+ {
+ if (n[2] > 0.0f)
+ *out = 0;
+ else
+ *out = 128;
+ }
+ else
+ {
+ char x, y;
+
+ x = (char)(57.2957795f * (atan2(n[1], n[0])) * (255.0f / 360.0f));
+ y = (char)(57.2957795f * (acos(n[2])) * (255.0f / 360.0f));
+
+ *out = (x << 8) + y;
+ }
+}
+#endif
+
+static inline void LatLngToNormal(short n, float *out)
+{
+ const float PI = (3.1415926535897932384626433832795f);
+ float lat = (float)(n >> 8);
+ float lng = (float)(n & 255);
+
+ lat *= PI / 128.0f;
+ lng *= PI / 128.0f;
+
+ out[0] = cosf(lat) * sinf(lng);
+ out[1] = sinf(lat) * sinf(lng);
+ out[2] = cosf(lng);
+}
+
+static void LatLngInit(void)
+{
+ int i, j;
+ for (i = 0; i < 256; i++)
+ {
+ for (j = 0; j < 256; j++)
+ LatLngToNormal((short)((i << 8) + j), latlnglookup[i][j]);
+ }
+}
+
+static boolean latlnginit = false;
+
+model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat)
+{
+ const float WUNITS = 1.0f;
+ model_t *retModel = NULL;
+ md3Frame *frames = NULL;
+ char *fname = NULL;
+ md3modelHeader *mdh;
+ long fileLen;
+ long fileReadLen;
+ char *buffer;
+ int surfEnd;
+ int i, t;
+ int matCount;
+ FILE *f;
+
+ if (!latlnginit)
+ {
+ LatLngInit();
+ latlnginit = true;
+ }
+
+ f = fopen(fileName, "rb");
+
+ if (!f)
+ return NULL;
+
+ retModel = (model_t*)Z_Calloc(sizeof(model_t), ztag, 0);
+
+ // find length of file
+ fseek(f, 0, SEEK_END);
+ fileLen = ftell(f);
+ fseek(f, 0, SEEK_SET);
+
+ // read in file
+ buffer = malloc(fileLen);
+ fileReadLen = fread(buffer, fileLen, 1, f);
+ fclose(f);
+
+ (void)fileReadLen; // intentionally ignore return value, per buildbot
+
+ // get pointer to file header
+ mdh = (md3modelHeader*)buffer;
+
+ retModel->numMeshes = mdh->numSurfaces;
+
+ retModel->numMaterials = 0;
+ surfEnd = 0;
+ for (i = 0; i < mdh->numSurfaces; i++)
+ {
+ md3Surface *mdS = (md3Surface*)&buffer[mdh->offsetSurfaces];
+ surfEnd += mdS->offsetEnd;
+
+ retModel->numMaterials += mdS->numShaders;
+ }
+
+ // Initialize materials
+ if (retModel->numMaterials <= 0) // Always at least one skin, duh
+ retModel->numMaterials = 1;
+
+ retModel->materials = (material_t*)Z_Calloc(sizeof(material_t)*retModel->numMaterials, ztag, 0);
+
+ for (t = 0; t < retModel->numMaterials; t++)
+ {
+ retModel->materials[t].ambient[0] = 0.3686f;
+ retModel->materials[t].ambient[1] = 0.3684f;
+ retModel->materials[t].ambient[2] = 0.3684f;
+ retModel->materials[t].ambient[3] = 1.0f;
+ retModel->materials[t].diffuse[0] = 0.8863f;
+ retModel->materials[t].diffuse[1] = 0.8850f;
+ retModel->materials[t].diffuse[2] = 0.8850f;
+ retModel->materials[t].diffuse[3] = 1.0f;
+ retModel->materials[t].emissive[0] = 0.0f;
+ retModel->materials[t].emissive[1] = 0.0f;
+ retModel->materials[t].emissive[2] = 0.0f;
+ retModel->materials[t].emissive[3] = 1.0f;
+ retModel->materials[t].specular[0] = 0.4902f;
+ retModel->materials[t].specular[1] = 0.4887f;
+ retModel->materials[t].specular[2] = 0.4887f;
+ retModel->materials[t].specular[3] = 1.0f;
+ retModel->materials[t].shininess = 25.0f;
+ retModel->materials[t].spheremap = false;
+ }
+
+ retModel->meshes = (mesh_t*)Z_Calloc(sizeof(mesh_t)*retModel->numMeshes, ztag, 0);
+
+ frames = (md3Frame*)&buffer[mdh->offsetFrames];
+ retModel->framenames = (char*)Z_Calloc(mdh->numFrames*16, ztag, 0);
+ fname = retModel->framenames;
+ for (i = 0; i < mdh->numFrames; i++)
+ {
+ memcpy(fname, frames->name, 16);
+ fname += 16;
+ frames++;
+ }
+
+ matCount = 0;
+ for (i = 0, surfEnd = 0; i < mdh->numSurfaces; i++)
+ {
+ int j;
+ md3Shader *mdShader;
+ md3Surface *mdS = (md3Surface*)&buffer[mdh->offsetSurfaces + surfEnd];
+ surfEnd += mdS->offsetEnd;
+
+ mdShader = (md3Shader*)((char*)mdS + mdS->offsetShaders);
+
+ for (j = 0; j < mdS->numShaders; j++, matCount++)
+ {
+ size_t len = strlen(mdShader[j].name);
+ mdShader[j].name[len-1] = 'z';
+ mdShader[j].name[len-2] = 'u';
+ mdShader[j].name[len-3] = 'b';
+
+ // Load material
+/* retModel->materials[matCount].texture = Texture::ReadTexture(mdShader[j].name, ZT_TEXTURE);
+
+ if (!systemSucks)
+ {
+ // Check for a normal map...??
+ char openfilename[1024];
+ char normalMapName[1024];
+ strcpy(normalMapName, mdShader[j].name);
+ len = strlen(normalMapName);
+ char *ptr = &normalMapName[len];
+ ptr--; // z
+ ptr--; // u
+ ptr--; // b
+ ptr--; // .
+ *ptr++ = '_';
+ *ptr++ = 'n';
+ *ptr++ = '.';
+ *ptr++ = 'b';
+ *ptr++ = 'u';
+ *ptr++ = 'z';
+ *ptr++ = '\0';
+
+ sprintf(openfilename, "%s/%s", "textures", normalMapName);
+ // Convert backslashes to forward slashes
+ for (int k = 0; k < 1024; k++)
+ {
+ if (openfilename[k] == '\0')
+ break;
+
+ if (openfilename[k] == '\\')
+ openfilename[k] = '/';
+ }
+
+ Resource::resource_t *res = Resource::Open(openfilename);
+ if (res)
+ {
+ Resource::Close(res);
+ retModel->materials[matCount].lightmap = Texture::ReadTexture(normalMapName, ZT_TEXTURE);
+ }
+ }*/
+ }
+
+ retModel->meshes[i].numFrames = mdS->numFrames;
+ retModel->meshes[i].numTriangles = mdS->numTriangles;
+
+ if (!useFloat) // 'tinyframe' mode with indices
+ {
+ float tempNormal[3];
+ float *uvptr;
+ md3TexCoord *mdST;
+ unsigned short *indexptr;
+ md3Triangle *mdT;
+
+ retModel->meshes[i].tinyframes = (tinyframe_t*)Z_Calloc(sizeof(tinyframe_t)*mdS->numFrames, ztag, 0);
+ retModel->meshes[i].numVertices = mdS->numVerts;
+ retModel->meshes[i].uvs = (float*)Z_Malloc(sizeof(float)*2*mdS->numVerts, ztag, 0);
+ for (j = 0; j < mdS->numFrames; j++)
+ {
+ short *vertptr;
+ char *normptr;
+ // char *tanptr;
+ int k;
+ md3Vertex *mdV = (md3Vertex*)((char*)mdS + mdS->offsetXYZNormal + (mdS->numVerts*j*sizeof(md3Vertex)));
+ retModel->meshes[i].tinyframes[j].vertices = (short*)Z_Malloc(sizeof(short)*3*mdS->numVerts, ztag, 0);
+ retModel->meshes[i].tinyframes[j].normals = (char*)Z_Malloc(sizeof(char)*3*mdS->numVerts, ztag, 0);
+
+// if (retModel->materials[0].lightmap)
+// retModel->meshes[i].tinyframes[j].tangents = (char*)malloc(sizeof(char));//(char*)Z_Malloc(sizeof(char)*3*mdS->numVerts, ztag);
+ retModel->meshes[i].indices = (unsigned short*)Z_Malloc(sizeof(unsigned short) * 3 * mdS->numTriangles, ztag, 0);
+ vertptr = retModel->meshes[i].tinyframes[j].vertices;
+ normptr = retModel->meshes[i].tinyframes[j].normals;
+
+// tanptr = retModel->meshes[i].tinyframes[j].tangents;
+ retModel->meshes[i].tinyframes[j].material = &retModel->materials[i];
+
+ for (k = 0; k < mdS->numVerts; k++)
+ {
+ // Vertex
+ *vertptr = mdV[k].x;
+ vertptr++;
+ *vertptr = mdV[k].z;
+ vertptr++;
+ *vertptr = 1.0f - mdV[k].y;
+ vertptr++;
+
+ // Normal
+ GetNormalFromLatLong(mdV[k].n, tempNormal);
+ *normptr = (char)(tempNormal[0] * 127);
+ normptr++;
+ *normptr = (char)(tempNormal[2] * 127);
+ normptr++;
+ *normptr = (char)(tempNormal[1] * 127);
+ normptr++;
+ }
+ }
+
+ uvptr = (float*)retModel->meshes[i].uvs;
+ mdST = (md3TexCoord*)((char*)mdS + mdS->offsetST);
+ for (j = 0; j < mdS->numVerts; j++)
+ {
+ *uvptr = mdST[j].st[0];
+ uvptr++;
+ *uvptr = mdST[j].st[1];
+ uvptr++;
+ }
+
+ indexptr = retModel->meshes[i].indices;
+ mdT = (md3Triangle*)((char*)mdS + mdS->offsetTriangles);
+ for (j = 0; j < mdS->numTriangles; j++, mdT++)
+ {
+ // Indices
+ *indexptr = (unsigned short)mdT->index[0];
+ indexptr++;
+ *indexptr = (unsigned short)mdT->index[1];
+ indexptr++;
+ *indexptr = (unsigned short)mdT->index[2];
+ indexptr++;
+ }
+ }
+ else // Traditional full-float loading method
+ {
+ float dataScale = 0.015624f * WUNITS;
+ float tempNormal[3];
+ md3TexCoord *mdST;
+ md3Triangle *mdT;
+ float *uvptr;
+ int k;
+
+ retModel->meshes[i].numVertices = mdS->numTriangles * 3;//mdS->numVerts;
+ retModel->meshes[i].frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t)*mdS->numFrames, ztag, 0);
+ retModel->meshes[i].uvs = (float*)Z_Malloc(sizeof(float)*2*mdS->numTriangles*3, ztag, 0);
+
+ for (j = 0; j < mdS->numFrames; j++)
+ {
+ float *vertptr;
+ float *normptr;
+ md3Vertex *mdV = (md3Vertex*)((char*)mdS + mdS->offsetXYZNormal + (mdS->numVerts*j*sizeof(md3Vertex)));
+ retModel->meshes[i].frames[j].vertices = (float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag, 0);
+ retModel->meshes[i].frames[j].normals = (float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag, 0);
+// if (retModel->materials[i].lightmap)
+// retModel->meshes[i].frames[j].tangents = (float*)malloc(sizeof(float));//(float*)Z_Malloc(sizeof(float)*3*mdS->numTriangles*3, ztag);
+ vertptr = retModel->meshes[i].frames[j].vertices;
+ normptr = retModel->meshes[i].frames[j].normals;
+ retModel->meshes[i].frames[j].material = &retModel->materials[i];
+
+ mdT = (md3Triangle*)((char*)mdS + mdS->offsetTriangles);
+
+ for (k = 0; k < mdS->numTriangles; k++)
+ {
+ // Vertex 1
+ *vertptr = mdV[mdT->index[0]].x * dataScale;
+ vertptr++;
+ *vertptr = mdV[mdT->index[0]].z * dataScale;
+ vertptr++;
+ *vertptr = 1.0f - mdV[mdT->index[0]].y * dataScale;
+ vertptr++;
+
+ GetNormalFromLatLong(mdV[mdT->index[0]].n, tempNormal);
+ *normptr = tempNormal[0];
+ normptr++;
+ *normptr = tempNormal[2];
+ normptr++;
+ *normptr = tempNormal[1];
+ normptr++;
+
+ // Vertex 2
+ *vertptr = mdV[mdT->index[1]].x * dataScale;
+ vertptr++;
+ *vertptr = mdV[mdT->index[1]].z * dataScale;
+ vertptr++;
+ *vertptr = 1.0f - mdV[mdT->index[1]].y * dataScale;
+ vertptr++;
+
+ GetNormalFromLatLong(mdV[mdT->index[1]].n, tempNormal);
+ *normptr = tempNormal[0];
+ normptr++;
+ *normptr = tempNormal[2];
+ normptr++;
+ *normptr = tempNormal[1];
+ normptr++;
+
+ // Vertex 3
+ *vertptr = mdV[mdT->index[2]].x * dataScale;
+ vertptr++;
+ *vertptr = mdV[mdT->index[2]].z * dataScale;
+ vertptr++;
+ *vertptr = 1.0f - mdV[mdT->index[2]].y * dataScale;
+ vertptr++;
+
+ GetNormalFromLatLong(mdV[mdT->index[2]].n, tempNormal);
+ *normptr = tempNormal[0];
+ normptr++;
+ *normptr = tempNormal[2];
+ normptr++;
+ *normptr = tempNormal[1];
+ normptr++;
+
+ mdT++; // Advance to next triangle
+ }
+ }
+
+ mdST = (md3TexCoord*)((char*)mdS + mdS->offsetST);
+ uvptr = (float*)retModel->meshes[i].uvs;
+ mdT = (md3Triangle*)((char*)mdS + mdS->offsetTriangles);
+
+ for (k = 0; k < mdS->numTriangles; k++)
+ {
+ *uvptr = mdST[mdT->index[0]].st[0];
+ uvptr++;
+ *uvptr = mdST[mdT->index[0]].st[1];
+ uvptr++;
+
+ *uvptr = mdST[mdT->index[1]].st[0];
+ uvptr++;
+ *uvptr = mdST[mdT->index[1]].st[1];
+ uvptr++;
+
+ *uvptr = mdST[mdT->index[2]].st[0];
+ uvptr++;
+ *uvptr = mdST[mdT->index[2]].st[1];
+ uvptr++;
+
+ mdT++; // Advance to next triangle
+ }
+ }
+ }
+ /*
+ // Tags?
+ retModel->numTags = mdh->numTags;
+ retModel->maxNumFrames = mdh->numFrames;
+ retModel->tags = (tag_t*)Z_Calloc(sizeof(tag_t) * retModel->numTags * mdh->numFrames, ztag);
+ md3Tag *mdTag = (md3Tag*)&buffer[mdh->offsetTags];
+ tag_t *curTag = retModel->tags;
+ for (i = 0; i < mdh->numFrames; i++)
+ {
+ int j;
+ for (j = 0; j < retModel->numTags; j++, mdTag++)
+ {
+ strcpys(curTag->name, mdTag->name, sizeof(curTag->name) / sizeof(char));
+ curTag->transform.m[0][0] = mdTag->axis[0];
+ curTag->transform.m[0][1] = mdTag->axis[1];
+ curTag->transform.m[0][2] = mdTag->axis[2];
+ curTag->transform.m[1][0] = mdTag->axis[3];
+ curTag->transform.m[1][1] = mdTag->axis[4];
+ curTag->transform.m[1][2] = mdTag->axis[5];
+ curTag->transform.m[2][0] = mdTag->axis[6];
+ curTag->transform.m[2][1] = mdTag->axis[7];
+ curTag->transform.m[2][2] = mdTag->axis[8];
+ curTag->transform.m[3][0] = mdTag->origin[0] * WUNITS;
+ curTag->transform.m[3][1] = mdTag->origin[1] * WUNITS;
+ curTag->transform.m[3][2] = mdTag->origin[2] * WUNITS;
+ curTag->transform.m[3][3] = 1.0f;
+
+ Matrix::Rotate(&curTag->transform, 90.0f, &Vector::Xaxis);
+ curTag++;
+ }
+ }*/
+
+
+ free(buffer);
+
+ return retModel;
+}
diff --git a/src/hardware/hw_md3load.h b/src/hardware/hw_md3load.h
new file mode 100644
index 0000000000000000000000000000000000000000..c0e0522ff6bf2e6e43c96021ab758ca64ae7b45b
--- /dev/null
+++ b/src/hardware/hw_md3load.h
@@ -0,0 +1,19 @@
+/*
+ From the 'Wizard2' engine by Spaddlewit Inc. ( http://www.spaddlewit.com )
+ An experimental work-in-progress.
+
+ Donated to Sonic Team Junior and adapted to work with
+ Sonic Robo Blast 2. The license of this code matches whatever
+ the licensing is for Sonic Robo Blast 2.
+*/
+
+#ifndef _HW_MD3LOAD_H_
+#define _HW_MD3LOAD_H_
+
+#include "hw_model.h"
+#include "../doomtype.h"
+
+// Load the Model
+model_t *MD3_LoadModel(const char *fileName, int ztag, boolean useFloat);
+
+#endif
diff --git a/src/hardware/hw_model.c b/src/hardware/hw_model.c
new file mode 100644
index 0000000000000000000000000000000000000000..ac73f8acac4b577f1ca18bd077e8bba837f320d8
--- /dev/null
+++ b/src/hardware/hw_model.c
@@ -0,0 +1,737 @@
+/*
+ From the 'Wizard2' engine by Spaddlewit Inc. ( http://www.spaddlewit.com )
+ An experimental work-in-progress.
+
+ Donated to Sonic Team Junior and adapted to work with
+ Sonic Robo Blast 2. The license of this code matches whatever
+ the licensing is for Sonic Robo Blast 2.
+*/
+
+#include "../doomdef.h"
+#include "../doomtype.h"
+#include "../info.h"
+#include "../z_zone.h"
+#include "hw_model.h"
+#include "hw_md2load.h"
+#include "hw_md3load.h"
+#include "hw_md2.h"
+#include "u_list.h"
+#include <string.h>
+
+static float PI = (3.1415926535897932384626433832795f);
+static float U_Deg2Rad(float deg)
+{
+ return deg * ((float)PI / 180.0f);
+}
+
+vector_t vectorXaxis = { 1.0f, 0.0f, 0.0f };
+vector_t vectorYaxis = { 0.0f, 1.0f, 0.0f };
+vector_t vectorZaxis = { 0.0f, 0.0f, 1.0f };
+
+void VectorRotate(vector_t *rotVec, const vector_t *axisVec, float angle)
+{
+ float ux, uy, uz, vx, vy, vz, wx, wy, wz, sa, ca;
+
+ angle = U_Deg2Rad(angle);
+
+ // Rotate the point (x,y,z) around the vector (u,v,w)
+ ux = axisVec->x * rotVec->x;
+ uy = axisVec->x * rotVec->y;
+ uz = axisVec->x * rotVec->z;
+ vx = axisVec->y * rotVec->x;
+ vy = axisVec->y * rotVec->y;
+ vz = axisVec->y * rotVec->z;
+ wx = axisVec->z * rotVec->x;
+ wy = axisVec->z * rotVec->y;
+ wz = axisVec->z * rotVec->z;
+ sa = sinf(angle);
+ ca = cosf(angle);
+
+ rotVec->x = axisVec->x*(ux + vy + wz) + (rotVec->x*(axisVec->y*axisVec->y + axisVec->z*axisVec->z) - axisVec->x*(vy + wz))*ca + (-wy + vz)*sa;
+ rotVec->y = axisVec->y*(ux + vy + wz) + (rotVec->y*(axisVec->x*axisVec->x + axisVec->z*axisVec->z) - axisVec->y*(ux + wz))*ca + (wx - uz)*sa;
+ rotVec->z = axisVec->z*(ux + vy + wz) + (rotVec->z*(axisVec->x*axisVec->x + axisVec->y*axisVec->y) - axisVec->z*(ux + vy))*ca + (-vx + uy)*sa;
+}
+
+void UnloadModel(model_t *model)
+{
+ // Wouldn't it be great if C just had destructors?
+ int i;
+ for (i = 0; i < model->numMeshes; i++)
+ {
+ mesh_t *mesh = &model->meshes[i];
+
+ if (mesh->frames)
+ {
+ int j;
+ for (j = 0; j < mesh->numFrames; j++)
+ {
+ if (mesh->frames[j].normals)
+ Z_Free(mesh->frames[j].normals);
+
+ if (mesh->frames[j].tangents)
+ Z_Free(mesh->frames[j].tangents);
+
+ if (mesh->frames[j].vertices)
+ Z_Free(mesh->frames[j].vertices);
+
+ if (mesh->frames[j].colors)
+ Z_Free(mesh->frames[j].colors);
+ }
+
+ Z_Free(mesh->frames);
+ }
+ else if (mesh->tinyframes)
+ {
+ int j;
+ for (j = 0; j < mesh->numFrames; j++)
+ {
+ if (mesh->tinyframes[j].normals)
+ Z_Free(mesh->tinyframes[j].normals);
+
+ if (mesh->tinyframes[j].tangents)
+ Z_Free(mesh->tinyframes[j].tangents);
+
+ if (mesh->tinyframes[j].vertices)
+ Z_Free(mesh->tinyframes[j].vertices);
+ }
+
+ if (mesh->indices)
+ Z_Free(mesh->indices);
+
+ Z_Free(mesh->tinyframes);
+ }
+
+ if (mesh->uvs)
+ Z_Free(mesh->uvs);
+
+ if (mesh->lightuvs)
+ Z_Free(mesh->lightuvs);
+ }
+
+ if (model->meshes)
+ Z_Free(model->meshes);
+
+ if (model->tags)
+ Z_Free(model->tags);
+
+ if (model->materials)
+ Z_Free(model->materials);
+
+ DeleteVBOs(model);
+ Z_Free(model);
+}
+
+tag_t *GetTagByName(model_t *model, char *name, int frame)
+{
+ if (frame < model->maxNumFrames)
+ {
+ tag_t *iterator = &model->tags[frame * model->numTags];
+
+ int i;
+ for (i = 0; i < model->numTags; i++)
+ {
+ if (!stricmp(iterator[i].name, name))
+ return &iterator[i];
+ }
+ }
+
+ return NULL;
+}
+
+//
+// LoadModel
+//
+// Load a model and
+// convert it to the
+// internal format.
+//
+model_t *LoadModel(const char *filename, int ztag)
+{
+ model_t *model;
+
+ // What type of file?
+ const char *extension = NULL;
+ int i;
+ for (i = (int)strlen(filename)-1; i >= 0; i--)
+ {
+ if (filename[i] != '.')
+ continue;
+
+ extension = &filename[i];
+ break;
+ }
+
+ if (!extension)
+ {
+ CONS_Printf("Model %s is lacking a file extension, unable to determine type!\n", filename);
+ return NULL;
+ }
+
+ if (!strcmp(extension, ".md3"))
+ {
+ if (!(model = MD3_LoadModel(filename, ztag, false)))
+ return NULL;
+ }
+ else if (!strcmp(extension, ".md3s")) // MD3 that will be converted in memory to use full floats
+ {
+ if (!(model = MD3_LoadModel(filename, ztag, true)))
+ return NULL;
+ }
+ else if (!strcmp(extension, ".md2"))
+ {
+ if (!(model = MD2_LoadModel(filename, ztag, false)))
+ return NULL;
+ }
+ else if (!strcmp(extension, ".md2s"))
+ {
+ if (!(model = MD2_LoadModel(filename, ztag, true)))
+ return NULL;
+ }
+ else
+ {
+ CONS_Printf("Unknown model format: %s\n", extension);
+ return NULL;
+ }
+
+ model->mdlFilename = (char*)Z_Malloc(strlen(filename)+1, ztag, 0);
+ strcpy(model->mdlFilename, filename);
+
+ Optimize(model);
+ GeneratePolygonNormals(model, ztag);
+ LoadModelSprite2(model);
+ if (!model->spr2frames)
+ LoadModelInterpolationSettings(model);
+
+ // Default material properties
+ for (i = 0 ; i < model->numMaterials; i++)
+ {
+ material_t *material = &model->materials[i];
+ material->ambient[0] = 0.7686f;
+ material->ambient[1] = 0.7686f;
+ material->ambient[2] = 0.7686f;
+ material->ambient[3] = 1.0f;
+ material->diffuse[0] = 0.5863f;
+ material->diffuse[1] = 0.5863f;
+ material->diffuse[2] = 0.5863f;
+ material->diffuse[3] = 1.0f;
+ material->specular[0] = 0.4902f;
+ material->specular[1] = 0.4902f;
+ material->specular[2] = 0.4902f;
+ material->specular[3] = 1.0f;
+ material->shininess = 25.0f;
+ }
+
+ return model;
+}
+
+void HWR_ReloadModels(void)
+{
+ size_t i;
+ INT32 s;
+
+ for (s = 0; s < MAXSKINS; s++)
+ {
+ if (md2_playermodels[s].model)
+ LoadModelSprite2(md2_playermodels[s].model);
+ }
+
+ for (i = 0; i < NUMSPRITES; i++)
+ {
+ if (md2_models[i].model)
+ LoadModelInterpolationSettings(md2_models[i].model);
+ }
+}
+
+void LoadModelInterpolationSettings(model_t *model)
+{
+ INT32 i;
+ INT32 numframes = model->meshes[0].numFrames;
+ char *framename = model->framenames;
+
+ if (!framename)
+ return;
+
+ #define GET_OFFSET \
+ memcpy(&interpolation_flag, framename + offset, 2); \
+ model->interpolate[i] = (!memcmp(interpolation_flag, MODEL_INTERPOLATION_FLAG, 2));
+
+ for (i = 0; i < numframes; i++)
+ {
+ int offset = (strlen(framename) - 4);
+ char interpolation_flag[3];
+ memset(&interpolation_flag, 0x00, 3);
+
+ // find the +i on the frame name
+ // ANIM+i00
+ // so the offset is (frame name length - 4)
+ GET_OFFSET;
+
+ // maybe the frame had three digits?
+ // ANIM+i000
+ // so the offset is (frame name length - 5)
+ if (!model->interpolate[i])
+ {
+ offset--;
+ GET_OFFSET;
+ }
+
+ framename += 16;
+ }
+
+ #undef GET_OFFSET
+}
+
+void LoadModelSprite2(model_t *model)
+{
+ INT32 i;
+ modelspr2frames_t *spr2frames = NULL;
+ INT32 numframes = model->meshes[0].numFrames;
+ char *framename = model->framenames;
+
+ if (!framename)
+ return;
+
+ for (i = 0; i < numframes; i++)
+ {
+ char prefix[6];
+ char name[5];
+ char interpolation_flag[3];
+ char framechars[4];
+ UINT8 frame = 0;
+ UINT8 spr2idx;
+ boolean interpolate = false;
+
+ memset(&prefix, 0x00, 6);
+ memset(&name, 0x00, 5);
+ memset(&interpolation_flag, 0x00, 3);
+ memset(&framechars, 0x00, 4);
+
+ if (strlen(framename) >= 9)
+ {
+ boolean super;
+ char *modelframename = framename;
+ memcpy(&prefix, modelframename, 5);
+ modelframename += 5;
+ memcpy(&name, modelframename, 4);
+ modelframename += 4;
+ // Oh look
+ memcpy(&interpolation_flag, modelframename, 2);
+ if (!memcmp(interpolation_flag, MODEL_INTERPOLATION_FLAG, 2))
+ {
+ interpolate = true;
+ modelframename += 2;
+ }
+ memcpy(&framechars, modelframename, 3);
+
+ if ((super = (!memcmp(prefix, "SUPER", 5))) || (!memcmp(prefix, "SPR2_", 5)))
+ {
+ spr2idx = 0;
+ while (spr2idx < free_spr2)
+ {
+ if (!memcmp(spr2names[spr2idx], name, 4))
+ {
+ if (!spr2frames)
+ spr2frames = (modelspr2frames_t*)Z_Calloc(sizeof(modelspr2frames_t)*NUMPLAYERSPRITES*2, PU_STATIC, NULL);
+ if (super)
+ spr2idx |= FF_SPR2SUPER;
+ if (framechars[0])
+ {
+ frame = atoi(framechars);
+ if (spr2frames[spr2idx].numframes < frame+1)
+ spr2frames[spr2idx].numframes = frame+1;
+ }
+ else
+ {
+ frame = spr2frames[spr2idx].numframes;
+ spr2frames[spr2idx].numframes++;
+ }
+ spr2frames[spr2idx].frames[frame] = i;
+ spr2frames[spr2idx].interpolate = interpolate;
+ break;
+ }
+ spr2idx++;
+ }
+ }
+ }
+
+ framename += 16;
+ }
+
+ if (model->spr2frames)
+ Z_Free(model->spr2frames);
+ model->spr2frames = spr2frames;
+}
+
+//
+// GenerateVertexNormals
+//
+// Creates a new normal for a vertex using the average of all of the polygons it belongs to.
+//
+void GenerateVertexNormals(model_t *model)
+{
+ int i;
+ for (i = 0; i < model->numMeshes; i++)
+ {
+ int j;
+
+ mesh_t *mesh = &model->meshes[i];
+
+ if (!mesh->frames)
+ continue;
+
+ for (j = 0; j < mesh->numFrames; j++)
+ {
+ mdlframe_t *frame = &mesh->frames[j];
+ int memTag = PU_STATIC;
+ float *newNormals = (float*)Z_Malloc(sizeof(float)*3*mesh->numTriangles*3, memTag, 0);
+ int k;
+ float *vertPtr = frame->vertices;
+ float *oldNormals;
+
+ M_Memcpy(newNormals, frame->normals, sizeof(float)*3*mesh->numTriangles*3);
+
+/* if (!systemSucks)
+ {
+ memTag = Z_GetTag(frame->tangents);
+ float *newTangents = (float*)Z_Malloc(sizeof(float)*3*mesh->numTriangles*3, memTag);
+ M_Memcpy(newTangents, frame->tangents, sizeof(float)*3*mesh->numTriangles*3);
+ }*/
+
+ for (k = 0; k < mesh->numVertices; k++)
+ {
+ float x, y, z;
+ int vCount = 0;
+ vector_t normal;
+ int l;
+ float *testPtr = frame->vertices;
+
+ x = *vertPtr++;
+ y = *vertPtr++;
+ z = *vertPtr++;
+
+ normal.x = normal.y = normal.z = 0;
+
+ for (l = 0; l < mesh->numVertices; l++)
+ {
+ float testX, testY, testZ;
+ testX = *testPtr++;
+ testY = *testPtr++;
+ testZ = *testPtr++;
+
+ if (fabsf(x - testX) > FLT_EPSILON
+ || fabsf(y - testY) > FLT_EPSILON
+ || fabsf(z - testZ) > FLT_EPSILON)
+ continue;
+
+ // Found a vertex match! Add it...
+ normal.x += frame->normals[3 * l + 0];
+ normal.y += frame->normals[3 * l + 1];
+ normal.z += frame->normals[3 * l + 2];
+ vCount++;
+ }
+
+ if (vCount > 1)
+ {
+// Vector::Normalize(&normal);
+ newNormals[3 * k + 0] = (float)normal.x;
+ newNormals[3 * k + 1] = (float)normal.y;
+ newNormals[3 * k + 2] = (float)normal.z;
+
+/* if (!systemSucks)
+ {
+ Vector::vector_t tangent;
+ Vector::Tangent(&normal, &tangent);
+ newTangents[3 * k + 0] = tangent.x;
+ newTangents[3 * k + 1] = tangent.y;
+ newTangents[3 * k + 2] = tangent.z;
+ }*/
+ }
+ }
+
+ oldNormals = frame->normals;
+ frame->normals = newNormals;
+ Z_Free(oldNormals);
+
+/* if (!systemSucks)
+ {
+ float *oldTangents = frame->tangents;
+ frame->tangents = newTangents;
+ Z_Free(oldTangents);
+ }*/
+ }
+ }
+}
+
+typedef struct materiallist_s
+{
+ struct materiallist_s *next;
+ struct materiallist_s *prev;
+ material_t *material;
+} materiallist_t;
+
+static boolean AddMaterialToList(materiallist_t **head, material_t *material)
+{
+ materiallist_t *node, *newMatNode;
+ for (node = *head; node; node = node->next)
+ {
+ if (node->material == material)
+ return false;
+ }
+
+ // Didn't find it, so add to the list
+ newMatNode = (materiallist_t*)Z_Malloc(sizeof(materiallist_t), PU_CACHE, 0);
+ newMatNode->material = material;
+ ListAdd(newMatNode, (listitem_t**)head);
+ return true;
+}
+
+//
+// Optimize
+//
+// Groups triangles from meshes in the model
+// Only works for models with 1 frame
+//
+void Optimize(model_t *model)
+{
+ int numMeshes = 0;
+ int i;
+ materiallist_t *matListHead = NULL;
+ int memTag;
+ mesh_t *newMeshes;
+ materiallist_t *node;
+
+ if (model->numMeshes <= 1)
+ return; // No need
+
+ for (i = 0; i < model->numMeshes; i++)
+ {
+ mesh_t *curMesh = &model->meshes[i];
+
+ if (curMesh->numFrames > 1)
+ return; // Can't optimize models with > 1 frame
+
+ if (!curMesh->frames)
+ return; // Don't optimize tinyframe models (no need)
+
+ // We are condensing to 1 mesh per material, so
+ // the # of materials we use will be the new
+ // # of meshes
+ if (AddMaterialToList(&matListHead, curMesh->frames[0].material))
+ numMeshes++;
+ }
+
+ memTag = PU_STATIC;
+ newMeshes = (mesh_t*)Z_Calloc(sizeof(mesh_t) * numMeshes, memTag, 0);
+
+ i = 0;
+ for (node = matListHead; node; node = node->next)
+ {
+ material_t *curMat = node->material;
+ mesh_t *newMesh = &newMeshes[i];
+ mdlframe_t *curFrame;
+ int uvCount;
+ int vertCount;
+ int colorCount;
+
+ // Find all triangles with this material and count them
+ int numTriangles = 0;
+ int j;
+ for (j = 0; j < model->numMeshes; j++)
+ {
+ mesh_t *curMesh = &model->meshes[j];
+
+ if (curMesh->frames[0].material == curMat)
+ numTriangles += curMesh->numTriangles;
+ }
+
+ newMesh->numFrames = 1;
+ newMesh->numTriangles = numTriangles;
+ newMesh->numVertices = numTriangles * 3;
+ newMesh->uvs = (float*)Z_Malloc(sizeof(float)*2*numTriangles*3, memTag, 0);
+// if (node->material->lightmap)
+// newMesh->lightuvs = (float*)Z_Malloc(sizeof(float)*2*numTriangles*3, memTag, 0);
+ newMesh->frames = (mdlframe_t*)Z_Calloc(sizeof(mdlframe_t), memTag, 0);
+ curFrame = &newMesh->frames[0];
+
+ curFrame->material = curMat;
+ curFrame->normals = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, 0);
+// if (!systemSucks)
+// curFrame->tangents = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, 0);
+ curFrame->vertices = (float*)Z_Malloc(sizeof(float)*3*numTriangles*3, memTag, 0);
+ curFrame->colors = (char*)Z_Malloc(sizeof(char)*4*numTriangles*3, memTag, 0);
+
+ // Now traverse the meshes of the model, adding in
+ // vertices/normals/uvs that match the current material
+ uvCount = 0;
+ vertCount = 0;
+ colorCount = 0;
+ for (j = 0; j < model->numMeshes; j++)
+ {
+ mesh_t *curMesh = &model->meshes[j];
+
+ if (curMesh->frames[0].material == curMat)
+ {
+ float *dest;
+ float *src;
+ char *destByte;
+ char *srcByte;
+
+ M_Memcpy(&newMesh->uvs[uvCount],
+ curMesh->uvs,
+ sizeof(float)*2*curMesh->numTriangles*3);
+
+/* if (node->material->lightmap)
+ {
+ M_Memcpy(&newMesh->lightuvs[uvCount],
+ curMesh->lightuvs,
+ sizeof(float)*2*curMesh->numTriangles*3);
+ }*/
+ uvCount += 2*curMesh->numTriangles*3;
+
+ dest = (float*)newMesh->frames[0].vertices;
+ src = (float*)curMesh->frames[0].vertices;
+ M_Memcpy(&dest[vertCount],
+ src,
+ sizeof(float)*3*curMesh->numTriangles*3);
+
+ dest = (float*)newMesh->frames[0].normals;
+ src = (float*)curMesh->frames[0].normals;
+ M_Memcpy(&dest[vertCount],
+ src,
+ sizeof(float)*3*curMesh->numTriangles*3);
+
+/* if (!systemSucks)
+ {
+ dest = (float*)newMesh->frames[0].tangents;
+ src = (float*)curMesh->frames[0].tangents;
+ M_Memcpy(&dest[vertCount],
+ src,
+ sizeof(float)*3*curMesh->numTriangles*3);
+ }*/
+
+ vertCount += 3 * curMesh->numTriangles * 3;
+
+ destByte = (char*)newMesh->frames[0].colors;
+ srcByte = (char*)curMesh->frames[0].colors;
+
+ if (srcByte)
+ {
+ M_Memcpy(&destByte[colorCount],
+ srcByte,
+ sizeof(char)*4*curMesh->numTriangles*3);
+ }
+ else
+ {
+ memset(&destByte[colorCount],
+ 255,
+ sizeof(char)*4*curMesh->numTriangles*3);
+ }
+
+ colorCount += 4 * curMesh->numTriangles * 3;
+ }
+ }
+
+ i++;
+ }
+
+ CONS_Printf("Model::Optimize(): Model reduced from %d to %d meshes.\n", model->numMeshes, numMeshes);
+ model->meshes = newMeshes;
+ model->numMeshes = numMeshes;
+}
+
+void GeneratePolygonNormals(model_t *model, int ztag)
+{
+ int i;
+ for (i = 0; i < model->numMeshes; i++)
+ {
+ int j;
+ mesh_t *mesh = &model->meshes[i];
+
+ if (!mesh->frames)
+ continue;
+
+ for (j = 0; j < mesh->numFrames; j++)
+ {
+ int k;
+ mdlframe_t *frame = &mesh->frames[j];
+ const float *vertices = frame->vertices;
+ vector_t *polyNormals;
+
+ frame->polyNormals = (vector_t*)Z_Malloc(sizeof(vector_t) * mesh->numTriangles, ztag, 0);
+
+ polyNormals = frame->polyNormals;
+
+ for (k = 0; k < mesh->numTriangles; k++)
+ {
+// Vector::Normal(vertices, polyNormals);
+ vertices += 3 * 3;
+ polyNormals++;
+ }
+ }
+ }
+}
+
+//
+// Reload
+//
+// Reload VBOs
+//
+#if 0
+static void Reload(void)
+{
+/* model_t *node;
+ for (node = modelHead; node; node = node->next)
+ {
+ int i;
+ for (i = 0; i < node->numMeshes; i++)
+ {
+ mesh_t *mesh = &node->meshes[i];
+
+ if (mesh->frames)
+ {
+ int j;
+ for (j = 0; j < mesh->numFrames; j++)
+ CreateVBO(mesh, &mesh->frames[j]);
+ }
+ else if (mesh->tinyframes)
+ {
+ int j;
+ for (j = 0; j < mesh->numFrames; j++)
+ CreateVBO(mesh, &mesh->tinyframes[j]);
+ }
+ }
+ }*/
+}
+#endif
+
+void DeleteVBOs(model_t *model)
+{
+ (void)model;
+/* for (int i = 0; i < model->numMeshes; i++)
+ {
+ mesh_t *mesh = &model->meshes[i];
+
+ if (mesh->frames)
+ {
+ for (int j = 0; j < mesh->numFrames; j++)
+ {
+ mdlframe_t *frame = &mesh->frames[j];
+ if (!frame->vboID)
+ continue;
+ bglDeleteBuffers(1, &frame->vboID);
+ frame->vboID = 0;
+ }
+ }
+ else if (mesh->tinyframes)
+ {
+ for (int j = 0; j < mesh->numFrames; j++)
+ {
+ tinyframe_t *frame = &mesh->tinyframes[j];
+ if (!frame->vboID)
+ continue;
+ bglDeleteBuffers(1, &frame->vboID);
+ frame->vboID = 0;
+ }
+ }
+ }*/
+}
diff --git a/src/hardware/hw_model.h b/src/hardware/hw_model.h
new file mode 100644
index 0000000000000000000000000000000000000000..2a5240bdefbda6320fa2411b451a5bf86408124e
--- /dev/null
+++ b/src/hardware/hw_model.h
@@ -0,0 +1,121 @@
+/*
+ From the 'Wizard2' engine by Spaddlewit Inc. ( http://www.spaddlewit.com )
+ An experimental work-in-progress.
+
+ Donated to Sonic Team Junior and adapted to work with
+ Sonic Robo Blast 2. The license of this code matches whatever
+ the licensing is for Sonic Robo Blast 2.
+*/
+
+#ifndef _HW_MODEL_H_
+#define _HW_MODEL_H_
+
+#include "../doomtype.h"
+
+typedef struct
+{
+ float x, y, z;
+} vector_t;
+
+extern vector_t vectorXaxis;
+extern vector_t vectorYaxis;
+extern vector_t vectorZaxis;
+
+void VectorRotate(vector_t *rotVec, const vector_t *axisVec, float angle);
+
+typedef struct
+{
+ float ambient[4], diffuse[4], specular[4], emissive[4];
+ float shininess;
+ boolean spheremap;
+// Texture::texture_t *texture;
+// Texture::texture_t *lightmap;
+} material_t;
+
+typedef struct
+{
+ material_t *material; // Pointer to the allocated 'materials' list in model_t
+ float *vertices;
+ float *normals;
+ float *tangents;
+ char *colors;
+ unsigned int vboID;
+ vector_t *polyNormals;
+} mdlframe_t;
+
+typedef struct
+{
+ material_t *material;
+ short *vertices;
+ char *normals;
+ char *tangents;
+ unsigned int vboID;
+} tinyframe_t;
+
+// Equivalent to MD3's many 'surfaces'
+typedef struct mesh_s
+{
+ int numVertices;
+ int numTriangles;
+
+ float *uvs;
+ float *lightuvs;
+
+ int numFrames;
+ mdlframe_t *frames;
+ tinyframe_t *tinyframes;
+ unsigned short *indices;
+} mesh_t;
+
+typedef struct tag_s
+{
+ char name[64];
+// matrix_t transform;
+} tag_t;
+
+#define MODEL_INTERPOLATION_FLAG "+i"
+
+typedef struct
+{
+ INT32 frames[256];
+ UINT8 numframes;
+ boolean interpolate;
+} modelspr2frames_t;
+
+typedef struct model_s
+{
+ int maxNumFrames;
+
+ int numMaterials;
+ material_t *materials;
+ int numMeshes;
+ mesh_t *meshes;
+ int numTags;
+ tag_t *tags;
+
+ char *mdlFilename;
+ boolean unloaded;
+
+ char *framenames;
+ boolean interpolate[256];
+ modelspr2frames_t *spr2frames;
+} model_t;
+
+extern int numModels;
+extern model_t *modelHead;
+
+void HWR_ReloadModels(void);
+
+tag_t *GetTagByName(model_t *model, char *name, int frame);
+model_t *LoadModel(const char *filename, int ztag);
+void UnloadModel(model_t *model);
+void Optimize(model_t *model);
+void LoadModelInterpolationSettings(model_t *model);
+void LoadModelSprite2(model_t *model);
+void GenerateVertexNormals(model_t *model);
+void GeneratePolygonNormals(model_t *model, int ztag);
+void CreateVBOTiny(mesh_t *mesh, tinyframe_t *frame);
+void CreateVBO(mesh_t *mesh, mdlframe_t *frame);
+void DeleteVBOs(model_t *model);
+
+#endif
diff --git a/src/hardware/r_opengl/ogl_win.c b/src/hardware/r_opengl/ogl_win.c
index eb9a31a7d7f1e909d72e88cc5bc3c166471b73ab..562afe9989e0908f046ece44abe2fcf22d2fa439 100644
--- a/src/hardware/r_opengl/ogl_win.c
+++ b/src/hardware/r_opengl/ogl_win.c
@@ -347,13 +347,6 @@ static INT32 WINAPI SetRes(viddef_t *lvid, vmode_t *pcurrentmode)
if (strstr(renderer, "810")) oglflags |= GLF_NOZBUFREAD;
DBG_Printf("oglflags : 0x%X\n", oglflags);
-#ifdef USE_PALETTED_TEXTURE
- if (isExtAvailable("GL_EXT_paletted_texture",gl_extensions))
- glColorTableEXT = GetGLFunc("glColorTableEXT");
- else
- glColorTableEXT = NULL;
-#endif
-
#ifdef USE_WGL_SWAP
if (isExtAvailable("WGL_EXT_swap_control",gl_extensions))
wglSwapIntervalEXT = GetGLFunc("wglSwapIntervalEXT");
@@ -582,19 +575,8 @@ EXPORT void HWRAPI(SetPalette) (RGBA_t *pal, RGBA_t *gamma)
myPaletteData[i].s.blue = (UINT8)MIN((pal[i].s.blue*gamma->s.blue)/127, 255);
myPaletteData[i].s.alpha = pal[i].s.alpha;
}
-#ifdef USE_PALETTED_TEXTURE
- if (glColorTableEXT)
- {
- for (i = 0; i < 256; i++)
- {
- palette_tex[3*i+0] = pal[i].s.red;
- palette_tex[3*i+1] = pal[i].s.green;
- palette_tex[3*i+2] = pal[i].s.blue;
- }
- glColorTableEXT(GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, palette_tex);
- }
-#endif
- // on a chang� de palette, il faut recharger toutes les textures
+
+ // on a palette change, you have to reload all of the textures
Flush();
}
diff --git a/src/hardware/r_opengl/r_opengl.c b/src/hardware/r_opengl/r_opengl.c
index dfee19857cca3881adbd9dc123fd56b48aef7416..1a50854c7e21cb949e839c1b8fbf0b9263832074 100644
--- a/src/hardware/r_opengl/r_opengl.c
+++ b/src/hardware/r_opengl/r_opengl.c
@@ -29,13 +29,10 @@
#include <stdarg.h>
#include <math.h>
-#ifndef SHUFFLE
-#define SHUFFLE
-#endif
#include "r_opengl.h"
+#include "r_vbo.h"
#if defined (HWRENDER) && !defined (NOROPENGL)
-// for KOS: GL_TEXTURE_ENV, glAlphaFunc, glColorMask, glPolygonOffset, glReadPixels, GL_ALPHA_TEST, GL_POLYGON_OFFSET_FILL
struct GLRGBAFloat
{
@@ -45,6 +42,7 @@ struct GLRGBAFloat
GLfloat alpha;
};
typedef struct GLRGBAFloat GLRGBAFloat;
+static const GLubyte white[4] = { 255, 255, 255, 255 };
// ==========================================================================
// CONSTANTS
@@ -68,8 +66,10 @@ static float NEAR_CLIPPING_PLANE = NZCLIP_PLANE;
static GLuint NextTexAvail = FIRST_TEX_AVAIL;
static GLuint tex_downloaded = 0;
static GLfloat fov = 90.0f;
+#if 0
static GLuint pal_col = 0;
static FRGBAFloat const_pal_col;
+#endif
static FBITFIELD CurrentPolyFlags;
static FTextureInfo* gr_cachetail = NULL;
@@ -90,26 +90,20 @@ static FTransform md2_transform;
const GLubyte *gl_extensions = NULL;
//Hurdler: 04/10/2000: added for the kick ass coronas as Boris wanted;-)
-static GLdouble modelMatrix[16];
-static GLdouble projMatrix[16];
+static GLfloat modelMatrix[16];
+static GLfloat projMatrix[16];
static GLint viewport[4];
-
-#ifdef USE_PALETTED_TEXTURE
- PFNGLCOLORTABLEEXTPROC glColorTableEXT = NULL;
- GLubyte palette_tex[256*3];
-#endif
-
// Yay for arbitrary numbers! NextTexAvail is buggy for some reason.
// Sryder: NextTexAvail is broken for these because palette changes or changes to the texture filter or antialiasing
// flush all of the stored textures, leaving them unavailable at times such as between levels
// These need to start at 0 and be set to their number, and be reset to 0 when deleted so that intel GPUs
// can know when the textures aren't there, as textures are always considered resident in their virtual memory
// TODO: Store them in a more normal way
-#define SCRTEX_SCREENTEXTURE 65535
-#define SCRTEX_STARTSCREENWIPE 65534
-#define SCRTEX_ENDSCREENWIPE 65533
-#define SCRTEX_FINALSCREENTEXTURE 65532
+#define SCRTEX_SCREENTEXTURE 4294967295U
+#define SCRTEX_STARTSCREENWIPE 4294967294U
+#define SCRTEX_ENDSCREENWIPE 4294967293U
+#define SCRTEX_FINALSCREENTEXTURE 4294967292U
static GLuint screentexture = 0;
static GLuint startScreenWipe = 0;
static GLuint endScreenWipe = 0;
@@ -161,9 +155,6 @@ float byteasfloat(UINT8 fbyte)
static I_Error_t I_Error_GL = NULL;
-static boolean gl13 = false; // whether we can use opengl 1.3 functions
-
-
// -----------------+
// DBG_Printf : Output error messages to debug log if DEBUG_TO_FILE is defined,
// : else do nothing
@@ -194,14 +185,14 @@ FUNCPRINTF void DBG_Printf(const char *lpFmt, ...)
#define pglAlphaFunc glAlphaFunc
#define pglBlendFunc glBlendFunc
#define pglCullFace glCullFace
-#define pglPolygonMode glPolygonMode
#define pglPolygonOffset glPolygonOffset
#define pglScissor glScissor
#define pglEnable glEnable
#define pglDisable glDisable
-#define pglGetDoublev glGetDoublev
+#define pglGetFloatv glGetFloatv
//glGetIntegerv
//glGetString
+#define pglHint glHint
/* Depth Buffer */
#define pglClearDepth glClearDepth
@@ -215,19 +206,26 @@ FUNCPRINTF void DBG_Printf(const char *lpFmt, ...)
#define pglPushMatrix glPushMatrix
#define pglPopMatrix glPopMatrix
#define pglLoadIdentity glLoadIdentity
-#define pglMultMatrixd glMultMatrixd
+#define pglMultMatrixf glMultMatrixf
#define pglRotatef glRotatef
#define pglScalef glScalef
#define pglTranslatef glTranslatef
/* Drawing Functions */
-#define pglBegin glBegin
-#define pglEnd glEnd
-#define pglVertex3f glVertex3f
-#define pglNormal3f glNormal3f
-#define pglColor4f glColor4f
-#define pglColor4fv glColor4fv
-#define pglTexCoord2f glTexCoord2f
+#define pglColor4ubv glColor4ubv
+#define pglVertexPointer glVertexPointer
+#define pglNormalPointer glNormalPointer
+#define pglTexCoordPointer glTexCoordPointer
+#define pglColorPointer glColorPointer
+#define pglDrawArrays glDrawArrays
+#define pglDrawElements glDrawElements
+#define pglEnableClientState glEnableClientState
+#define pglDisableClientState glDisableClientState
+#define pglClientActiveTexture glClientActiveTexture
+#define pglGenBuffers glGenBuffers
+#define pglBindBuffer glBindBuffer
+#define pglBufferData glBufferData
+#define pglDeleteBuffers glDeleteBuffers
/* Lighting */
#define pglShadeModel glShadeModel
@@ -271,8 +269,6 @@ typedef void (APIENTRY * PFNglBlendFunc) (GLenum sfactor, GLenum dfactor);
static PFNglBlendFunc pglBlendFunc;
typedef void (APIENTRY * PFNglCullFace) (GLenum mode);
static PFNglCullFace pglCullFace;
-typedef void (APIENTRY * PFNglPolygonMode) (GLenum face, GLenum mode);
-static PFNglPolygonMode pglPolygonMode;
typedef void (APIENTRY * PFNglPolygonOffset) (GLfloat factor, GLfloat units);
static PFNglPolygonOffset pglPolygonOffset;
typedef void (APIENTRY * PFNglScissor) (GLint x, GLint y, GLsizei width, GLsizei height);
@@ -281,8 +277,8 @@ typedef void (APIENTRY * PFNglEnable) (GLenum cap);
static PFNglEnable pglEnable;
typedef void (APIENTRY * PFNglDisable) (GLenum cap);
static PFNglDisable pglDisable;
-typedef void (APIENTRY * PFNglGetDoublev) (GLenum pname, GLdouble *params);
-static PFNglGetDoublev pglGetDoublev;
+typedef void (APIENTRY * PFNglGetFloatv) (GLenum pname, GLfloat *params);
+static PFNglGetFloatv pglGetFloatv;
//glGetIntegerv
//glGetString
@@ -307,8 +303,8 @@ typedef void (APIENTRY * PFNglPopMatrix) (void);
static PFNglPopMatrix pglPopMatrix;
typedef void (APIENTRY * PFNglLoadIdentity) (void);
static PFNglLoadIdentity pglLoadIdentity;
-typedef void (APIENTRY * PFNglMultMatrixd) (const GLdouble *m);
-static PFNglMultMatrixd pglMultMatrixd;
+typedef void (APIENTRY * PFNglMultMatrixf) (const GLfloat *m);
+static PFNglMultMatrixf pglMultMatrixf;
typedef void (APIENTRY * PFNglRotatef) (GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
static PFNglRotatef pglRotatef;
typedef void (APIENTRY * PFNglScalef) (GLfloat x, GLfloat y, GLfloat z);
@@ -317,20 +313,33 @@ typedef void (APIENTRY * PFNglTranslatef) (GLfloat x, GLfloat y, GLfloat z);
static PFNglTranslatef pglTranslatef;
/* Drawing Functions */
-typedef void (APIENTRY * PFNglBegin) (GLenum mode);
-static PFNglBegin pglBegin;
-typedef void (APIENTRY * PFNglEnd) (void);
-static PFNglEnd pglEnd;
-typedef void (APIENTRY * PFNglVertex3f) (GLfloat x, GLfloat y, GLfloat z);
-static PFNglVertex3f pglVertex3f;
-typedef void (APIENTRY * PFNglNormal3f) (GLfloat x, GLfloat y, GLfloat z);
-static PFNglNormal3f pglNormal3f;
-typedef void (APIENTRY * PFNglColor4f) (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-static PFNglColor4f pglColor4f;
-typedef void (APIENTRY * PFNglColor4fv) (const GLfloat *v);
-static PFNglColor4fv pglColor4fv;
-typedef void (APIENTRY * PFNglTexCoord2f) (GLfloat s, GLfloat t);
-static PFNglTexCoord2f pglTexCoord2f;
+typedef void (APIENTRY * PFNglColor4ubv) (const GLubyte *v);
+static PFNglColor4ubv pglColor4ubv;
+typedef void (APIENTRY * PFNglVertexPointer) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static PFNglVertexPointer pglVertexPointer;
+typedef void (APIENTRY * PFNglNormalPointer) (GLenum type, GLsizei stride, const GLvoid *pointer);
+static PFNglNormalPointer pglNormalPointer;
+typedef void (APIENTRY * PFNglTexCoordPointer) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static PFNglTexCoordPointer pglTexCoordPointer;
+typedef void (APIENTRY * PFNglColorPointer) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+static PFNglColorPointer pglColorPointer;
+typedef void (APIENTRY * PFNglDrawArrays) (GLenum mode, GLint first, GLsizei count);
+static PFNglDrawArrays pglDrawArrays;
+typedef void (APIENTRY * PFNglDrawElements) (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+static PFNglDrawElements pglDrawElements;
+typedef void (APIENTRY * PFNglEnableClientState) (GLenum cap);
+static PFNglEnableClientState pglEnableClientState;
+typedef void (APIENTRY * PFNglDisableClientState) (GLenum cap);
+static PFNglDisableClientState pglDisableClientState;
+typedef void (APIENTRY * PFNglGenBuffers) (GLsizei n, GLuint *buffers);
+static PFNglGenBuffers pglGenBuffers;
+typedef void (APIENTRY * PFNglBindBuffer) (GLenum target, GLuint buffer);
+static PFNglBindBuffer pglBindBuffer;
+typedef void (APIENTRY * PFNglBufferData) (GLenum target, GLsizei size, const GLvoid *data, GLenum usage);
+static PFNglBufferData pglBufferData;
+typedef void (APIENTRY * PFNglDeleteBuffers) (GLsizei n, const GLuint *buffers);
+static PFNglDeleteBuffers pglDeleteBuffers;
+
/* Lighting */
typedef void (APIENTRY * PFNglShadeModel) (GLenum mode);
@@ -383,6 +392,10 @@ typedef void (APIENTRY *PFNglActiveTexture) (GLenum);
static PFNglActiveTexture pglActiveTexture;
typedef void (APIENTRY *PFNglMultiTexCoord2f) (GLenum, GLfloat, GLfloat);
static PFNglMultiTexCoord2f pglMultiTexCoord2f;
+typedef void (APIENTRY *PFNglMultiTexCoord2fv) (GLenum target, const GLfloat *v);
+static PFNglMultiTexCoord2fv pglMultiTexCoord2fv;
+typedef void (APIENTRY *PFNglClientActiveTexture) (GLenum);
+static PFNglClientActiveTexture pglClientActiveTexture;
/* 1.2 Parms */
/* GL_CLAMP_TO_EDGE_EXT */
@@ -416,19 +429,18 @@ boolean SetupGLfunc(void)
GETOPENGLFUNC(pglClearColor, glClearColor)
- GETOPENGLFUNC(pglClear , glClear)
- GETOPENGLFUNC(pglColorMask , glColorMask)
- GETOPENGLFUNC(pglAlphaFunc , glAlphaFunc)
- GETOPENGLFUNC(pglBlendFunc , glBlendFunc)
- GETOPENGLFUNC(pglCullFace , glCullFace)
- GETOPENGLFUNC(pglPolygonMode , glPolygonMode)
- GETOPENGLFUNC(pglPolygonOffset , glPolygonOffset)
- GETOPENGLFUNC(pglScissor , glScissor)
- GETOPENGLFUNC(pglEnable , glEnable)
- GETOPENGLFUNC(pglDisable , glDisable)
- GETOPENGLFUNC(pglGetDoublev , glGetDoublev)
- GETOPENGLFUNC(pglGetIntegerv , glGetIntegerv)
- GETOPENGLFUNC(pglGetString , glGetString)
+ GETOPENGLFUNC(pglClear, glClear)
+ GETOPENGLFUNC(pglColorMask, glColorMask)
+ GETOPENGLFUNC(pglAlphaFunc, glAlphaFunc)
+ GETOPENGLFUNC(pglBlendFunc, glBlendFunc)
+ GETOPENGLFUNC(pglCullFace, glCullFace)
+ GETOPENGLFUNC(pglPolygonOffset, glPolygonOffset)
+ GETOPENGLFUNC(pglScissor, glScissor)
+ GETOPENGLFUNC(pglEnable, glEnable)
+ GETOPENGLFUNC(pglDisable, glDisable)
+ GETOPENGLFUNC(pglGetFloatv, glGetFloatv)
+ GETOPENGLFUNC(pglGetIntegerv, glGetIntegerv)
+ GETOPENGLFUNC(pglGetString, glGetString)
GETOPENGLFUNC(pglClearDepth , glClearDepth)
GETOPENGLFUNC(pglDepthFunc , glDepthFunc)
@@ -440,18 +452,20 @@ boolean SetupGLfunc(void)
GETOPENGLFUNC(pglPushMatrix , glPushMatrix)
GETOPENGLFUNC(pglPopMatrix , glPopMatrix)
GETOPENGLFUNC(pglLoadIdentity , glLoadIdentity)
- GETOPENGLFUNC(pglMultMatrixd , glMultMatrixd)
+ GETOPENGLFUNC(pglMultMatrixf , glMultMatrixf)
GETOPENGLFUNC(pglRotatef , glRotatef)
GETOPENGLFUNC(pglScalef , glScalef)
GETOPENGLFUNC(pglTranslatef , glTranslatef)
- GETOPENGLFUNC(pglBegin , glBegin)
- GETOPENGLFUNC(pglEnd , glEnd)
- GETOPENGLFUNC(pglVertex3f , glVertex3f)
- GETOPENGLFUNC(pglNormal3f , glNormal3f)
- GETOPENGLFUNC(pglColor4f , glColor4f)
- GETOPENGLFUNC(pglColor4fv , glColor4fv)
- GETOPENGLFUNC(pglTexCoord2f , glTexCoord2f)
+ GETOPENGLFUNC(pglColor4ubv, glColor4ubv)
+ GETOPENGLFUNC(pglVertexPointer, glVertexPointer)
+ GETOPENGLFUNC(pglNormalPointer, glNormalPointer)
+ GETOPENGLFUNC(pglTexCoordPointer, glTexCoordPointer)
+ GETOPENGLFUNC(pglColorPointer, glColorPointer)
+ GETOPENGLFUNC(pglDrawArrays, glDrawArrays)
+ GETOPENGLFUNC(pglDrawElements, glDrawElements)
+ GETOPENGLFUNC(pglEnableClientState, glEnableClientState)
+ GETOPENGLFUNC(pglDisableClientState, glDisableClientState)
GETOPENGLFUNC(pglShadeModel , glShadeModel)
GETOPENGLFUNC(pglLightfv, glLightfv)
@@ -483,42 +497,18 @@ boolean SetupGLfunc(void)
}
// This has to be done after the context is created so the version number can be obtained
+// This is stupid -- even some of the oldest usable OpenGL hardware today supports 1.3-level featureset.
boolean SetupGLFunc13(void)
{
- const GLubyte *version = pglGetString(GL_VERSION);
- int glmajor, glminor;
-
- gl13 = false;
- // Parse the GL version
- if (version != NULL)
- {
- if (sscanf((const char*)version, "%d.%d", &glmajor, &glminor) == 2)
- {
- // Look, we gotta prepare for the inevitable arrival of GL 2.0 code...
- if (glmajor == 1 && glminor >= 3)
- gl13 = true;
- else if (glmajor > 1)
- gl13 = true;
- }
- }
-
- if (gl13)
- {
- pglActiveTexture = GetGLFunc("glActiveTexture");
- pglMultiTexCoord2f = GetGLFunc("glMultiTexCoord2f");
- }
- else if (isExtAvailable("GL_ARB_multitexture", gl_extensions))
- {
- // Get the functions
- pglActiveTexture = GetGLFunc("glActiveTextureARB");
- pglMultiTexCoord2f = GetGLFunc("glMultiTexCoord2fARB");
+ pglActiveTexture = GetGLFunc("glActiveTexture");
+ pglMultiTexCoord2f = GetGLFunc("glMultiTexCoord2f");
+ pglClientActiveTexture = GetGLFunc("glClientActiveTexture");
+ pglMultiTexCoord2fv = GetGLFunc("glMultiTexCoord2fv");
+ pglGenBuffers = GetGLFunc("glGenBuffers");
+ pglBindBuffer = GetGLFunc("glBindBuffer");
+ pglBufferData = GetGLFunc("glBufferData");
+ pglDeleteBuffers = GetGLFunc("glDeleteBuffers");
- gl13 = true; // This is now true, so the new fade mask stuff can be done, if OpenGL version is less than 1.3, it still uses the old fade stuff.
- DBG_Printf("GL_ARB_multitexture support: enabled\n");
-
- }
- else
- DBG_Printf("GL_ARB_multitexture support: disabled\n");
return true;
}
@@ -535,39 +525,40 @@ static void SetNoTexture(void)
}
}
-static void GLPerspective(GLdouble fovy, GLdouble aspect)
+static void GLPerspective(GLfloat fovy, GLfloat aspect)
{
- GLdouble m[4][4] =
+ GLfloat m[4][4] =
{
{ 1.0f, 0.0f, 0.0f, 0.0f},
{ 0.0f, 1.0f, 0.0f, 0.0f},
{ 0.0f, 0.0f, 1.0f,-1.0f},
{ 0.0f, 0.0f, 0.0f, 0.0f},
};
- const GLdouble zNear = NEAR_CLIPPING_PLANE;
- const GLdouble zFar = FAR_CLIPPING_PLANE;
- const GLdouble radians = (GLdouble)(fovy / 2.0f * M_PIl / 180.0f);
- const GLdouble sine = sin(radians);
- const GLdouble deltaZ = zFar - zNear;
- GLdouble cotangent;
+ const GLfloat zNear = NEAR_CLIPPING_PLANE;
+ const GLfloat zFar = FAR_CLIPPING_PLANE;
+ const GLfloat radians = (GLfloat)(fovy / 2.0f * M_PIl / 180.0f);
+ const GLfloat sine = sinf(radians);
+ const GLfloat deltaZ = zFar - zNear;
+ GLfloat cotangent;
if ((fabsf((float)deltaZ) < 1.0E-36f) || fpclassify(sine) == FP_ZERO || fpclassify(aspect) == FP_ZERO)
{
return;
}
- cotangent = cos(radians) / sine;
+ cotangent = cosf(radians) / sine;
m[0][0] = cotangent / aspect;
m[1][1] = cotangent;
m[2][2] = -(zFar + zNear) / deltaZ;
m[3][2] = -2.0f * zNear * zFar / deltaZ;
- pglMultMatrixd(&m[0][0]);
+
+ pglMultMatrixf(&m[0][0]);
}
-static void GLProject(GLdouble objX, GLdouble objY, GLdouble objZ,
- GLdouble* winX, GLdouble* winY, GLdouble* winZ)
+static void GLProject(GLfloat objX, GLfloat objY, GLfloat objZ,
+ GLfloat* winX, GLfloat* winY, GLfloat* winZ)
{
- GLdouble in[4], out[4];
+ GLfloat in[4], out[4];
int i;
for (i=0; i<4; i++)
@@ -634,7 +625,7 @@ void SetModelView(GLint w, GLint h)
// added for new coronas' code (without depth buffer)
pglGetIntegerv(GL_VIEWPORT, viewport);
- pglGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
+ pglGetFloatv(GL_PROJECTION_MATRIX, projMatrix);
}
@@ -659,9 +650,11 @@ void SetStates(void)
//pglShadeModel(GL_FLAT);
pglEnable(GL_TEXTURE_2D); // two-dimensional texturing
+
pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
+
//pglBlendFunc(GL_ONE, GL_ZERO); // copy pixel to frame buffer (opaque)
pglEnable(GL_BLEND); // enable color blending
@@ -694,8 +687,6 @@ void SetStates(void)
//pglEnable(GL_CULL_FACE);
//pglCullFace(GL_FRONT);
- //pglPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
- //pglPolygonMode(GL_FRONT, GL_LINE);
//glFogi(GL_FOG_MODE, GL_EXP);
//pglHint(GL_FOG_HINT, GL_FASTEST);
@@ -711,7 +702,7 @@ void SetStates(void)
// bp : when no t&l :)
pglLoadIdentity();
pglScalef(1.0f, 1.0f, -1.0f);
- pglGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix); // added for new coronas' code (without depth buffer)
+ pglGetFloatv(GL_MODELVIEW_MATRIX, modelMatrix); // added for new coronas' code (without depth buffer)
}
@@ -877,7 +868,7 @@ EXPORT void HWRAPI(GClipRect) (INT32 minx, INT32 miny, INT32 maxx, INT32 maxy, f
// added for new coronas' code (without depth buffer)
pglGetIntegerv(GL_VIEWPORT, viewport);
- pglGetDoublev(GL_PROJECTION_MATRIX, projMatrix);
+ pglGetFloatv(GL_PROJECTION_MATRIX, projMatrix);
}
@@ -911,6 +902,8 @@ EXPORT void HWRAPI(ClearBuffer) (FBOOLEAN ColorMask,
SetBlend(DepthMask ? PF_Occlude | CurrentPolyFlags : CurrentPolyFlags&~PF_Occlude);
pglClear(ClearMask);
+ pglEnableClientState(GL_VERTEX_ARRAY); // We always use this one
+ pglEnableClientState(GL_TEXTURE_COORD_ARRAY); // And mostly this one, too
}
@@ -921,26 +914,35 @@ EXPORT void HWRAPI(Draw2DLine) (F2DCoord * v1,
F2DCoord * v2,
RGBA_t Color)
{
- GLRGBAFloat c;
-
// DBG_Printf ("DrawLine() (%f %f %f) %d\n", v1->x, -v1->y, -v1->z, v1->argb);
+ GLfloat p[12];
+ GLfloat dx, dy;
+ GLfloat angle;
// BP: we should reflect the new state in our variable
//SetBlend(PF_Modulated|PF_NoTexture);
pglDisable(GL_TEXTURE_2D);
- c.red = byte2float[Color.s.red];
- c.green = byte2float[Color.s.green];
- c.blue = byte2float[Color.s.blue];
- c.alpha = byte2float[Color.s.alpha];
+ // This is the preferred, 'modern' way of rendering lines -- creating a polygon.
+ if (fabsf(v2->x - v1->x) > FLT_EPSILON)
+ angle = (float)atan((v2->y-v1->y)/(v2->x-v1->x));
+ else
+ angle = (float)N_PI_DEMI;
+ dx = (float)sin(angle) / (float)screen_width;
+ dy = (float)cos(angle) / (float)screen_height;
+
+ p[0] = v1->x - dx; p[1] = -(v1->y + dy); p[2] = 1;
+ p[3] = v2->x - dx; p[4] = -(v2->y + dy); p[5] = 1;
+ p[6] = v2->x + dx; p[7] = -(v2->y - dy); p[8] = 1;
+ p[9] = v1->x + dx; p[10] = -(v1->y - dy); p[11] = 1;
- pglColor4fv(&c.red); // is in RGBA float format
- pglBegin(GL_LINES);
- pglVertex3f(v1->x, -v1->y, 1.0f);
- pglVertex3f(v2->x, -v2->y, 1.0f);
- pglEnd();
+ pglDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ pglColor4ubv((GLubyte*)&Color.s);
+ pglVertexPointer(3, GL_FLOAT, 0, p);
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+ pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
pglEnable(GL_TEXTURE_2D);
}
@@ -985,7 +987,7 @@ EXPORT void HWRAPI(SetBlend) (FBITFIELD PolyFlags)
break;
case PF_Substractive & PF_Blending:
// good for shadow
- // not realy but what else ?
+ // not really but what else ?
pglBlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_COLOR);
pglAlphaFunc(GL_NOTEQUAL, 0.0f);
break;
@@ -1050,7 +1052,7 @@ EXPORT void HWRAPI(SetBlend) (FBITFIELD PolyFlags)
if (oglflags & GLF_NOTEXENV)
{
if (!(PolyFlags & PF_Modulated))
- pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+ pglColor4ubv(white);
}
else
#endif
@@ -1125,15 +1127,6 @@ EXPORT void HWRAPI(SetTexture) (FTextureInfo *pTexInfo)
w = pTexInfo->width;
h = pTexInfo->height;
-#ifdef USE_PALETTED_TEXTURE
- if (glColorTableEXT &&
- (pTexInfo->grInfo.format == GR_TEXFMT_P_8) &&
- !(pTexInfo->flags & TF_CHROMAKEYED))
- {
- // do nothing here.
- }
- else
-#endif
if ((pTexInfo->grInfo.format == GR_TEXFMT_P_8) ||
(pTexInfo->grInfo.format == GR_TEXFMT_AP_88))
{
@@ -1233,17 +1226,6 @@ EXPORT void HWRAPI(SetTexture) (FTextureInfo *pTexInfo)
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter);
}
-#ifdef USE_PALETTED_TEXTURE
- //Hurdler: not really supported and not tested recently
- if (glColorTableEXT &&
- (pTexInfo->grInfo.format == GR_TEXFMT_P_8) &&
- !(pTexInfo->flags & TF_CHROMAKEYED))
- {
- glColorTableEXT(GL_TEXTURE_2D, GL_RGB8, 256, GL_RGB, GL_UNSIGNED_BYTE, palette_tex);
- pglTexImage2D(GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, w, h, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, pTexInfo->grInfo.data);
- }
- else
-#endif
if (pTexInfo->grInfo.format == GR_TEXFMT_ALPHA_INTENSITY_88)
{
//pglTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, ptex);
@@ -1328,7 +1310,6 @@ EXPORT void HWRAPI(DrawPolygon) (FSurfaceInfo *pSurf,
{
FUINT i;
FUINT j;
- GLRGBAFloat c = {0,0,0,0};
if ((PolyFlags & PF_Corona) && (oglflags & GLF_NOZBUFREAD))
PolyFlags &= ~(PF_NoDepthTest|PF_Corona);
@@ -1337,24 +1318,7 @@ EXPORT void HWRAPI(DrawPolygon) (FSurfaceInfo *pSurf,
// If Modulated, mix the surface colour to the texture
if ((CurrentPolyFlags & PF_Modulated) && pSurf)
- {
- if (pal_col)
- { // hack for non-palettized mode
- c.red = (const_pal_col.red +byte2float[pSurf->FlatColor.s.red]) /2.0f;
- c.green = (const_pal_col.green+byte2float[pSurf->FlatColor.s.green])/2.0f;
- c.blue = (const_pal_col.blue +byte2float[pSurf->FlatColor.s.blue]) /2.0f;
- c.alpha = byte2float[pSurf->FlatColor.s.alpha];
- }
- else
- {
- c.red = byte2float[pSurf->FlatColor.s.red];
- c.green = byte2float[pSurf->FlatColor.s.green];
- c.blue = byte2float[pSurf->FlatColor.s.blue];
- c.alpha = byte2float[pSurf->FlatColor.s.alpha];
- }
-
- pglColor4fv(&c.red); // is in RGBA float format
- }
+ pglColor4ubv((GLubyte*)&pSurf->FlatColor.s);
// this test is added for new coronas' code (without depth buffer)
// I think I should do a separate function for drawing coronas, so it will be a little faster
@@ -1362,10 +1326,14 @@ EXPORT void HWRAPI(DrawPolygon) (FSurfaceInfo *pSurf,
{
//rem: all 8 (or 8.0f) values are hard coded: it can be changed to a higher value
GLfloat buf[8][8];
- GLdouble cx, cy, cz;
- GLdouble px = 0.0f, py = 0.0f, pz = -1.0f;
+ GLfloat cx, cy, cz;
+ GLfloat px = 0.0f, py = 0.0f, pz = -1.0f;
GLfloat scalef = 0.0f;
+ GLubyte c[4];
+
+ float alpha;
+
cx = (pOutVerts[0].x + pOutVerts[2].x) / 2.0f; // we should change the coronas' ...
cy = (pOutVerts[0].y + pOutVerts[2].y) / 2.0f; // ... code so its only done once.
cz = pOutVerts[0].z;
@@ -1401,21 +1369,20 @@ EXPORT void HWRAPI(DrawPolygon) (FSurfaceInfo *pSurf,
if (scalef < 0.05f)
return;
- c.alpha *= scalef; // change the alpha value (it seems better than changing the size of the corona)
- pglColor4fv(&c.red);
- }
- if (PolyFlags & PF_MD2)
- return;
+ // GLubyte c[4];
+ c[0] = pSurf->FlatColor.s.red;
+ c[1] = pSurf->FlatColor.s.green;
+ c[2] = pSurf->FlatColor.s.blue;
- pglBegin(GL_TRIANGLE_FAN);
- for (i = 0; i < iNumPts; i++)
- {
- pglTexCoord2f(pOutVerts[i].sow, pOutVerts[i].tow);
- //Hurdler: test code: -pOutVerts[i].z => pOutVerts[i].z
- pglVertex3f(pOutVerts[i].x, pOutVerts[i].y, pOutVerts[i].z);
- //pglVertex3f(pOutVerts[i].x, pOutVerts[i].y, -pOutVerts[i].z);
+ alpha = byte2float[pSurf->FlatColor.s.alpha];
+ alpha *= scalef; // change the alpha value (it seems better than changing the size of the corona)
+ c[3] = (unsigned char)(alpha * 255);
+ pglColor4ubv(c);
}
- pglEnd();
+
+ pglVertexPointer(3, GL_FLOAT, sizeof(FOutVector), &pOutVerts[0].x);
+ pglTexCoordPointer(2, GL_FLOAT, sizeof(FOutVector), &pOutVerts[0].sow);
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, iNumPts);
if (PolyFlags & PF_RemoveYWrap)
pglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
@@ -1427,6 +1394,256 @@ EXPORT void HWRAPI(DrawPolygon) (FSurfaceInfo *pSurf,
Clamp2D(GL_TEXTURE_WRAP_T);
}
+typedef struct vbo_vertex_s
+{
+ float x, y, z;
+ float u, v;
+ unsigned char r, g, b, a;
+} vbo_vertex_t;
+
+typedef struct
+{
+ int mode;
+ int vertexcount;
+ int vertexindex;
+ int use_texture;
+} GLSkyLoopDef;
+
+typedef struct
+{
+ unsigned int id;
+ int rows, columns;
+ int loopcount;
+ GLSkyLoopDef *loops;
+ vbo_vertex_t *data;
+} GLSkyVBO;
+
+static const boolean gl_ext_arb_vertex_buffer_object = true;
+
+#define NULL_VBO_VERTEX ((vbo_vertex_t*)NULL)
+#define sky_vbo_x (gl_ext_arb_vertex_buffer_object ? &NULL_VBO_VERTEX->x : &vbo->data[0].x)
+#define sky_vbo_u (gl_ext_arb_vertex_buffer_object ? &NULL_VBO_VERTEX->u : &vbo->data[0].u)
+#define sky_vbo_r (gl_ext_arb_vertex_buffer_object ? &NULL_VBO_VERTEX->r : &vbo->data[0].r)
+
+// The texture offset to be applied to the texture coordinates in SkyVertex().
+static int rows, columns;
+static boolean yflip;
+static int texw, texh;
+static boolean foglayer;
+static float delta = 0.0f;
+
+static int gl_sky_detail = 16;
+
+static INT32 lasttex = -1;
+
+#define MAP_COEFF 128.0f
+
+static void SkyVertex(vbo_vertex_t *vbo, int r, int c)
+{
+ const float radians = (M_PIl / 180.0f);
+ const float scale = 10000.0f;
+ const float maxSideAngle = 60.0f;
+
+ float topAngle = (c / (float)columns * 360.0f);
+ float sideAngle = (maxSideAngle * (rows - r) / rows);
+ float height = sin(sideAngle * radians);
+ float realRadius = scale * cos(sideAngle * radians);
+ float x = realRadius * cos(topAngle * radians);
+ float y = (!yflip) ? scale * height : -scale * height;
+ float z = realRadius * sin(topAngle * radians);
+ float timesRepeat = (4 * (256.0f / texw));
+ if (fpclassify(timesRepeat) == FP_ZERO)
+ timesRepeat = 1.0f;
+
+ if (!foglayer)
+ {
+ vbo->r = 255;
+ vbo->g = 255;
+ vbo->b = 255;
+ vbo->a = (r == 0 ? 0 : 255);
+
+ // And the texture coordinates.
+ vbo->u = (-timesRepeat * c / (float)columns);
+ if (!yflip) // Flipped Y is for the lower hemisphere.
+ vbo->v = (r / (float)rows) + 0.5f;
+ else
+ vbo->v = 1.0f + ((rows - r) / (float)rows) + 0.5f;
+ }
+
+ if (r != 4)
+ {
+ y += 300.0f;
+ }
+
+ // And finally the vertex.
+ vbo->x = x;
+ vbo->y = y + delta;
+ vbo->z = z;
+}
+
+static GLSkyVBO sky_vbo;
+
+static void gld_BuildSky(int row_count, int col_count)
+{
+ int c, r;
+ vbo_vertex_t *vertex_p;
+ int vertex_count = 2 * row_count * (col_count * 2 + 2) + col_count * 2;
+
+ GLSkyVBO *vbo = &sky_vbo;
+
+ if ((vbo->columns != col_count) || (vbo->rows != row_count))
+ {
+ free(vbo->loops);
+ free(vbo->data);
+ memset(vbo, 0, sizeof(&vbo));
+ }
+
+ if (!vbo->data)
+ {
+ memset(vbo, 0, sizeof(&vbo));
+ vbo->loops = malloc((row_count * 2 + 2) * sizeof(vbo->loops[0]));
+ // create vertex array
+ vbo->data = malloc(vertex_count * sizeof(vbo->data[0]));
+ }
+
+ vbo->columns = col_count;
+ vbo->rows = row_count;
+
+ vertex_p = &vbo->data[0];
+ vbo->loopcount = 0;
+
+ for (yflip = 0; yflip < 2; yflip++)
+ {
+ vbo->loops[vbo->loopcount].mode = GL_TRIANGLE_FAN;
+ vbo->loops[vbo->loopcount].vertexindex = vertex_p - &vbo->data[0];
+ vbo->loops[vbo->loopcount].vertexcount = col_count;
+ vbo->loops[vbo->loopcount].use_texture = false;
+ vbo->loopcount++;
+
+ delta = 0.0f;
+ foglayer = true;
+ for (c = 0; c < col_count; c++)
+ {
+ SkyVertex(vertex_p, 1, c);
+ vertex_p->r = 255;
+ vertex_p->g = 255;
+ vertex_p->b = 255;
+ vertex_p->a = 255;
+ vertex_p++;
+ }
+ foglayer = false;
+
+ delta = (yflip ? 5.0f : -5.0f) / MAP_COEFF;
+
+ for (r = 0; r < row_count; r++)
+ {
+ vbo->loops[vbo->loopcount].mode = GL_TRIANGLE_STRIP;
+ vbo->loops[vbo->loopcount].vertexindex = vertex_p - &vbo->data[0];
+ vbo->loops[vbo->loopcount].vertexcount = 2 * col_count + 2;
+ vbo->loops[vbo->loopcount].use_texture = true;
+ vbo->loopcount++;
+
+ for (c = 0; c <= col_count; c++)
+ {
+ SkyVertex(vertex_p++, r + (yflip ? 1 : 0), (c ? c : 0));
+ SkyVertex(vertex_p++, r + (yflip ? 0 : 1), (c ? c : 0));
+ }
+ }
+ }
+}
+
+//-----------------------------------------------------------------------------
+//
+//
+//
+//-----------------------------------------------------------------------------
+
+static void RenderDome(INT32 skytexture)
+{
+ int i, j;
+ int vbosize;
+ GLSkyVBO *vbo = &sky_vbo;
+
+ rows = 4;
+ columns = 4 * gl_sky_detail;
+
+ vbosize = 2 * rows * (columns * 2 + 2) + columns * 2;
+
+ // Build the sky dome! Yes!
+ if (lasttex != skytexture)
+ {
+ // delete VBO when already exists
+ if (gl_ext_arb_vertex_buffer_object)
+ {
+ if (vbo->id)
+ pglDeleteBuffers(1, &vbo->id);
+ }
+
+ lasttex = skytexture;
+ gld_BuildSky(rows, columns);
+
+ if (gl_ext_arb_vertex_buffer_object)
+ {
+ // generate a new VBO and get the associated ID
+ pglGenBuffers(1, &vbo->id);
+
+ // bind VBO in order to use
+ pglBindBuffer(GL_ARRAY_BUFFER, vbo->id);
+
+ // upload data to VBO
+ pglBufferData(GL_ARRAY_BUFFER, vbosize * sizeof(vbo->data[0]), vbo->data, GL_STATIC_DRAW);
+ }
+ }
+
+ // bind VBO in order to use
+ if (gl_ext_arb_vertex_buffer_object)
+ pglBindBuffer(GL_ARRAY_BUFFER, vbo->id);
+
+ // activate and specify pointers to arrays
+ pglVertexPointer(3, GL_FLOAT, sizeof(vbo->data[0]), sky_vbo_x);
+ pglTexCoordPointer(2, GL_FLOAT, sizeof(vbo->data[0]), sky_vbo_u);
+ pglColorPointer(4, GL_UNSIGNED_BYTE, sizeof(vbo->data[0]), sky_vbo_r);
+
+ // activate color arrays
+ pglEnableClientState(GL_COLOR_ARRAY);
+
+ // set transforms
+ pglScalef(1.0f, (float)texh / 230.0f, 1.0f);
+ pglRotatef(270.0f, 0.0f, 1.0f, 0.0f);
+
+ for (j = 0; j < 2; j++)
+ {
+ for (i = 0; i < vbo->loopcount; i++)
+ {
+ GLSkyLoopDef *loop = &vbo->loops[i];
+
+ if (j == 0 ? loop->use_texture : !loop->use_texture)
+ continue;
+
+ pglDrawArrays(loop->mode, loop->vertexindex, loop->vertexcount);
+ }
+ }
+
+ pglScalef(1.0f, 1.0f, 1.0f);
+ pglColor4ubv(white);
+
+ // bind with 0, so, switch back to normal pointer operation
+ if (gl_ext_arb_vertex_buffer_object)
+ pglBindBuffer(GL_ARRAY_BUFFER, 0);
+
+ // deactivate color array
+ pglDisableClientState(GL_COLOR_ARRAY);
+}
+
+EXPORT void HWRAPI(RenderSkyDome) (INT32 tex, INT32 texture_width, INT32 texture_height, FTransform transform)
+{
+ SetBlend(PF_Translucent|PF_NoDepthTest|PF_Modulated);
+ SetTransform(&transform);
+ texw = texture_width;
+ texh = texture_height;
+ RenderDome(tex);
+ SetBlend(0);
+}
// ==========================================================================
//
@@ -1446,15 +1663,6 @@ EXPORT void HWRAPI(SetSpecialState) (hwdspecialstate_t IdState, INT32 Value)
}
#endif
- case HWD_SET_PALETTECOLOR:
- {
- pal_col = Value;
- const_pal_col.blue = byte2float[((Value>>16)&0xff)];
- const_pal_col.green = byte2float[((Value>>8)&0xff)];
- const_pal_col.red = byte2float[((Value)&0xff)];
- break;
- }
-
case HWD_SET_FOG_COLOR:
{
GLfloat fogcolor[4];
@@ -1496,13 +1704,6 @@ EXPORT void HWRAPI(SetSpecialState) (hwdspecialstate_t IdState, INT32 Value)
pglDisable(GL_FOG);
break;
- case HWD_SET_POLYGON_SMOOTH:
- if (Value)
- pglEnable(GL_POLYGON_SMOOTH);
- else
- pglDisable(GL_POLYGON_SMOOTH);
- break;
-
case HWD_SET_TEXTUREFILTERMODE:
switch (Value)
{
@@ -1557,19 +1758,227 @@ EXPORT void HWRAPI(SetSpecialState) (hwdspecialstate_t IdState, INT32 Value)
}
}
-static void DrawMD2Ex(INT32 *gl_cmd_buffer, md2_frame_t *frame, INT32 duration, INT32 tics, md2_frame_t *nextframe, FTransform *pos, float scale, UINT8 flipped, UINT8 *color)
+static float *vertBuffer = NULL;
+static float *normBuffer = NULL;
+static size_t lerpBufferSize = 0;
+static short *vertTinyBuffer = NULL;
+static char *normTinyBuffer = NULL;
+static size_t lerpTinyBufferSize = 0;
+
+// Static temporary buffer for doing frame interpolation
+// 'size' is the vertex size
+static void AllocLerpBuffer(size_t size)
+{
+ if (lerpBufferSize >= size)
+ return;
+
+ if (vertBuffer != NULL)
+ free(vertBuffer);
+
+ if (normBuffer != NULL)
+ free(normBuffer);
+
+ lerpBufferSize = size;
+ vertBuffer = malloc(lerpBufferSize);
+ normBuffer = malloc(lerpBufferSize);
+}
+
+// Static temporary buffer for doing frame interpolation
+// 'size' is the vertex size
+static void AllocLerpTinyBuffer(size_t size)
+{
+ if (lerpTinyBufferSize >= size)
+ return;
+
+ if (vertTinyBuffer != NULL)
+ free(vertTinyBuffer);
+
+ if (normTinyBuffer != NULL)
+ free(normTinyBuffer);
+
+ lerpTinyBufferSize = size;
+ vertTinyBuffer = malloc(lerpTinyBufferSize);
+ normTinyBuffer = malloc(lerpTinyBufferSize / 2);
+}
+
+#ifndef GL_STATIC_DRAW
+#define GL_STATIC_DRAW 0x88E4
+#endif
+
+#ifndef GL_ARRAY_BUFFER
+#define GL_ARRAY_BUFFER 0x8892
+#endif
+
+static void CreateModelVBO(mesh_t *mesh, mdlframe_t *frame)
+{
+ int bufferSize = sizeof(vbo64_t)*mesh->numTriangles * 3;
+ vbo64_t *buffer = (vbo64_t*)malloc(bufferSize);
+ vbo64_t *bufPtr = buffer;
+
+ float *vertPtr = frame->vertices;
+ float *normPtr = frame->normals;
+ float *tanPtr = frame->tangents;
+ float *uvPtr = mesh->uvs;
+ float *lightPtr = mesh->lightuvs;
+ char *colorPtr = frame->colors;
+
+ int i;
+ for (i = 0; i < mesh->numTriangles * 3; i++)
+ {
+ bufPtr->x = *vertPtr++;
+ bufPtr->y = *vertPtr++;
+ bufPtr->z = *vertPtr++;
+
+ bufPtr->nx = *normPtr++;
+ bufPtr->ny = *normPtr++;
+ bufPtr->nz = *normPtr++;
+
+ bufPtr->s0 = *uvPtr++;
+ bufPtr->t0 = *uvPtr++;
+
+ if (tanPtr != NULL)
+ {
+ bufPtr->tan0 = *tanPtr++;
+ bufPtr->tan1 = *tanPtr++;
+ bufPtr->tan2 = *tanPtr++;
+ }
+
+ if (lightPtr != NULL)
+ {
+ bufPtr->s1 = *lightPtr++;
+ bufPtr->t1 = *lightPtr++;
+ }
+
+ if (colorPtr)
+ {
+ bufPtr->r = *colorPtr++;
+ bufPtr->g = *colorPtr++;
+ bufPtr->b = *colorPtr++;
+ bufPtr->a = *colorPtr++;
+ }
+ else
+ {
+ bufPtr->r = 255;
+ bufPtr->g = 255;
+ bufPtr->b = 255;
+ bufPtr->a = 255;
+ }
+
+ bufPtr++;
+ }
+
+ pglGenBuffers(1, &frame->vboID);
+ pglBindBuffer(GL_ARRAY_BUFFER, frame->vboID);
+ pglBufferData(GL_ARRAY_BUFFER, bufferSize, buffer, GL_STATIC_DRAW);
+ free(buffer);
+
+ // Don't leave the array buffer bound to the model,
+ // since this is called mid-frame
+ pglBindBuffer(GL_ARRAY_BUFFER, 0);
+}
+
+static void CreateModelVBOTiny(mesh_t *mesh, tinyframe_t *frame)
+{
+ int bufferSize = sizeof(vbotiny_t)*mesh->numTriangles * 3;
+ vbotiny_t *buffer = (vbotiny_t*)malloc(bufferSize);
+ vbotiny_t *bufPtr = buffer;
+
+ short *vertPtr = frame->vertices;
+ char *normPtr = frame->normals;
+ float *uvPtr = mesh->uvs;
+ char *tanPtr = frame->tangents;
+
+ int i;
+ for (i = 0; i < mesh->numVertices; i++)
+ {
+ bufPtr->x = *vertPtr++;
+ bufPtr->y = *vertPtr++;
+ bufPtr->z = *vertPtr++;
+
+ bufPtr->nx = *normPtr++;
+ bufPtr->ny = *normPtr++;
+ bufPtr->nz = *normPtr++;
+
+ bufPtr->s0 = *uvPtr++;
+ bufPtr->t0 = *uvPtr++;
+
+ if (tanPtr)
+ {
+ bufPtr->tanx = *tanPtr++;
+ bufPtr->tany = *tanPtr++;
+ bufPtr->tanz = *tanPtr++;
+ }
+
+ bufPtr++;
+ }
+
+ pglGenBuffers(1, &frame->vboID);
+ pglBindBuffer(GL_ARRAY_BUFFER, frame->vboID);
+ pglBufferData(GL_ARRAY_BUFFER, bufferSize, buffer, GL_STATIC_DRAW);
+ free(buffer);
+
+ // Don't leave the array buffer bound to the model,
+ // since this is called mid-frame
+ pglBindBuffer(GL_ARRAY_BUFFER, 0);
+}
+
+EXPORT void HWRAPI(CreateModelVBOs) (model_t *model)
+{
+ int i;
+ for (i = 0; i < model->numMeshes; i++)
+ {
+ mesh_t *mesh = &model->meshes[i];
+
+ if (mesh->frames)
+ {
+ int j;
+ for (j = 0; j < model->meshes[i].numFrames; j++)
+ {
+ mdlframe_t *frame = &mesh->frames[j];
+ if (frame->vboID)
+ pglDeleteBuffers(1, &frame->vboID);
+ frame->vboID = 0;
+ CreateModelVBO(mesh, frame);
+ }
+ }
+ else if (mesh->tinyframes)
+ {
+ int j;
+ for (j = 0; j < model->meshes[i].numFrames; j++)
+ {
+ tinyframe_t *frame = &mesh->tinyframes[j];
+ if (frame->vboID)
+ pglDeleteBuffers(1, &frame->vboID);
+ frame->vboID = 0;
+ CreateModelVBOTiny(mesh, frame);
+ }
+ }
+ }
+}
+
+#define BUFFER_OFFSET(i) ((char*)NULL + (i))
+
+static void DrawModelEx(model_t *model, INT32 frameIndex, INT32 duration, INT32 tics, INT32 nextFrameIndex, FTransform *pos, float scale, UINT8 flipped, UINT8 *color)
{
- INT32 val, count, pindex;
- GLfloat s, t;
GLfloat ambient[4];
GLfloat diffuse[4];
float pol = 0.0f;
- float scalex = scale, scaley = scale, scalez = scale;
+ float scalex, scaley, scalez;
+
+ boolean useTinyFrames;
+
+ int i;
// Because Otherwise, scaling the screen negatively vertically breaks the lighting
GLfloat LightPos[] = {0.0f, 1.0f, 0.0f, 0.0f};
+ // Affect input model scaling
+ scale *= 0.5f;
+ scalex = scale;
+ scaley = scale;
+ scalez = scale;
+
if (duration != 0 && duration != -1 && tics != -1) // don't interpolate if instantaneous or infinite in length
{
UINT32 newtime = (duration - tics); // + 1;
@@ -1603,7 +2012,21 @@ static void DrawMD2Ex(INT32 *gl_cmd_buffer, md2_frame_t *frame, INT32 duration,
}
pglEnable(GL_CULL_FACE);
+ pglEnable(GL_NORMALIZE);
+#ifdef USE_FTRANSFORM_MIRROR
+ // flipped is if the object is flipped
+ // pos->flip is if the screen is flipped vertically
+ // pos->mirror is if the screen is flipped horizontally
+ // XOR all the flips together to figure out what culling to use!
+ {
+ boolean reversecull = (flipped ^ pos->flip ^ pos->mirror);
+ if (reversecull)
+ pglCullFace(GL_FRONT);
+ else
+ pglCullFace(GL_BACK);
+ }
+#else
// pos->flip is if the screen is flipped too
if (flipped != pos->flip) // If either are active, but not both, invert the model's culling
{
@@ -1613,6 +2036,7 @@ static void DrawMD2Ex(INT32 *gl_cmd_buffer, md2_frame_t *frame, INT32 duration,
{
pglCullFace(GL_BACK);
}
+#endif
pglLightfv(GL_LIGHT0, GL_POSITION, LightPos);
@@ -1635,98 +2059,145 @@ static void DrawMD2Ex(INT32 *gl_cmd_buffer, md2_frame_t *frame, INT32 duration,
pglTranslatef(pos->x, pos->z, pos->y);
if (flipped)
scaley = -scaley;
- pglRotatef(pos->angley, 0.0f, -1.0f, 0.0f);
+#ifdef USE_FTRANSFORM_ANGLEZ
+ pglRotatef(pos->anglez, 0.0f, 0.0f, -1.0f); // rotate by slope from Kart
+#endif
pglRotatef(pos->anglex, -1.0f, 0.0f, 0.0f);
+ pglRotatef(pos->angley, 0.0f, -1.0f, 0.0f);
+
+ pglScalef(scalex, scaley, scalez);
+
+ useTinyFrames = model->meshes[0].tinyframes != NULL;
- val = *gl_cmd_buffer++;
+ if (useTinyFrames)
+ pglScalef(1 / 64.0f, 1 / 64.0f, 1 / 64.0f);
- while (val != 0)
+ pglEnableClientState(GL_NORMAL_ARRAY);
+
+ for (i = 0; i < model->numMeshes; i++)
{
- if (val < 0)
- {
- pglBegin(GL_TRIANGLE_FAN);
- count = -val;
- }
- else
- {
- pglBegin(GL_TRIANGLE_STRIP);
- count = val;
- }
+ mesh_t *mesh = &model->meshes[i];
- while (count--)
+ if (useTinyFrames)
{
- s = *(float *) gl_cmd_buffer++;
- t = *(float *) gl_cmd_buffer++;
- pindex = *gl_cmd_buffer++;
+ tinyframe_t *frame = &mesh->tinyframes[frameIndex % mesh->numFrames];
+ tinyframe_t *nextframe = NULL;
- pglTexCoord2f(s, t);
+ if (nextFrameIndex != -1)
+ nextframe = &mesh->tinyframes[nextFrameIndex % mesh->numFrames];
if (!nextframe || fpclassify(pol) == FP_ZERO)
{
- pglNormal3f(frame->vertices[pindex].normal[0],
- frame->vertices[pindex].normal[1],
- frame->vertices[pindex].normal[2]);
+ pglBindBuffer(GL_ARRAY_BUFFER, frame->vboID);
+ pglVertexPointer(3, GL_SHORT, sizeof(vbotiny_t), BUFFER_OFFSET(0));
+ pglNormalPointer(GL_BYTE, sizeof(vbotiny_t), BUFFER_OFFSET(sizeof(short)*3));
+ pglTexCoordPointer(2, GL_FLOAT, sizeof(vbotiny_t), BUFFER_OFFSET(sizeof(short) * 3 + sizeof(char) * 6));
- pglVertex3f(frame->vertices[pindex].vertex[0]*scalex/2.0f,
- frame->vertices[pindex].vertex[1]*scaley/2.0f,
- frame->vertices[pindex].vertex[2]*scalez/2.0f);
+ pglDrawElements(GL_TRIANGLES, mesh->numTriangles * 3, GL_UNSIGNED_SHORT, mesh->indices);
+ pglBindBuffer(GL_ARRAY_BUFFER, 0);
}
else
{
- // Interpolate
- float px1 = frame->vertices[pindex].vertex[0]*scalex/2.0f;
- float px2 = nextframe->vertices[pindex].vertex[0]*scalex/2.0f;
- float py1 = frame->vertices[pindex].vertex[1]*scaley/2.0f;
- float py2 = nextframe->vertices[pindex].vertex[1]*scaley/2.0f;
- float pz1 = frame->vertices[pindex].vertex[2]*scalez/2.0f;
- float pz2 = nextframe->vertices[pindex].vertex[2]*scalez/2.0f;
- float nx1 = frame->vertices[pindex].normal[0];
- float nx2 = nextframe->vertices[pindex].normal[0];
- float ny1 = frame->vertices[pindex].normal[1];
- float ny2 = nextframe->vertices[pindex].normal[1];
- float nz1 = frame->vertices[pindex].normal[2];
- float nz2 = nextframe->vertices[pindex].normal[2];
-
- pglNormal3f((nx1 + pol * (nx2 - nx1)),
- (ny1 + pol * (ny2 - ny1)),
- (nz1 + pol * (nz2 - nz1)));
- pglVertex3f((px1 + pol * (px2 - px1)),
- (py1 + pol * (py2 - py1)),
- (pz1 + pol * (pz2 - pz1)));
+ short *vertPtr;
+ char *normPtr;
+ int j;
+
+ // Dangit, I soooo want to do this in a GLSL shader...
+ AllocLerpTinyBuffer(mesh->numVertices * sizeof(short) * 3);
+ vertPtr = vertTinyBuffer;
+ normPtr = normTinyBuffer;
+ j = 0;
+
+ for (j = 0; j < mesh->numVertices * 3; j++)
+ {
+ // Interpolate
+ *vertPtr++ = (short)(frame->vertices[j] + (pol * (nextframe->vertices[j] - frame->vertices[j])));
+ *normPtr++ = (char)(frame->normals[j] + (pol * (nextframe->normals[j] - frame->normals[j])));
+ }
+
+ pglVertexPointer(3, GL_SHORT, 0, vertTinyBuffer);
+ pglNormalPointer(GL_BYTE, 0, normTinyBuffer);
+ pglTexCoordPointer(2, GL_FLOAT, 0, mesh->uvs);
+ pglDrawElements(GL_TRIANGLES, mesh->numTriangles * 3, GL_UNSIGNED_SHORT, mesh->indices);
}
}
+ else
+ {
+ mdlframe_t *frame = &mesh->frames[frameIndex % mesh->numFrames];
+ mdlframe_t *nextframe = NULL;
+
+ if (nextFrameIndex != -1)
+ nextframe = &mesh->frames[nextFrameIndex % mesh->numFrames];
- pglEnd();
+ if (!nextframe || fpclassify(pol) == FP_ZERO)
+ {
+ // Zoom! Take advantage of just shoving the entire arrays to the GPU.
+/* pglVertexPointer(3, GL_FLOAT, 0, frame->vertices);
+ pglNormalPointer(GL_FLOAT, 0, frame->normals);
+ pglTexCoordPointer(2, GL_FLOAT, 0, mesh->uvs);
+ pglDrawArrays(GL_TRIANGLES, 0, mesh->numTriangles * 3);*/
+
+ pglBindBuffer(GL_ARRAY_BUFFER, frame->vboID);
+ pglVertexPointer(3, GL_FLOAT, sizeof(vbo64_t), BUFFER_OFFSET(0));
+ pglNormalPointer(GL_FLOAT, sizeof(vbo64_t), BUFFER_OFFSET(sizeof(float) * 3));
+ pglTexCoordPointer(2, GL_FLOAT, sizeof(vbo64_t), BUFFER_OFFSET(sizeof(float) * 6));
+
+ pglDrawArrays(GL_TRIANGLES, 0, mesh->numTriangles * 3);
+ // No tinyframes, no mesh indices
+ //pglDrawElements(GL_TRIANGLES, mesh->numTriangles * 3, GL_UNSIGNED_SHORT, mesh->indices);
+ pglBindBuffer(GL_ARRAY_BUFFER, 0);
+ }
+ else
+ {
+ float *vertPtr;
+ float *normPtr;
+ int j = 0;
- val = *gl_cmd_buffer++;
+ // Dangit, I soooo want to do this in a GLSL shader...
+ AllocLerpBuffer(mesh->numVertices * sizeof(float) * 3);
+ vertPtr = vertBuffer;
+ normPtr = normBuffer;
+ //int j = 0;
+
+ for (j = 0; j < mesh->numVertices * 3; j++)
+ {
+ // Interpolate
+ *vertPtr++ = frame->vertices[j] + (pol * (nextframe->vertices[j] - frame->vertices[j]));
+ *normPtr++ = frame->normals[j] + (pol * (nextframe->normals[j] - frame->normals[j]));
+ }
+
+ pglVertexPointer(3, GL_FLOAT, 0, vertBuffer);
+ pglNormalPointer(GL_FLOAT, 0, normBuffer);
+ pglTexCoordPointer(2, GL_FLOAT, 0, mesh->uvs);
+ pglDrawArrays(GL_TRIANGLES, 0, mesh->numVertices);
+ }
+ }
}
+
+ pglDisableClientState(GL_NORMAL_ARRAY);
+
pglPopMatrix(); // should be the same as glLoadIdentity
if (color)
pglDisable(GL_LIGHTING);
pglShadeModel(GL_FLAT);
pglDisable(GL_CULL_FACE);
+ pglDisable(GL_NORMALIZE);
}
// -----------------+
// HWRAPI DrawMD2 : Draw an MD2 model with glcommands
// -----------------+
-EXPORT void HWRAPI(DrawMD2i) (INT32 *gl_cmd_buffer, md2_frame_t *frame, INT32 duration, INT32 tics, md2_frame_t *nextframe, FTransform *pos, float scale, UINT8 flipped, UINT8 *color)
-{
- DrawMD2Ex(gl_cmd_buffer, frame, duration, tics, nextframe, pos, scale, flipped, color);
-}
-
-EXPORT void HWRAPI(DrawMD2) (INT32 *gl_cmd_buffer, md2_frame_t *frame, FTransform *pos, float scale)
+EXPORT void HWRAPI(DrawModel) (model_t *model, INT32 frameIndex, INT32 duration, INT32 tics, INT32 nextFrameIndex, FTransform *pos, float scale, UINT8 flipped, UINT8 *color)
{
- DrawMD2Ex(gl_cmd_buffer, frame, 0, 0, NULL, pos, scale, false, NULL);
+ DrawModelEx(model, frameIndex, duration, tics, nextFrameIndex, pos, scale, flipped, color);
}
-
// -----------------+
// SetTransform :
// -----------------+
EXPORT void HWRAPI(SetTransform) (FTransform *stransform)
{
- static INT32 special_splitscreen;
+ static boolean special_splitscreen;
pglLoadIdentity();
if (stransform)
{
@@ -1734,6 +2205,12 @@ EXPORT void HWRAPI(SetTransform) (FTransform *stransform)
// keep a trace of the transformation for md2
memcpy(&md2_transform, stransform, sizeof (md2_transform));
+#ifdef USE_FTRANSFORM_MIRROR
+ // mirroring from Kart
+ if (stransform->mirror)
+ pglScalef(-stransform->scalex, stransform->scaley, -stransform->scalez);
+ else
+#endif
if (stransform->flip)
pglScalef(stransform->scalex, -stransform->scaley, -stransform->scalez);
else
@@ -1748,10 +2225,10 @@ EXPORT void HWRAPI(SetTransform) (FTransform *stransform)
fovx90 = stransform->fovxangle > 0.0f && fabsf(stransform->fovxangle - 90.0f) < 0.5f;
special_splitscreen = (stransform->splitscreen && fovx90);
if (special_splitscreen)
- GLPerspective(53.13l, 2*ASPECT_RATIO); // 53.13 = 2*atan(0.5)
+ GLPerspective(53.13f, 2*ASPECT_RATIO); // 53.13 = 2*atan(0.5)
else
GLPerspective(stransform->fovxangle, ASPECT_RATIO);
- pglGetDoublev(GL_PROJECTION_MATRIX, projMatrix); // added for new coronas' code (without depth buffer)
+ pglGetFloatv(GL_PROJECTION_MATRIX, projMatrix); // added for new coronas' code (without depth buffer)
pglMatrixMode(GL_MODELVIEW);
}
else
@@ -1761,15 +2238,15 @@ EXPORT void HWRAPI(SetTransform) (FTransform *stransform)
pglMatrixMode(GL_PROJECTION);
pglLoadIdentity();
if (special_splitscreen)
- GLPerspective(53.13l, 2*ASPECT_RATIO); // 53.13 = 2*atan(0.5)
+ GLPerspective(53.13f, 2*ASPECT_RATIO); // 53.13 = 2*atan(0.5)
else
//Hurdler: is "fov" correct?
GLPerspective(fov, ASPECT_RATIO);
- pglGetDoublev(GL_PROJECTION_MATRIX, projMatrix); // added for new coronas' code (without depth buffer)
+ pglGetFloatv(GL_PROJECTION_MATRIX, projMatrix); // added for new coronas' code (without depth buffer)
pglMatrixMode(GL_MODELVIEW);
}
- pglGetDoublev(GL_MODELVIEW_MATRIX, modelMatrix); // added for new coronas' code (without depth buffer)
+ pglGetFloatv(GL_MODELVIEW_MATRIX, modelMatrix); // added for new coronas' code (without depth buffer)
}
EXPORT INT32 HWRAPI(GetTextureUsed) (void)
@@ -1790,7 +2267,6 @@ EXPORT INT32 HWRAPI(GetRenderVersion) (void)
return VERSION;
}
-#ifdef SHUFFLE
EXPORT void HWRAPI(PostImgRedraw) (float points[SCREENVERTS][SCREENVERTS][2])
{
INT32 x, y;
@@ -1798,6 +2274,14 @@ EXPORT void HWRAPI(PostImgRedraw) (float points[SCREENVERTS][SCREENVERTS][2])
float xfix, yfix;
INT32 texsize = 2048;
+ const float blackBack[16] =
+ {
+ -16.0f, -16.0f, 6.0f,
+ -16.0f, 16.0f, 6.0f,
+ 16.0f, 16.0f, 6.0f,
+ 16.0f, -16.0f, 6.0f
+ };
+
// Use a power of two texture, dammit
if(screen_width <= 1024)
texsize = 1024;
@@ -1810,47 +2294,66 @@ EXPORT void HWRAPI(PostImgRedraw) (float points[SCREENVERTS][SCREENVERTS][2])
pglDisable(GL_DEPTH_TEST);
pglDisable(GL_BLEND);
- pglBegin(GL_QUADS);
- // Draw a black square behind the screen texture,
- // so nothing shows through the edges
- pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
- pglVertex3f(-16.0f, -16.0f, 6.0f);
- pglVertex3f(-16.0f, 16.0f, 6.0f);
- pglVertex3f(16.0f, 16.0f, 6.0f);
- pglVertex3f(16.0f, -16.0f, 6.0f);
+ // const float blackBack[16]
+
+ // Draw a black square behind the screen texture,
+ // so nothing shows through the edges
+ pglColor4ubv(white);
- for(x=0;x<SCREENVERTS-1;x++)
+ pglVertexPointer(3, GL_FLOAT, 0, blackBack);
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+ for(x=0;x<SCREENVERTS-1;x++)
+ {
+ for(y=0;y<SCREENVERTS-1;y++)
{
- for(y=0;y<SCREENVERTS-1;y++)
- {
- // Used for texture coordinates
- // Annoying magic numbers to scale the square texture to
- // a non-square screen..
- float_x = (float)(x/(xfix));
- float_y = (float)(y/(yfix));
- float_nextx = (float)(x+1)/(xfix);
- float_nexty = (float)(y+1)/(yfix);
-
- // Attach the squares together.
- pglTexCoord2f( float_x, float_y);
- pglVertex3f(points[x][y][0], points[x][y][1], 4.4f);
-
- pglTexCoord2f( float_x, float_nexty);
- pglVertex3f(points[x][y+1][0], points[x][y+1][1], 4.4f);
-
- pglTexCoord2f( float_nextx, float_nexty);
- pglVertex3f(points[x+1][y+1][0], points[x+1][y+1][1], 4.4f);
-
- pglTexCoord2f( float_nextx, float_y);
- pglVertex3f(points[x+1][y][0], points[x+1][y][1], 4.4f);
- }
+ float stCoords[8];
+ float vertCoords[12];
+
+ // Used for texture coordinates
+ // Annoying magic numbers to scale the square texture to
+ // a non-square screen..
+ float_x = (float)(x/(xfix));
+ float_y = (float)(y/(yfix));
+ float_nextx = (float)(x+1)/(xfix);
+ float_nexty = (float)(y+1)/(yfix);
+
+ // float stCoords[8];
+ stCoords[0] = float_x;
+ stCoords[1] = float_y;
+ stCoords[2] = float_x;
+ stCoords[3] = float_nexty;
+ stCoords[4] = float_nextx;
+ stCoords[5] = float_nexty;
+ stCoords[6] = float_nextx;
+ stCoords[7] = float_y;
+
+ pglTexCoordPointer(2, GL_FLOAT, 0, stCoords);
+
+ // float vertCoords[12];
+ vertCoords[0] = points[x][y][0];
+ vertCoords[1] = points[x][y][1];
+ vertCoords[2] = 4.4f;
+ vertCoords[3] = points[x][y + 1][0];
+ vertCoords[4] = points[x][y + 1][1];
+ vertCoords[5] = 4.4f;
+ vertCoords[6] = points[x + 1][y + 1][0];
+ vertCoords[7] = points[x + 1][y + 1][1];
+ vertCoords[8] = 4.4f;
+ vertCoords[9] = points[x + 1][y][0];
+ vertCoords[10] = points[x + 1][y][1];
+ vertCoords[11] = 4.4f;
+
+ pglVertexPointer(3, GL_FLOAT, 0, vertCoords);
+
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
- pglEnd();
+ }
+
pglEnable(GL_DEPTH_TEST);
pglEnable(GL_BLEND);
}
-#endif //SHUFFLE
// Sryder: This needs to be called whenever the screen changes resolution in order to reset the screen textures to use
// a new size
@@ -1935,6 +2438,16 @@ EXPORT void HWRAPI(DrawIntermissionBG)(void)
float xfix, yfix;
INT32 texsize = 2048;
+ const float screenVerts[12] =
+ {
+ -1.0f, -1.0f, 1.0f,
+ -1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, -1.0f, 1.0f
+ };
+
+ float fix[8];
+
if(screen_width <= 1024)
texsize = 1024;
if(screen_width <= 512)
@@ -1943,41 +2456,56 @@ EXPORT void HWRAPI(DrawIntermissionBG)(void)
xfix = 1/((float)(texsize)/((float)((screen_width))));
yfix = 1/((float)(texsize)/((float)((screen_height))));
- pglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
-
- pglBindTexture(GL_TEXTURE_2D, screentexture);
- pglBegin(GL_QUADS);
-
- pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
- // Bottom left
- pglTexCoord2f(0.0f, 0.0f);
- pglVertex3f(-1.0f, -1.0f, 1.0f);
+ // const float screenVerts[12]
- // Top left
- pglTexCoord2f(0.0f, yfix);
- pglVertex3f(-1.0f, 1.0f, 1.0f);
+ // float fix[8];
+ fix[0] = 0.0f;
+ fix[1] = 0.0f;
+ fix[2] = 0.0f;
+ fix[3] = yfix;
+ fix[4] = xfix;
+ fix[5] = yfix;
+ fix[6] = xfix;
+ fix[7] = 0.0f;
- // Top right
- pglTexCoord2f(xfix, yfix);
- pglVertex3f(1.0f, 1.0f, 1.0f);
+ pglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
- // Bottom right
- pglTexCoord2f(xfix, 0.0f);
- pglVertex3f(1.0f, -1.0f, 1.0f);
+ pglBindTexture(GL_TEXTURE_2D, screentexture);
+ pglColor4ubv(white);
- pglEnd();
+ pglTexCoordPointer(2, GL_FLOAT, 0, fix);
+ pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
tex_downloaded = screentexture;
}
// Do screen fades!
-EXPORT void HWRAPI(DoScreenWipe)(float alpha)
+EXPORT void HWRAPI(DoScreenWipe)(void)
{
INT32 texsize = 2048;
float xfix, yfix;
INT32 fademaskdownloaded = tex_downloaded; // the fade mask that has been set
+ const float screenVerts[12] =
+ {
+ -1.0f, -1.0f, 1.0f,
+ -1.0f, 1.0f, 1.0f,
+ 1.0f, 1.0f, 1.0f,
+ 1.0f, -1.0f, 1.0f
+ };
+
+ float fix[8];
+
+ const float defaultST[8] =
+ {
+ 0.0f, 1.0f,
+ 0.0f, 0.0f,
+ 1.0f, 0.0f,
+ 1.0f, 1.0f
+ };
+
// Use a power of two texture, dammit
if(screen_width <= 1024)
texsize = 1024;
@@ -1987,101 +2515,60 @@ EXPORT void HWRAPI(DoScreenWipe)(float alpha)
xfix = 1/((float)(texsize)/((float)((screen_width))));
yfix = 1/((float)(texsize)/((float)((screen_height))));
+ // const float screenVerts[12]
+
+ // float fix[8];
+ fix[0] = 0.0f;
+ fix[1] = 0.0f;
+ fix[2] = 0.0f;
+ fix[3] = yfix;
+ fix[4] = xfix;
+ fix[5] = yfix;
+ fix[6] = xfix;
+ fix[7] = 0.0f;
+
pglClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
SetBlend(PF_Modulated|PF_NoDepthTest|PF_Clip|PF_NoZClip);
+ pglEnable(GL_TEXTURE_2D);
// Draw the original screen
pglBindTexture(GL_TEXTURE_2D, startScreenWipe);
- pglBegin(GL_QUADS);
- pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+ pglColor4ubv(white);
+ pglTexCoordPointer(2, GL_FLOAT, 0, fix);
+ pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
- // Bottom left
- pglTexCoord2f(0.0f, 0.0f);
- pglVertex3f(-1.0f, -1.0f, 1.0f);
+ SetBlend(PF_Modulated|PF_Translucent|PF_NoDepthTest|PF_Clip|PF_NoZClip);
- // Top left
- pglTexCoord2f(0.0f, yfix);
- pglVertex3f(-1.0f, 1.0f, 1.0f);
+ // Draw the end screen that fades in
+ pglActiveTexture(GL_TEXTURE0);
+ pglEnable(GL_TEXTURE_2D);
+ pglBindTexture(GL_TEXTURE_2D, endScreenWipe);
+ pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
- // Top right
- pglTexCoord2f(xfix, yfix);
- pglVertex3f(1.0f, 1.0f, 1.0f);
+ pglActiveTexture(GL_TEXTURE1);
+ pglEnable(GL_TEXTURE_2D);
+ pglBindTexture(GL_TEXTURE_2D, fademaskdownloaded);
- // Bottom right
- pglTexCoord2f(xfix, 0.0f);
- pglVertex3f(1.0f, -1.0f, 1.0f);
+ pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
- pglEnd();
+ // const float defaultST[8]
- SetBlend(PF_Modulated|PF_Translucent|PF_NoDepthTest|PF_Clip|PF_NoZClip);
+ pglClientActiveTexture(GL_TEXTURE0);
+ pglTexCoordPointer(2, GL_FLOAT, 0, fix);
+ pglVertexPointer(3, GL_FLOAT, 0, screenVerts);
+ pglClientActiveTexture(GL_TEXTURE1);
+ pglEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ pglTexCoordPointer(2, GL_FLOAT, 0, defaultST);
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
- if (gl13)
- {
- // Draw the end screen that fades in
- pglActiveTexture(GL_TEXTURE0);
- pglEnable(GL_TEXTURE_2D);
- pglBindTexture(GL_TEXTURE_2D, endScreenWipe);
- pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-
- pglActiveTexture(GL_TEXTURE1);
- pglEnable(GL_TEXTURE_2D);
- pglBindTexture(GL_TEXTURE_2D, fademaskdownloaded);
-
- pglTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
- pglBegin(GL_QUADS);
- pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
-
- // Bottom left
- pglMultiTexCoord2f(GL_TEXTURE0, 0.0f, 0.0f);
- pglMultiTexCoord2f(GL_TEXTURE1, 0.0f, 1.0f);
- pglVertex3f(-1.0f, -1.0f, 1.0f);
-
- // Top left
- pglMultiTexCoord2f(GL_TEXTURE0, 0.0f, yfix);
- pglMultiTexCoord2f(GL_TEXTURE1, 0.0f, 0.0f);
- pglVertex3f(-1.0f, 1.0f, 1.0f);
-
- // Top right
- pglMultiTexCoord2f(GL_TEXTURE0, xfix, yfix);
- pglMultiTexCoord2f(GL_TEXTURE1, 1.0f, 0.0f);
- pglVertex3f(1.0f, 1.0f, 1.0f);
-
- // Bottom right
- pglMultiTexCoord2f(GL_TEXTURE0, xfix, 0.0f);
- pglMultiTexCoord2f(GL_TEXTURE1, 1.0f, 1.0f);
- pglVertex3f(1.0f, -1.0f, 1.0f);
- pglEnd();
-
- pglDisable(GL_TEXTURE_2D); // disable the texture in the 2nd texture unit
- pglActiveTexture(GL_TEXTURE0);
- tex_downloaded = endScreenWipe;
- }
- else
- {
- // Draw the end screen that fades in
- pglBindTexture(GL_TEXTURE_2D, endScreenWipe);
- pglBegin(GL_QUADS);
- pglColor4f(1.0f, 1.0f, 1.0f, alpha);
-
- // Bottom left
- pglTexCoord2f(0.0f, 0.0f);
- pglVertex3f(-1.0f, -1.0f, 1.0f);
-
- // Top left
- pglTexCoord2f(0.0f, yfix);
- pglVertex3f(-1.0f, 1.0f, 1.0f);
-
- // Top right
- pglTexCoord2f(xfix, yfix);
- pglVertex3f(1.0f, 1.0f, 1.0f);
-
- // Bottom right
- pglTexCoord2f(xfix, 0.0f);
- pglVertex3f(1.0f, -1.0f, 1.0f);
- pglEnd();
- tex_downloaded = endScreenWipe;
- }
+ pglDisable(GL_TEXTURE_2D); // disable the texture in the 2nd texture unit
+ pglDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+ pglActiveTexture(GL_TEXTURE0);
+ pglClientActiveTexture(GL_TEXTURE0);
+ tex_downloaded = endScreenWipe;
}
@@ -2144,7 +2631,6 @@ EXPORT void HWRAPI(MakeScreenFinalTexture) (void)
pglCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize, texsize);
tex_downloaded = finalScreenTexture;
-
}
EXPORT void HWRAPI(DrawScreenFinalTexture)(int width, int height)
@@ -2155,6 +2641,9 @@ EXPORT void HWRAPI(DrawScreenFinalTexture)(int width, int height)
FRGBAFloat clearColour;
INT32 texsize = 2048;
+ float off[12];
+ float fix[8];
+
if(screen_width <= 1024)
texsize = 1024;
if(screen_width <= 512)
@@ -2176,33 +2665,43 @@ EXPORT void HWRAPI(DrawScreenFinalTexture)(int width, int height)
yoff = newaspect / origaspect;
}
+ // float off[12];
+ off[0] = -xoff;
+ off[1] = -yoff;
+ off[2] = 1.0f;
+ off[3] = -xoff;
+ off[4] = yoff;
+ off[5] = 1.0f;
+ off[6] = xoff;
+ off[7] = yoff;
+ off[8] = 1.0f;
+ off[9] = xoff;
+ off[10] = -yoff;
+ off[11] = 1.0f;
+
+ // float fix[8];
+ fix[0] = 0.0f;
+ fix[1] = 0.0f;
+ fix[2] = 0.0f;
+ fix[3] = yfix;
+ fix[4] = xfix;
+ fix[5] = yfix;
+ fix[6] = xfix;
+ fix[7] = 0.0f;
+
pglViewport(0, 0, width, height);
clearColour.red = clearColour.green = clearColour.blue = 0;
clearColour.alpha = 1;
ClearBuffer(true, false, &clearColour);
pglBindTexture(GL_TEXTURE_2D, finalScreenTexture);
- pglBegin(GL_QUADS);
-
- pglColor4f(1.0f, 1.0f, 1.0f, 1.0f);
- // Bottom left
- pglTexCoord2f(0.0f, 0.0f);
- pglVertex3f(-xoff, -yoff, 1.0f);
-
- // Top left
- pglTexCoord2f(0.0f, yfix);
- pglVertex3f(-xoff, yoff, 1.0f);
-
- // Top right
- pglTexCoord2f(xfix, yfix);
- pglVertex3f(xoff, yoff, 1.0f);
- // Bottom right
- pglTexCoord2f(xfix, 0.0f);
- pglVertex3f(xoff, -yoff, 1.0f);
+ pglColor4ubv(white);
- pglEnd();
+ pglTexCoordPointer(2, GL_FLOAT, 0, fix);
+ pglVertexPointer(3, GL_FLOAT, 0, off);
+ pglDrawArrays(GL_TRIANGLE_FAN, 0, 4);
tex_downloaded = finalScreenTexture;
}
diff --git a/src/hardware/r_opengl/r_opengl.h b/src/hardware/r_opengl/r_opengl.h
index e6cf164bb088b72ae778bc40fa02814e7f96fcd9..1bb97c37c31aec5dcde5524b907bea8c5576f639 100644
--- a/src/hardware/r_opengl/r_opengl.h
+++ b/src/hardware/r_opengl/r_opengl.h
@@ -71,7 +71,6 @@ extern FILE *gllogstream;
#endif
#ifndef DRIVER_STRING
-// #define USE_PALETTED_TEXTURE
#define DRIVER_STRING "HWRAPI Init(): SRB2 OpenGL renderer" // Tails
#endif
@@ -89,10 +88,6 @@ int SetupPixelFormat(INT32 WantColorBits, INT32 WantStencilBits, INT32 WantDepth
void SetModelView(GLint w, GLint h);
void SetStates(void);
FUNCMATH float byteasfloat(UINT8 fbyte);
-#ifdef USE_PALETTED_TEXTURE
-extern PFNGLCOLORTABLEEXTPROC glColorTableEXT;
-extern GLubyte palette_tex[256*3];
-#endif
#ifndef GL_EXT_texture_filter_anisotropic
#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
@@ -118,6 +113,10 @@ typedef void (APIENTRY * PFNglGetIntegerv) (GLenum pname, GLint *params);
extern PFNglGetIntegerv pglGetIntegerv;
typedef const GLubyte* (APIENTRY * PFNglGetString) (GLenum name);
extern PFNglGetString pglGetString;
+#if 0
+typedef void (APIENTRY * PFNglEnableClientState) (GLenum cap); // redefined in r_opengl.c
+static PFNglEnableClientState pglEnableClientState;
+#endif
#endif
// ==========================================================================
diff --git a/src/hardware/r_opengl/r_vbo.h b/src/hardware/r_opengl/r_vbo.h
new file mode 100644
index 0000000000000000000000000000000000000000..ca1a974dabbbe6cc296e0f237d2f7dacd1d2328b
--- /dev/null
+++ b/src/hardware/r_opengl/r_vbo.h
@@ -0,0 +1,52 @@
+/*
+ From the 'Wizard2' engine by Spaddlewit Inc. ( http://www.spaddlewit.com )
+ An experimental work-in-progress.
+
+ Donated to Sonic Team Junior and adapted to work with
+ Sonic Robo Blast 2. The license of this code matches whatever
+ the licensing is for Sonic Robo Blast 2.
+*/
+#ifndef _R_VBO_H_
+#define _R_VBO_H_
+
+typedef struct
+{
+ float x, y, z; // Vertex
+ float nx, ny, nz; // Normal
+ float s0, t0; // Texcoord0
+} vbo32_t;
+
+typedef struct
+{
+ float x, y, z; // Vertex
+ float s0, t0; // Texcoord0
+ unsigned char r, g, b, a; // Color
+ float pad[2]; // Pad
+} vbo2d32_t;
+
+typedef struct
+{
+ float x, y; // Vertex
+ float s0, t0; // Texcoord0
+} vbofont_t;
+
+typedef struct
+{
+ short x, y, z; // Vertex
+ char nx, ny, nz; // Normal
+ char tanx, tany, tanz; // Tangent
+ float s0, t0; // Texcoord0
+} vbotiny_t;
+
+typedef struct
+{
+ float x, y, z; // Vertex
+ float nx, ny, nz; // Normal
+ float s0, t0; // Texcoord0
+ float s1, t1; // Texcoord1
+ float s2, t2; // Texcoord2
+ float tan0, tan1, tan2; // Tangent
+ unsigned char r, g, b, a; // Color
+} vbo64_t;
+
+#endif
diff --git a/src/hardware/u_list.c b/src/hardware/u_list.c
new file mode 100644
index 0000000000000000000000000000000000000000..dc49a74e7f7ab1a0502fbf5fb5f13cbbad888275
--- /dev/null
+++ b/src/hardware/u_list.c
@@ -0,0 +1,230 @@
+/*
+ From the 'Wizard2' engine by Spaddlewit Inc. ( http://www.spaddlewit.com )
+ An experimental work-in-progress.
+
+ Donated to Sonic Team Junior and adapted to work with
+ Sonic Robo Blast 2. The license of this code matches whatever
+ the licensing is for Sonic Robo Blast 2.
+*/
+
+#include "u_list.h"
+#include "../z_zone.h"
+
+// Utility for managing
+// structures in a linked
+// list.
+//
+// Struct must have "next" and "prev" pointers
+// as its first two variables.
+//
+
+//
+// ListAdd
+//
+// Adds an item to the list
+//
+void ListAdd(void *pItem, listitem_t **itemHead)
+{
+ listitem_t *item = (listitem_t*)pItem;
+
+ if (*itemHead == NULL)
+ {
+ *itemHead = item;
+ (*itemHead)->prev = (*itemHead)->next = NULL;
+ }
+ else
+ {
+ listitem_t *tail;
+ tail = *itemHead;
+
+ while (tail->next != NULL)
+ tail = tail->next;
+
+ tail->next = item;
+
+ tail->next->prev = tail;
+
+ item->next = NULL;
+ }
+}
+
+//
+// ListAddFront
+//
+// Adds an item to the front of the list
+// (This is much faster)
+//
+void ListAddFront(void *pItem, listitem_t **itemHead)
+{
+ listitem_t *item = (listitem_t*)pItem;
+
+ if (*itemHead == NULL)
+ {
+ *itemHead = item;
+ (*itemHead)->prev = (*itemHead)->next = NULL;
+ }
+ else
+ {
+ (*itemHead)->prev = item;
+ item->next = (*itemHead);
+ item->prev = NULL;
+ *itemHead = item;
+ }
+}
+
+//
+// ListAddBefore
+//
+// Adds an item before the item specified in the list
+//
+void ListAddBefore(void *pItem, void *pSpot, listitem_t **itemHead)
+{
+ listitem_t *item = (listitem_t*)pItem;
+ listitem_t *spot = (listitem_t*)pSpot;
+
+ listitem_t *prev = spot->prev;
+
+ if (!prev)
+ ListAddFront(pItem, itemHead);
+ else
+ {
+ item->next = spot;
+ spot->prev = item;
+ item->prev = prev;
+ prev->next = item;
+ }
+}
+
+//
+// ListAddAfter
+//
+// Adds an item after the item specified in the list
+//
+void ListAddAfter(void *pItem, void *pSpot, listitem_t **itemHead)
+{
+ listitem_t *item = (listitem_t*)pItem;
+ listitem_t *spot = (listitem_t*)pSpot;
+
+ listitem_t *next = spot->next;
+
+ if (!next)
+ ListAdd(pItem, itemHead);
+ else
+ {
+ item->prev = spot;
+ spot->next = item;
+ item->next = next;
+ next->prev = item;
+ }
+}
+
+//
+// ListRemove
+//
+// Take an item out of the list and free its memory.
+//
+void ListRemove(void *pItem, listitem_t **itemHead)
+{
+ listitem_t *item = (listitem_t*)pItem;
+
+ if (item == *itemHead) // Start of list
+ {
+ *itemHead = item->next;
+
+ if (*itemHead)
+ (*itemHead)->prev = NULL;
+ }
+ else if (item->next == NULL) // end of list
+ {
+ item->prev->next = NULL;
+ }
+ else // Somewhere in between
+ {
+ item->prev->next = item->next;
+ item->next->prev = item->prev;
+ }
+
+ Z_Free (item);
+}
+
+//
+// ListRemoveAll
+//
+// Removes all items from the list, freeing their memory.
+//
+void ListRemoveAll(listitem_t **itemHead)
+{
+ listitem_t *item;
+ listitem_t *next;
+ for (item = *itemHead; item; item = next)
+ {
+ next = item->next;
+ ListRemove(item, itemHead);
+ }
+}
+
+//
+// ListRemoveNoFree
+//
+// Take an item out of the list, but don't free its memory.
+//
+void ListRemoveNoFree(void *pItem, listitem_t **itemHead)
+{
+ listitem_t *item = (listitem_t*)pItem;
+
+ if (item == *itemHead) // Start of list
+ {
+ *itemHead = item->next;
+
+ if (*itemHead)
+ (*itemHead)->prev = NULL;
+ }
+ else if (item->next == NULL) // end of list
+ {
+ item->prev->next = NULL;
+ }
+ else // Somewhere in between
+ {
+ item->prev->next = item->next;
+ item->next->prev = item->prev;
+ }
+}
+
+//
+// ListGetCount
+//
+// Counts the # of items in a list
+// Should not be used in performance-minded code
+//
+unsigned int ListGetCount(void *itemHead)
+{
+ listitem_t *item = (listitem_t*)itemHead;
+
+ unsigned int count = 0;
+ for (; item; item = item->next)
+ count++;
+
+ return count;
+}
+
+//
+// ListGetByIndex
+//
+// Gets an item in the list by its index
+// Should not be used in performance-minded code
+//
+listitem_t *ListGetByIndex(void *itemHead, unsigned int index)
+{
+ listitem_t *head = (listitem_t*)itemHead;
+ unsigned int count = 0;
+ listitem_t *node;
+ for (node = head; node; node = node->next)
+ {
+ if (count == index)
+ return node;
+
+ count++;
+ }
+
+ return NULL;
+}
diff --git a/src/hardware/u_list.h b/src/hardware/u_list.h
new file mode 100644
index 0000000000000000000000000000000000000000..7e9a3cabd3bb9e5a9ded2c2d9f1d0f34b074ec3f
--- /dev/null
+++ b/src/hardware/u_list.h
@@ -0,0 +1,29 @@
+/*
+ From the 'Wizard2' engine by Spaddlewit Inc. ( http://www.spaddlewit.com )
+ An experimental work-in-progress.
+
+ Donated to Sonic Team Junior and adapted to work with
+ Sonic Robo Blast 2. The license of this code matches whatever
+ the licensing is for Sonic Robo Blast 2.
+*/
+
+#ifndef _U_LIST_H_
+#define _U_LIST_H_
+
+typedef struct listitem_s
+{
+ struct listitem_s *next;
+ struct listitem_s *prev;
+} listitem_t;
+
+void ListAdd(void *pItem, listitem_t **itemHead);
+void ListAddFront(void *pItem, listitem_t **itemHead);
+void ListAddBefore(void *pItem, void *pSpot, listitem_t **itemHead);
+void ListAddAfter(void *pItem, void *pSpot, listitem_t **itemHead);
+void ListRemove(void *pItem, listitem_t **itemHead);
+void ListRemoveAll(listitem_t **itemHead);
+void ListRemoveNoFree(void *pItem, listitem_t **itemHead);
+unsigned int ListGetCount(void *itemHead);
+listitem_t *ListGetByIndex(void *itemHead, unsigned int index);
+
+#endif
diff --git a/src/hu_stuff.c b/src/hu_stuff.c
index 7270cb986fd6160aa5ace46ff338570342999e41..27926bf8be1a911e65855e70e6b5d9562d2aec1b 100644
--- a/src/hu_stuff.c
+++ b/src/hu_stuff.c
@@ -71,6 +71,10 @@ patch_t *lt_font[LT_FONTSIZE];
patch_t *cred_font[CRED_FONTSIZE];
patch_t *ttlnum[20]; // act numbers (0-19)
+// Name tag fonts
+patch_t *ntb_font[NT_FONTSIZE];
+patch_t *nto_font[NT_FONTSIZE];
+
static player_t *plr;
boolean chat_on; // entering a chat message?
static char w_chat[HU_MAXMSGLEN];
@@ -246,6 +250,32 @@ void HU_LoadGraphics(void)
ttlnum[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
}
+ // cache the base name tag font for entire game execution
+ j = NT_FONTSTART;
+ for (i = 0; i < NT_FONTSIZE; i++)
+ {
+ sprintf(buffer, "NTFNT%.3d", j);
+ j++;
+
+ if (W_CheckNumForName(buffer) == LUMPERROR)
+ ntb_font[i] = NULL;
+ else
+ ntb_font[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
+ }
+
+ // cache the outline name tag font for entire game execution
+ j = NT_FONTSTART;
+ for (i = 0; i < NT_FONTSIZE; i++)
+ {
+ sprintf(buffer, "NTFNO%.3d", j);
+ j++;
+
+ if (W_CheckNumForName(buffer) == LUMPERROR)
+ nto_font[i] = NULL;
+ else
+ nto_font[i] = (patch_t *)W_CachePatchName(buffer, PU_HUDGFX);
+ }
+
// cache the crosshairs, don't bother to know which one is being used,
// just cache all 3, they're so small anyway.
for (i = 0; i < HU_CROSSHAIRS; i++)
diff --git a/src/hu_stuff.h b/src/hu_stuff.h
index ab77e67b6f9a36cd3f390344a0337f9a5e666c4c..55b61d4b7a995d6ffb4f9fd85958ed0d25d2ba66 100644
--- a/src/hu_stuff.h
+++ b/src/hu_stuff.h
@@ -35,6 +35,12 @@
#define CRED_FONTEND 'Z' // the last font character
#define CRED_FONTSIZE (CRED_FONTEND - CRED_FONTSTART + 1)
+// Name tag font
+// Used by base and outline font set
+#define NT_FONTSTART '!' // the first font character
+#define NT_FONTEND 'Z' // the last font character
+#define NT_FONTSIZE (NT_FONTEND - NT_FONTSTART + 1)
+
#define HU_CROSSHAIRS 3 // maximum of 9 - see HU_Init();
extern char *shiftxform; // english translation shift table
@@ -77,6 +83,8 @@ extern patch_t *tallnum[10];
extern patch_t *nightsnum[10];
extern patch_t *lt_font[LT_FONTSIZE];
extern patch_t *cred_font[CRED_FONTSIZE];
+extern patch_t *ntb_font[NT_FONTSIZE];
+extern patch_t *nto_font[NT_FONTSIZE];
extern patch_t *ttlnum[20];
extern patch_t *emeraldpics[3][8];
extern patch_t *rflagico;
diff --git a/src/i_tcp.c b/src/i_tcp.c
index f2b4336dc313faba1f0c3bebe84e31e89fb923ab..da92f27673fa4edc872b2056bfdbc64bea9d07cf 100644
--- a/src/i_tcp.c
+++ b/src/i_tcp.c
@@ -776,6 +776,8 @@ static SOCKET_TYPE UDP_Bind(int family, struct sockaddr *addr, socklen_t addrlen
#endif
#endif
mysockaddr_t straddr;
+ struct sockaddr_in sin;
+ socklen_t len = sizeof(sin);
if (s == (SOCKET_TYPE)ERRSOCKET)
return (SOCKET_TYPE)ERRSOCKET;
@@ -869,12 +871,16 @@ static SOCKET_TYPE UDP_Bind(int family, struct sockaddr *addr, socklen_t addrlen
CONS_Printf(M_GetText("Network system buffer set to: %dKb\n"), opt>>10);
}
+ if (getsockname(s, (struct sockaddr *)&sin, &len) == -1)
+ CONS_Alert(CONS_WARNING, M_GetText("Failed to get port number\n"));
+ else
+ current_port = (UINT16)ntohs(sin.sin_port);
+
return s;
}
static boolean UDP_Socket(void)
{
- const char *sock_port = NULL;
size_t s;
struct my_addrinfo *ai, *runp, hints;
int gaie;
@@ -896,20 +902,11 @@ static boolean UDP_Socket(void)
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
- if (M_CheckParm("-clientport"))
- {
- if (!M_IsNextParm())
- I_Error("syntax: -clientport <portnum>");
- sock_port = M_GetNextParm();
- }
- else
- sock_port = port_name;
-
if (M_CheckParm("-bindaddr"))
{
while (M_IsNextParm())
{
- gaie = I_getaddrinfo(M_GetNextParm(), sock_port, &hints, &ai);
+ gaie = I_getaddrinfo(M_GetNextParm(), port_name, &hints, &ai);
if (gaie == 0)
{
runp = ai;
@@ -930,7 +927,7 @@ static boolean UDP_Socket(void)
}
else
{
- gaie = I_getaddrinfo("0.0.0.0", sock_port, &hints, &ai);
+ gaie = I_getaddrinfo("0.0.0.0", port_name, &hints, &ai);
if (gaie == 0)
{
runp = ai;
@@ -945,8 +942,8 @@ static boolean UDP_Socket(void)
#ifdef HAVE_MINIUPNPC
if (UPNP_support)
{
- I_UPnP_rem(sock_port, "UDP");
- I_UPnP_add(NULL, sock_port, "UDP");
+ I_UPnP_rem(port_name, "UDP");
+ I_UPnP_add(NULL, port_name, "UDP");
}
#endif
}
@@ -963,7 +960,7 @@ static boolean UDP_Socket(void)
{
while (M_IsNextParm())
{
- gaie = I_getaddrinfo(M_GetNextParm(), sock_port, &hints, &ai);
+ gaie = I_getaddrinfo(M_GetNextParm(), port_name, &hints, &ai);
if (gaie == 0)
{
runp = ai;
@@ -984,7 +981,7 @@ static boolean UDP_Socket(void)
}
else
{
- gaie = I_getaddrinfo("::", sock_port, &hints, &ai);
+ gaie = I_getaddrinfo("::", port_name, &hints, &ai);
if (gaie == 0)
{
runp = ai;
@@ -1260,7 +1257,7 @@ static SINT8 SOCK_NetMakeNodewPort(const char *address, const char *port)
int gaie;
if (!port || !port[0])
- port = port_name;
+ port = DEFAULTPORT;
DEBFILE(va("Creating new node: %s@%s\n", address, port));
@@ -1424,14 +1421,15 @@ boolean I_InitTcpNetwork(void)
if (!I_InitTcpDriver())
return false;
- if (M_CheckParm("-udpport"))
+ if (M_CheckParm("-port"))
+ // Combined -udpport and -clientport into -port
+ // As it was really redundant having two seperate parms that does the same thing
{
if (M_IsNextParm())
strcpy(port_name, M_GetNextParm());
else
strcpy(port_name, "0");
}
- current_port = (UINT16)atoi(port_name);
// parse network game options,
if (M_CheckParm("-server") || dedicated)
diff --git a/src/info.c b/src/info.c
index 5fb4d3070247e4cce5ead0eb8c90ad4661c0cc4e..698e6c25f535ea83d505cbe2cf95f419635a264f 100644
--- a/src/info.c
+++ b/src/info.c
@@ -50,6 +50,8 @@ char sprnames[NUMSPRITES + 1][5] =
"TURR", // Pop-Up Turret
"SHRP", // Sharp
"CRAB", // Crushstacean
+ "CR2B", // Banpyura
+ "CSPR", // Banpyura spring
"JJAW", // Jet Jaw
"SNLR", // Snailer
"VLTR", // BASH
@@ -68,6 +70,8 @@ char sprnames[NUMSPRITES + 1][5] =
"UNID", // Unidus
"CANA", // Canarivore
"CANG", // Canarivore gas
+ "PYRE", // Pyre Fly
+ "PTER", // Pterabyte
// Generic Boss Items
"JETF", // Boss jet fumes
@@ -149,6 +153,7 @@ char sprnames[NUMSPRITES + 1][5] =
"WSPB", // Wall spike base
"STPT", // Starpost
"BMNE", // Big floating mine
+ "PUMI", // Rollout Rock
// Monitor Boxes
"MSTV", // MiSc TV sprites
@@ -263,7 +268,6 @@ char sprnames[NUMSPRITES + 1][5] =
"ADST", // Arid dust
"MCRT", // Minecart
"MCSP", // Minecart spark
- "NON2", // Saloon door thinker
"SALD", // Saloon door
"TRAE", // Train cameo locomotive
"TRAI", // Train cameo wagon
@@ -272,6 +276,10 @@ char sprnames[NUMSPRITES + 1][5] =
// Red Volcano Scenery
"FLME", // Flame jet
"DFLM", // Blade's flame
+ "LFAL", // Lavafall
+ "JPLA", // Jungle palm
+ "TFLO", // Torch flower
+ "WVIN", // Wall vines
// Dark City Scenery
@@ -283,7 +291,9 @@ char sprnames[NUMSPRITES + 1][5] =
"XMS3", // Snowman
"XMS4", // Lamppost
"XMS5", // Hanging Star
+ "XMS6", // Mistletoe
"FHZI", // FHZ ice
+ "ROSY",
// Halloween Scenery
"PUMK", // Pumpkins
@@ -291,6 +301,11 @@ char sprnames[NUMSPRITES + 1][5] =
"SHRM", // Mushroom
"HHZM", // Misc
+ // Azure Temple Scenery
+ "BGAR", // ATZ Gargoyles
+ "RCRY", // ATZ Red Crystal (Target)
+ "CFLM", // Green torch flame
+
// Botanic Serenity Scenery
"BSZ1", // Tall flowers
"BSZ2", // Medium flowers
@@ -310,7 +325,6 @@ char sprnames[NUMSPRITES + 1][5] =
// Misc Scenery
"STLG", // Stalagmites
"DBAL", // Disco
- "RCRY", // ATZ Red Crystal (Target)
// Powerup Indicators
"ARMA", // Armageddon Shield Orb
@@ -364,11 +378,14 @@ char sprnames[NUMSPRITES + 1][5] =
"SSWY", // Yellow Side Spring
"SSWR", // Red Side Spring
"SSWB", // Blue Side Spring
+ "BSTY", // Yellow Booster
+ "BSTR", // Red Booster
// Environmental Effects
"RAIN", // Rain
"SNO1", // Snowflake
"SPLH", // Water Splish
+ "LSPL", // Lava Splish
"SPLA", // Water Splash
"SMOK",
"BUBL", // Bubble
@@ -516,6 +533,7 @@ char spr2names[NUMPLAYERSPRITES][5] =
"TIRE",
"GLID",
+ "LAND",
"CLNG",
"CLMB",
@@ -523,7 +541,6 @@ char spr2names[NUMPLAYERSPRITES][5] =
"FRUN",
"BNCE",
- "BLND",
"FIRE",
@@ -619,6 +636,7 @@ playersprite_t spr2defaults[NUMPLAYERSPRITES] = {
0, // SPR2_TIRE, (conditional, will never be referenced)
SPR2_FLY , // SPR2_GLID,
+ SPR2_ROLL, // SPR2_LAND,
SPR2_CLMB, // SPR2_CLNG,
SPR2_ROLL, // SPR2_CLMB,
@@ -626,7 +644,6 @@ playersprite_t spr2defaults[NUMPLAYERSPRITES] = {
SPR2_RUN , // SPR2_FRUN,
SPR2_FALL, // SPR2_BNCE,
- SPR2_ROLL, // SPR2_BLND,
0, // SPR2_FIRE,
@@ -749,6 +766,7 @@ state_t states[NUMSTATES] =
// CA_GLIDEANDCLIMB
{SPR_PLAY, SPR2_GLID, 2, {NULL}, 0, 0, S_PLAY_GLIDE}, // S_PLAY_GLIDE
+ {SPR_PLAY, SPR2_LAND, 9, {NULL}, 0, 0, S_PLAY_STND}, // S_PLAY_GLIDE_LANDING
{SPR_PLAY, SPR2_CLNG|FF_ANIMATE, -1, {NULL}, 0, 4, S_NULL}, // S_PLAY_CLING
{SPR_PLAY, SPR2_CLMB, 5, {NULL}, 0, 0, S_PLAY_CLIMB}, // S_PLAY_CLIMB
@@ -758,7 +776,7 @@ state_t states[NUMSTATES] =
// CA_BOUNCE
{SPR_PLAY, SPR2_BNCE|FF_ANIMATE, -1, {NULL}, 0, 0, S_NULL}, // S_PLAY_BOUNCE
- {SPR_PLAY, SPR2_BLND|FF_SPR2ENDSTATE, 2, {NULL}, S_PLAY_BOUNCE, 0, S_PLAY_BOUNCE_LANDING}, // S_PLAY_BOUNCE_LANDING
+ {SPR_PLAY, SPR2_LAND|FF_SPR2ENDSTATE, 2, {NULL}, S_PLAY_BOUNCE, 0, S_PLAY_BOUNCE_LANDING}, // S_PLAY_BOUNCE_LANDING
// CA2_GUNSLINGER
{SPR_PLAY, SPR2_FIRE|FF_SPR2ENDSTATE, 2, {NULL}, S_PLAY_FIRE_FINISH, 0, S_PLAY_FIRE}, // S_PLAY_FIRE
@@ -790,7 +808,7 @@ state_t states[NUMSTATES] =
{SPR_PLAY, SPR2_LIFE, 20, {NULL}, 0, 4, S_NULL}, // S_PLAY_ICON3
// Level end sign (uses player sprite)
- {SPR_PLAY, SPR2_SIGN, 1, {NULL}, 0, 24, S_PLAY_SIGN}, // S_PLAY_SIGN
+ {SPR_PLAY, SPR2_SIGN|FF_PAPERSPRITE, -1, {NULL}, 0, 29, S_PLAY_SIGN}, // S_PLAY_SIGN
// NiGHTS Player, transforming
{SPR_PLAY, SPR2_TRNS|FF_ANIMATE, 7, {NULL}, 0, 4, S_PLAY_NIGHTS_TRANS2}, // S_PLAY_NIGHTS_TRANS1
@@ -849,6 +867,9 @@ state_t states[NUMSTATES] =
{SPR_PLAY, SPR2_TALA|FF_SPR2MIDSTART, 35, {NULL}, 0, 0, S_TAILSOVERLAY_GASP}, // S_TAILSOVERLAY_GASP
{SPR_PLAY, SPR2_TALB , 35, {NULL}, 0, 0, S_TAILSOVERLAY_EDGE}, // S_TAILSOVERLAY_EDGE
+ // [:
+ {SPR_JETF, 3|FF_ANIMATE|FF_FULLBRIGHT, 2, {NULL}, 1, 1, S_JETFUME1}, // S_JETFUMEFLASH
+
// Blue Crawla
{SPR_POSS, 0, 5, {A_Look}, 0, 0, S_POSS_STND}, // S_POSS_STND
{SPR_POSS, 0, 3, {A_Chase}, 0, 0, S_POSS_RUN2}, // S_POSS_RUN1
@@ -996,6 +1017,22 @@ state_t states[NUMSTATES] =
{SPR_CRAB, 3, 37, {NULL}, 0, 0, S_CRUSHCLAW_AIM}, // S_CRUSHCLAW_WAIT
{SPR_CRAB, 4, -1, {NULL}, 0, 0, S_NULL}, // S_CRUSHCHAIN
+ // Banpyura
+ {SPR_CR2B, 0, 3, {A_CrushstaceanWalk}, 0, S_BANPYURA_ROAMPAUSE, S_BANPYURA_ROAM2}, // S_BANPYURA_ROAM1
+ {SPR_CR2B, 1, 3, {A_CrushstaceanWalk}, 0, S_BANPYURA_ROAMPAUSE, S_BANPYURA_ROAM3}, // S_BANPYURA_ROAM2
+ {SPR_CR2B, 0, 3, {A_CrushstaceanWalk}, 0, S_BANPYURA_ROAMPAUSE, S_BANPYURA_ROAM4}, // S_BANPYURA_ROAM3
+ {SPR_CR2B, 2, 3, {A_CrushstaceanWalk}, 0, S_BANPYURA_ROAMPAUSE, S_BANPYURA_ROAM1}, // S_BANPYURA_ROAM4
+ {SPR_CR2B, 0, 40, {NULL}, 0, 0, S_BANPYURA_ROAM1}, // S_BANPYURA_ROAMPAUSE
+
+ {SPR_CSPR, 0, 1, {A_CrushclawAim}, 50, 20, S_CDIAG1}, // S_CDIAG1
+ {SPR_CSPR, 1, 1, {A_Pain}, 0, 0, S_CDIAG3}, // S_CDIAG2
+ {SPR_CSPR, 2, 1, {A_CrushclawAim}, 50, 20, S_CDIAG4}, // S_CDIAG3
+ {SPR_CSPR, 3, 1, {A_CrushclawAim}, 50, 20, S_CDIAG5}, // S_CDIAG4
+ {SPR_CSPR, 4, 1, {A_CrushclawAim}, 50, 20, S_CDIAG6}, // S_CDIAG5
+ {SPR_CSPR, 3, 1, {A_CrushclawAim}, 50, 20, S_CDIAG7}, // S_CDIAG6
+ {SPR_CSPR, 2, 1, {A_CrushclawAim}, 50, 20, S_CDIAG8}, // S_CDIAG7
+ {SPR_CSPR, 1, 1, {A_CrushclawAim}, 50, 20, S_CDIAG1}, // S_CDIAG8
+
// Jet Jaw
{SPR_JJAW, 0, 1, {A_JetJawRoam}, 0, 0, S_JETJAW_ROAM2}, // S_JETJAW_ROAM1
{SPR_JJAW, 0, 1, {A_JetJawRoam}, 0, 0, S_JETJAW_ROAM3}, // S_JETJAW_ROAM2
@@ -1184,6 +1221,22 @@ state_t states[NUMSTATES] =
{SPR_CANG, 0|FF_TRANS80, 10, {NULL}, 0, 0, S_CANARIVOREGAS_8}, // S_CANARIVOREGAS_7
{SPR_CANG, 0|FF_TRANS90, 10, {NULL}, 0, 0, S_NULL}, // S_CANARIVOREGAS_8
+ // Pyre Fly
+ {SPR_PYRE, FF_ANIMATE, -1, {NULL}, 3, 2, S_NULL}, // S_PYREFLY_FLY
+ {SPR_PYRE, 4|FF_ANIMATE|FF_FULLBRIGHT, -1, {NULL}, 3, 2, S_NULL}, // S_PYREFLY_BURN
+ {SPR_FLAM, FF_FULLBRIGHT, 10, {NULL}, 0, 0, S_PYREFIRE2}, // S_PYREFIRE1
+ {SPR_FLAM, 1|FF_FULLBRIGHT, 10, {A_FireShrink}, 0, 16, S_NULL}, // S_PYREFIRE2
+
+ // Pterabyte
+ {SPR_NULL, 0, -1, {A_SpawnPterabytes}, 0, 0, S_PTERABYTESPAWNER}, // S_PTERABYTESPAWNER
+ {SPR_NULL, 0, 1, {A_PterabyteHover}, 0, 0, S_PTERABYTEWAYPOINT}, // S_PTERABYTEWAYPOINT
+ {SPR_PTER, 0, 6, {NULL}, 0, 0, S_PTERABYTE_FLY2}, // S_PTERABYTE_FLY1
+ {SPR_PTER, 1, 2, {NULL}, 0, 0, S_PTERABYTE_FLY3}, // S_PTERABYTE_FLY2
+ {SPR_PTER, 2, 6, {NULL}, 0, 0, S_PTERABYTE_FLY4}, // S_PTERABYTE_FLY3
+ {SPR_PTER, 3, 2, {NULL}, 0, 0, S_PTERABYTE_FLY1}, // S_PTERABYTE_FLY4
+ {SPR_PTER, 4, 1, {NULL}, 0, 0, S_PTERABYTE_SWOOPDOWN}, // S_PTERABYTE_SWOOPDOWN
+ {SPR_PTER, 0, 1, {NULL}, 0, 0, S_PTERABYTE_SWOOPUP}, // S_PTERABYTE_SWOOPUP
+
// Boss Explosion
{SPR_BOM2, FF_FULLBRIGHT|FF_ANIMATE, (5*7), {NULL}, 6, 5, S_NULL}, // S_BOSSEXPLODE
@@ -1747,38 +1800,24 @@ state_t states[NUMSTATES] =
{SPR_NULL, 0, 1, {A_BossScream}, 0, 0, S_CYBRAKDEMONVILEEXPLOSION1}, //S_CYBRAKDEMONVILEEXPLOSION3,
// Metal Sonic
- {SPR_METL, 0, 35, {NULL}, 0, 0, S_METALSONIC_WAIT1}, // S_METALSONIC_STAND
- {SPR_METL, 1, 8, {NULL}, 0, 0, S_METALSONIC_WAIT2}, // S_METALSONIC_WAIT1
- {SPR_METL, 2, 8, {NULL}, 0, 0, S_METALSONIC_WAIT1}, // S_METALSONIC_WAIT2
- {SPR_METL, 3, 4, {NULL}, 0, 0, S_METALSONIC_WALK2}, // S_METALSONIC_WALK1
- {SPR_METL, 4, 4, {NULL}, 0, 0, S_METALSONIC_WALK3}, // S_METALSONIC_WALK2
- {SPR_METL, 5, 4, {NULL}, 0, 0, S_METALSONIC_WALK4}, // S_METALSONIC_WALK3
- {SPR_METL, 6, 4, {NULL}, 0, 0, S_METALSONIC_WALK5}, // S_METALSONIC_WALK4
- {SPR_METL, 7, 4, {NULL}, 0, 0, S_METALSONIC_WALK6}, // S_METALSONIC_WALK5
- {SPR_METL, 6, 4, {NULL}, 0, 0, S_METALSONIC_WALK7}, // S_METALSONIC_WALK6
- {SPR_METL, 5, 4, {NULL}, 0, 0, S_METALSONIC_WALK8}, // S_METALSONIC_WALK7
- {SPR_METL, 4, 4, {NULL}, 0, 0, S_METALSONIC_WALK1}, // S_METALSONIC_WALK8
- {SPR_METL, 8, 2, {NULL}, 0, 0, S_METALSONIC_RUN2}, // S_METALSONIC_RUN1
- {SPR_METL, 9, 2, {NULL}, 0, 0, S_METALSONIC_RUN3}, // S_METALSONIC_RUN2
- {SPR_METL, 10, 2, {NULL}, 0, 0, S_METALSONIC_RUN4}, // S_METALSONIC_RUN3
- {SPR_METL, 9, 2, {NULL}, 0, 0, S_METALSONIC_RUN1}, // S_METALSONIC_RUN4
+ {SPR_PLAY, SPR2_STND, -1, {NULL}, 0, 0, S_METALSONIC_RACE}, // S_METALSONIC_RACE
{SPR_METL, 4, -1, {NULL}, 0, 0, S_NULL}, // S_METALSONIC_FLOAT
- {SPR_METL, 12|FF_FULLBRIGHT, -1, {NULL}, 0, 0, S_METALSONIC_STUN}, // S_METALSONIC_VECTOR
- {SPR_METL, 11, -1, {NULL}, 0, 0, S_METALSONIC_FLOAT}, // S_METALSONIC_STUN
- {SPR_METL, 13, 20, {NULL}, 0, 0, S_METALSONIC_GATHER},// S_METALSONIC_RAISE
- {SPR_METL, 14, -1, {NULL}, 0, 0, S_NULL}, // S_METALSONIC_GATHER
- {SPR_METL, 15, -1, {NULL}, 0, 0, S_METALSONIC_BOUNCE},// S_METALSONIC_DASH
- {SPR_METL, 14, -1, {NULL}, 0, 0, S_NULL}, // S_METALSONIC_BOUNCE
- {SPR_METL, 16, -1, {NULL}, 0, 0, S_NULL}, // S_METALSONIC_BADBOUNCE
- {SPR_METL, 13, -1, {NULL}, 0, 0, S_METALSONIC_GATHER},// S_METALSONIC_SHOOT
- {SPR_METL, 11, 40, {A_Pain}, 0, 0, S_METALSONIC_FLOAT}, // S_METALSONIC_PAIN
- {SPR_METL, 13, 2, {A_Fall}, 0, 0, S_METALSONIC_DEATH2},// S_METALSONIC_DEATH1
- {SPR_METL, 13, 4, {A_BossScream}, 0, 0, S_METALSONIC_DEATH3},// S_METALSONIC_DEATH2
- {SPR_METL, 13, 0, {A_Repeat}, 17, S_METALSONIC_DEATH2, S_METALSONIC_DEATH4}, // S_METALSONIC_DEATH3
- {SPR_METL, 13, -1, {A_BossDeath}, 0, 0, S_NULL}, // S_METALSONIC_DEATH4
- {SPR_METL, 11, 1, {A_BossScream}, 0, 0, S_METALSONIC_FLEE2}, // S_METALSONIC_FLEE1
- {SPR_METL, 11, 7, {NULL}, 0, 0, S_METALSONIC_FLEE1}, // S_METALSONIC_FLEE2
+ {SPR_METL, 16|FF_FULLBRIGHT, -1, {NULL}, 0, 0, S_METALSONIC_STUN}, // S_METALSONIC_VECTOR
+ {SPR_METL, 15, -1, {NULL}, 0, 0, S_METALSONIC_FLOAT}, // S_METALSONIC_STUN
+ {SPR_METL, 17, 20, {NULL}, 0, 0, S_METALSONIC_GATHER},// S_METALSONIC_RAISE
+ {SPR_METL, 18, -1, {NULL}, 0, 0, S_NULL}, // S_METALSONIC_GATHER
+ {SPR_METL, 6|FF_FULLBRIGHT|FF_ANIMATE|FF_GLOBALANIM, -1, {NULL}, 1, 2, S_METALSONIC_BOUNCE},// S_METALSONIC_DASH
+ {SPR_METL, 18|FF_FULLBRIGHT|FF_ANIMATE|FF_GLOBALANIM, -1, {NULL}, 1, 2, S_NULL}, // S_METALSONIC_BOUNCE
+ {SPR_METL, 14, -1, {NULL}, 0, 0, S_NULL}, // S_METALSONIC_BADBOUNCE
+ {SPR_METL, 17, -1, {NULL}, 0, 0, S_METALSONIC_GATHER},// S_METALSONIC_SHOOT
+ {SPR_METL, 15, 40, {A_Pain}, 0, 0, S_METALSONIC_FLOAT}, // S_METALSONIC_PAIN
+ {SPR_METL, 17, 2, {A_Fall}, 0, 0, S_METALSONIC_DEATH2},// S_METALSONIC_DEATH1
+ {SPR_METL, 17, 4, {A_BossScream}, 0, 0, S_METALSONIC_DEATH3},// S_METALSONIC_DEATH2
+ {SPR_METL, 17, 0, {A_Repeat}, 17, S_METALSONIC_DEATH2, S_METALSONIC_DEATH4}, // S_METALSONIC_DEATH3
+ {SPR_METL, 17, -1, {A_BossDeath}, 0, 0, S_NULL}, // S_METALSONIC_DEATH4
+ {SPR_METL, 15, 1, {A_BossScream}, 0, 0, S_METALSONIC_FLEE2}, // S_METALSONIC_FLEE1
+ {SPR_METL, 15, 7, {NULL}, 0, 0, S_METALSONIC_FLEE1}, // S_METALSONIC_FLEE2
{SPR_MSCF, FF_FULLBRIGHT|FF_TRANS30|FF_ANIMATE, -1, {NULL}, 11, 1, S_NULL}, // S_MSSHIELD_F1
{SPR_MSCF, FF_FULLBRIGHT|FF_ANIMATE|12, -1, {NULL}, 8, 2, S_NULL}, // S_MSSHIELD_F2
@@ -1872,59 +1911,18 @@ state_t states[NUMSTATES] =
{SPR_BBLS, 3, 8, {A_BubbleCheck}, 0, 0, S_BUBBLES1}, // S_BUBBLES4
// Level End Sign
- {SPR_SIGN, 0, 1, {NULL}, 0, 0, S_SIGN2}, // S_SIGN1
- {SPR_SIGN, 1, 1, {NULL}, 0, 0, S_SIGN3}, // S_SIGN2
- {SPR_SIGN, 2, 1, {NULL}, 0, 0, S_SIGN4}, // S_SIGN3
- {SPR_SIGN, 5, 1, {NULL}, 0, 0, S_SIGN5}, // S_SIGN4
- {SPR_SIGN, 0, 1, {NULL}, 0, 0, S_SIGN6}, // S_SIGN5
- {SPR_SIGN, 1, 1, {NULL}, 0, 0, S_SIGN7}, // S_SIGN6
- {SPR_SIGN, 2, 1, {NULL}, 0, 0, S_SIGN8}, // S_SIGN7
- {SPR_SIGN, 3, 1, {NULL}, 0, 0, S_SIGN9}, // S_SIGN8
- {SPR_SIGN, 0, 1, {NULL}, 0, 0, S_SIGN10}, // S_SIGN9
- {SPR_SIGN, 1, 1, {NULL}, 0, 0, S_SIGN11}, // S_SIGN10
- {SPR_SIGN, 2, 1, {NULL}, 0, 0, S_SIGN12}, // S_SIGN11
- {SPR_SIGN, 4, 1, {NULL}, 0, 0, S_SIGN13}, // S_SIGN12
- {SPR_SIGN, 0, 1, {NULL}, 0, 0, S_SIGN14}, // S_SIGN13
- {SPR_SIGN, 1, 1, {NULL}, 0, 0, S_SIGN15}, // S_SIGN14
- {SPR_SIGN, 2, 1, {NULL}, 0, 0, S_SIGN16}, // S_SIGN15
- {SPR_SIGN, 3, 1, {NULL}, 0, 0, S_SIGN17}, // S_SIGN16
- {SPR_SIGN, 0, 1, {NULL}, 0, 0, S_SIGN18}, // S_SIGN17
- {SPR_SIGN, 1, 1, {NULL}, 0, 0, S_SIGN19}, // S_SIGN18
- {SPR_SIGN, 2, 1, {NULL}, 0, 0, S_SIGN20}, // S_SIGN19
- {SPR_SIGN, 6, 1, {NULL}, 0, 0, S_SIGN21}, // S_SIGN20
- {SPR_SIGN, 0, 1, {NULL}, 0, 0, S_SIGN22}, // S_SIGN21
- {SPR_SIGN, 1, 1, {NULL}, 0, 0, S_SIGN23}, // S_SIGN22
- {SPR_SIGN, 2, 1, {NULL}, 0, 0, S_SIGN24}, // S_SIGN23
- {SPR_SIGN, 3, 1, {NULL}, 0, 0, S_SIGN25}, // S_SIGN24
- {SPR_SIGN, 0, 1, {NULL}, 0, 0, S_SIGN26}, // S_SIGN25
- {SPR_SIGN, 1, 1, {NULL}, 0, 0, S_SIGN27}, // S_SIGN26
- {SPR_SIGN, 2, 1, {NULL}, 0, 0, S_SIGN28}, // S_SIGN27
- {SPR_SIGN, 5, 1, {NULL}, 0, 0, S_SIGN29}, // S_SIGN28
- {SPR_SIGN, 0, 1, {NULL}, 0, 0, S_SIGN30}, // S_SIGN29
- {SPR_SIGN, 1, 1, {NULL}, 0, 0, S_SIGN31}, // S_SIGN30
- {SPR_SIGN, 2, 1, {NULL}, 0, 0, S_SIGN32}, // S_SIGN31
- {SPR_SIGN, 3, 1, {NULL}, 0, 0, S_SIGN33}, // S_SIGN32
- {SPR_SIGN, 0, 1, {NULL}, 0, 0, S_SIGN34}, // S_SIGN33
- {SPR_SIGN, 1, 1, {NULL}, 0, 0, S_SIGN35}, // S_SIGN34
- {SPR_SIGN, 2, 1, {NULL}, 0, 0, S_SIGN36}, // S_SIGN35
- {SPR_SIGN, 4, 1, {NULL}, 0, 0, S_SIGN37}, // S_SIGN36
- {SPR_SIGN, 0, 1, {NULL}, 0, 0, S_SIGN38}, // S_SIGN37
- {SPR_SIGN, 1, 1, {NULL}, 0, 0, S_SIGN39}, // S_SIGN38
- {SPR_SIGN, 2, 1, {NULL}, 0, 0, S_SIGN40}, // S_SIGN39
- {SPR_SIGN, 3, 1, {NULL}, 0, 0, S_SIGN41}, // S_SIGN40
- {SPR_SIGN, 0, 1, {NULL}, 0, 0, S_SIGN42}, // S_SIGN41
- {SPR_SIGN, 1, 1, {NULL}, 0, 0, S_SIGN43}, // S_SIGN42
- {SPR_SIGN, 2, 1, {NULL}, 0, 0, S_SIGN44}, // S_SIGN43
- {SPR_SIGN, 6, 1, {NULL}, 0, 0, S_SIGN45}, // S_SIGN44
- {SPR_SIGN, 0, 1, {NULL}, 0, 0, S_SIGN46}, // S_SIGN45
- {SPR_SIGN, 1, 1, {NULL}, 0, 0, S_SIGN47}, // S_SIGN46
- {SPR_SIGN, 2, 1, {NULL}, 0, 0, S_SIGN48}, // S_SIGN47
- {SPR_SIGN, 3, 1, {NULL}, 0, 0, S_SIGN49}, // S_SIGN48
- {SPR_SIGN, 0, 1, {NULL}, 0, 0, S_SIGN50}, // S_SIGN49
- {SPR_SIGN, 1, 1, {NULL}, 0, 0, S_SIGN51}, // S_SIGN50
- {SPR_SIGN, 2, 1, {NULL}, 0, 0, S_SIGN53}, // S_SIGN51
- {SPR_SIGN, 3, -1, {NULL}, 0, 0, S_NULL}, // S_SIGN52 Eggman
- {SPR_SIGN, 7, -1, {A_SignPlayer}, 0, 0, S_NULL}, // S_SIGN53 Blank
+ {SPR_SIGN, 0, -1, {A_SignPlayer}, -3, 0, S_NULL}, // S_SIGN
+ {SPR_SIGN, 0, 1, {A_SignSpin}, 30, 0, S_SIGNSPIN2}, // S_SIGNSPIN1
+ {SPR_SIGN, 0, 0, {A_Repeat}, 4, S_SIGNSPIN1, S_SIGNSPIN3}, // S_SIGNSPIN2
+ {SPR_SIGN, 0, 0, {A_SignPlayer}, -2, 0, S_SIGNSPIN4}, // S_SIGNSPIN3
+ {SPR_SIGN, 0, 1, {A_SignSpin}, 30, 0, S_SIGNSPIN5}, // S_SIGNSPIN4
+ {SPR_SIGN, 0, 0, {A_Repeat}, 4, S_SIGNSPIN4, S_SIGNSPIN6}, // S_SIGNSPIN5
+ {SPR_SIGN, 0, 0, {A_SignPlayer}, -3, 0, S_SIGNSPIN1}, // S_SIGNSPIN6
+ {SPR_SIGN, 0, 1, {A_SignPlayer}, -1, 0, S_SIGNSLOW}, // S_SIGNPLAYER
+ {SPR_SIGN, 0, 1, {A_SignSpin}, 30, 0, S_SIGNSLOW}, // S_SIGNSLOW
+ {SPR_SIGN, 0, -1, {NULL}, 0, 0, S_NULL}, // S_SIGNSTOP
+ {SPR_SIGN, FF_PAPERSPRITE|2, -1, {NULL}, 0, 0, S_NULL}, // S_SIGNBOARD
+ {SPR_SIGN, FF_PAPERSPRITE|1, -1, {NULL}, 0, 29, S_NULL}, // S_EGGMANSIGN
// Spike Ball
{SPR_SPIK, 0, 1, {NULL}, 0, 0, S_SPIKEBALL2}, // S_SPIKEBALL1
@@ -2462,8 +2460,8 @@ state_t states[NUMSTATES] =
{SPR_MCSP, FF_FULLBRIGHT, 1, {A_MinecartSparkThink}, 0, 0, S_MINECARTSPARK}, // S_MINECARTSPARK
// Saloon door
- {SPR_SALD, 0|FF_PAPERSPRITE, -1, {NULL}, 0, 0, S_NULL}, // S_SALOONDOOR
- {SPR_NON2, 0, -1, {A_SaloonDoorSpawn}, 0, 0, S_NULL}, // S_SALONDOORTHINKER
+ {SPR_SALD, 0|FF_PAPERSPRITE, -1, {NULL}, 0, 0, S_NULL}, // S_SALOONDOOR
+ {SPR_NULL, 0, -1, {A_SaloonDoorSpawn}, MT_SALOONDOOR, 48, S_NULL}, // S_SALOONDOORCENTER
// Train cameo
{SPR_NULL, 0, -1, {NULL}, 0, 0, S_TRAINCAMEOSPAWNER_2}, // S_TRAINCAMEOSPAWNER_1
@@ -2483,6 +2481,12 @@ state_t states[NUMSTATES] =
{SPR_FLME, FF_FULLBRIGHT , 4, {NULL}, 0, 0, S_FLAMEJETFLAME2}, // S_FLAMEJETFLAME1
{SPR_FLME, FF_FULLBRIGHT|1, 5, {NULL}, 0, 0, S_FLAMEJETFLAME3}, // S_FLAMEJETFLAME2
{SPR_FLME, FF_FULLBRIGHT|2, 11, {NULL}, 0, 0, S_NULL}, // S_FLAMEJETFLAME3
+ {SPR_FLME, FF_FULLBRIGHT|3, 4, {NULL}, 0, 0, S_FLAMEJETFLAME5}, // S_FLAMEJETFLAME4
+ {SPR_FLME, FF_FULLBRIGHT|4, 5, {NULL}, 0, 0, S_FLAMEJETFLAME6}, // S_FLAMEJETFLAME5
+ {SPR_FLME, FF_FULLBRIGHT|5, 11, {NULL}, 0, 0, S_NULL}, // S_FLAMEJETFLAME6
+ {SPR_FLME, FF_FULLBRIGHT|6, 4, {NULL}, 0, 0, S_FLAMEJETFLAME8}, // S_FLAMEJETFLAME7
+ {SPR_FLME, FF_FULLBRIGHT|7, 5, {NULL}, 0, 0, S_FLAMEJETFLAME9}, // S_FLAMEJETFLAME8
+ {SPR_FLME, FF_FULLBRIGHT|8, 11, {NULL}, 0, 0, S_NULL}, // S_FLAMEJETFLAME9
// Spinning flame jets
// A: Counter-clockwise
@@ -2498,32 +2502,60 @@ state_t states[NUMSTATES] =
{SPR_DFLM, FF_FULLBRIGHT|FF_TRANS40, 1, {A_MoveRelative}, 0, 7, S_FLAMEJETFLAMEB3}, // S_FLAMEJETFLAMEB2
{SPR_DFLM, FF_FULLBRIGHT|FF_TRANS40|FF_ANIMATE, (12*7), {NULL}, 7, 12, S_NULL}, // S_FLAMEJETFLAMEB3
- // Trapgoyles
- {SPR_GARG, 0, 67, {NULL}, 0, 0, S_TRAPGOYLE_CHECK}, // S_TRAPGOYLE
- {SPR_GARG, 0, 3, {NULL}, 0, 0, S_TRAPGOYLE_FIRE1}, // S_TRAPGOYLE_CHECK
- {SPR_GARG, 0, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16), S_TRAPGOYLE_FIRE2}, // S_TRAPGOYLE_FIRE1
- {SPR_GARG, 0, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16), S_TRAPGOYLE_FIRE3}, // S_TRAPGOYLE_FIRE2
- {SPR_GARG, 0, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16), S_TRAPGOYLE}, // S_TRAPGOYLE_FIRE3
-
- {SPR_GARG, 0, 67, {NULL}, 0, 0, S_TRAPGOYLEUP_CHECK}, // S_TRAPGOYLEUP
- {SPR_GARG, 0, 3, {NULL}, 0, 0, S_TRAPGOYLEUP_FIRE1}, // S_TRAPGOYLEUP_CHECK
- {SPR_GARG, 0, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16)+45, S_TRAPGOYLEUP_FIRE2}, // S_TRAPGOYLEUP_FIRE1
- {SPR_GARG, 0, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16)+45, S_TRAPGOYLEUP_FIRE3}, // S_TRAPGOYLEUP_FIRE2
- {SPR_GARG, 0, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16)+45, S_TRAPGOYLEUP}, // S_TRAPGOYLEUP_FIRE3
-
- {SPR_GARG, 0, 67, {NULL}, 0, 0, S_TRAPGOYLEDOWN_CHECK}, // S_TRAPGOYLEDOWN
- {SPR_GARG, 0, 3, {NULL}, 0, 0, S_TRAPGOYLEDOWN_FIRE1}, // S_TRAPGOYLEDOWN_CHECK
- {SPR_GARG, 0, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16)+315, S_TRAPGOYLEDOWN_FIRE2}, // S_TRAPGOYLEDOWN_FIRE1
- {SPR_GARG, 0, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16)+315, S_TRAPGOYLEDOWN_FIRE3}, // S_TRAPGOYLEDOWN_FIRE2
- {SPR_GARG, 0, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16)+315, S_TRAPGOYLEDOWN}, // S_TRAPGOYLEDOWN_FIRE3
-
- {SPR_GARG, 0, 135, {NULL}, 0, 0, S_TRAPGOYLELONG_CHECK}, // S_TRAPGOYLELONG
- {SPR_GARG, 0, 3, {NULL}, 0, 0, S_TRAPGOYLELONG_FIRE1}, // S_TRAPGOYLELONG_CHECK
- {SPR_GARG, 0, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16), S_TRAPGOYLELONG_FIRE2}, // S_TRAPGOYLELONG_FIRE1
- {SPR_GARG, 0, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16), S_TRAPGOYLELONG_FIRE3}, // S_TRAPGOYLELONG_FIRE2
- {SPR_GARG, 0, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16), S_TRAPGOYLELONG_FIRE4}, // S_TRAPGOYLELONG_FIRE3
- {SPR_GARG, 0, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16), S_TRAPGOYLELONG_FIRE5}, // S_TRAPGOYLELONG_FIRE4
- {SPR_GARG, 0, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16), S_TRAPGOYLELONG}, // S_TRAPGOYLELONG_FIRE5
+ // Lavafall
+ {SPR_LFAL, 5, 1, {NULL}, 0, 0, S_LAVAFALL_DORMANT}, // S_LAVAFALL_DORMANT
+ {SPR_LFAL, 6|FF_ANIMATE, 4, {A_LavafallRocks}, 1, 2, S_LAVAFALL_TELL}, // S_LAVAFALL_TELL
+ {SPR_LFAL, 9|FF_FULLBRIGHT|FF_ANIMATE, 2, {A_LavafallLava}, 1, 1, S_LAVAFALL_SHOOT}, // S_LAVAFALL_SHOOT
+ {SPR_LFAL, FF_FULLBRIGHT, 1, {A_FallingLavaCheck}, 0, 0, S_LAVAFALL_LAVA2}, // S_LAVAFALL_LAVA1
+ {SPR_LFAL, FF_FULLBRIGHT, 1, {A_FallingLavaCheck}, 0, 0, S_LAVAFALL_LAVA1}, // S_LAVAFALL_LAVA2
+ {SPR_LFAL, 2|FF_FULLBRIGHT|FF_ANIMATE, 9, {NULL}, 2, 3, S_NULL}, // S_LAVAFALL_LAVA3
+ {SPR_LFAL, 11|FF_ANIMATE|FF_RANDOMANIM, 12, {NULL}, 3, 3, S_LAVAFALLROCK}, // S_LAVAFALLROCK
+
+ // Rollout Rock
+ {SPR_NULL, 0, 1, {A_RolloutSpawn}, 256*FRACUNIT, MT_ROLLOUTROCK, S_ROLLOUTSPAWN}, // S_ROLLOUTSPAWN
+ {SPR_PUMI, 0, 1, {A_RolloutRock}, 63*FRACUNIT/64, 7*FRACUNIT/10, S_ROLLOUTROCK}, // S_ROLLOUTROCK
+
+ // RVZ scenery
+ {SPR_JPLA, FF_PAPERSPRITE, -1, {NULL}, 0, 0, S_NULL}, // S_BIGFERNLEAF
+ {SPR_JPLA, 1, 1, {NULL}, 0, 0, S_BIGFERN2}, // S_BIGFERN1
+ {SPR_JPLA, 1, -1, {NULL}, 0, 0, S_NULL}, // S_BIGFERN2
+ {SPR_JPLA, 2, -1, {NULL}, 0, 0, S_NULL}, // S_JUNGLEPALM
+ {SPR_TFLO, FF_FULLBRIGHT, -1, {NULL}, 0, 0, S_TORCHFLOWER}, // S_TORCHFLOWER
+ {SPR_WVIN, FF_PAPERSPRITE, -1, {NULL}, 0, 0, S_NULL}, // S_WALLVINE_LONG
+ {SPR_WVIN, 1|FF_PAPERSPRITE, -1, {NULL}, 0, 0, S_NULL}, // S_WALLVINE_SHORT
+
+ // Glaregoyles
+ {SPR_BGAR, 0, 22, {NULL}, 0, 0, S_GLAREGOYLE_CHARGE}, // S_GLAREGOYLE
+ {SPR_BGAR, 2, 6, {NULL}, 0, 0, S_GLAREGOYLE_BLINK}, // S_GLAREGOYLE_CHARGE
+ {SPR_BGAR, FF_ANIMATE|1, 18, {NULL}, 1, 3, S_GLAREGOYLE_HOLD}, // S_GLAREGOYLE_BLINK
+ {SPR_BGAR, 1, 9, {NULL}, 0, 0, S_GLAREGOYLE_FIRE}, // S_GLAREGOYLE_HOLD
+ {SPR_BGAR, 1, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16), S_GLAREGOYLE_LOOP}, // S_GLAREGOYLE_FIRE
+ {SPR_BGAR, 1, 0, {A_Repeat}, 3, S_GLAREGOYLE_FIRE, S_GLAREGOYLE_COOLDOWN}, // S_GLAREGOYLE_LOOP
+ {SPR_BGAR, FF_ANIMATE|1, 15, {NULL}, 1, 9, S_GLAREGOYLE}, // S_GLAREGOYLE_COOLDOWN
+
+ {SPR_BGAR, 0, 22, {NULL}, 0, 0, S_GLAREGOYLEUP_CHARGE}, // S_GLAREGOYLEUP
+ {SPR_BGAR, 2, 6, {NULL}, 0, 0, S_GLAREGOYLEUP_BLINK}, // S_GLAREGOYLEUP_CHARGE
+ {SPR_BGAR, FF_ANIMATE|1, 18, {NULL}, 1, 3, S_GLAREGOYLEUP_HOLD}, // S_GLAREGOYLEUP_BLINK
+ {SPR_BGAR, 1, 9, {NULL}, 0, 0, S_GLAREGOYLEUP_FIRE}, // S_GLAREGOYLEUP_HOLD
+ {SPR_BGAR, 1, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16)+45, S_GLAREGOYLEUP_LOOP}, // S_GLAREGOYLEUP_FIRE
+ {SPR_BGAR, 1, 0, {A_Repeat}, 3, S_GLAREGOYLEUP_FIRE, S_GLAREGOYLEUP_COOLDOWN}, // S_GLAREGOYLEUP_LOOP
+ {SPR_BGAR, FF_ANIMATE|1, 15, {NULL}, 1, 9, S_GLAREGOYLEUP}, // S_GLAREGOYLEUP_COOLDOWN
+
+ {SPR_BGAR, 0, 22, {NULL}, 0, 0, S_GLAREGOYLEDOWN_CHARGE}, // S_GLAREGOYLEDOWN
+ {SPR_BGAR, 2, 6, {NULL}, 0, 0, S_GLAREGOYLEDOWN_BLINK}, // S_GLAREGOYLEDOWN_CHARGE
+ {SPR_BGAR, FF_ANIMATE|1, 18, {NULL}, 1, 3, S_GLAREGOYLEDOWN_HOLD}, // S_GLAREGOYLEDOWN_BLINK
+ {SPR_BGAR, 1, 9, {NULL}, 0, 0, S_GLAREGOYLEDOWN_FIRE}, // S_GLAREGOYLEDOWN_HOLD
+ {SPR_BGAR, 1, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16)+315, S_GLAREGOYLEDOWN_LOOP}, // S_GLAREGOYLEDOWN_FIRE
+ {SPR_BGAR, 1, 0, {A_Repeat}, 3, S_GLAREGOYLEDOWN_FIRE, S_GLAREGOYLEDOWN_COOLDOWN}, // S_GLAREGOYLEDOWN_LOOP
+ {SPR_BGAR, FF_ANIMATE|1, 15, {NULL}, 1, 9, S_GLAREGOYLEDOWN}, // S_GLAREGOYLEDOWN_COOLDOWN
+
+ {SPR_BGAR, 0, 90, {NULL}, 0, 0, S_GLAREGOYLELONG_CHARGE}, // S_GLAREGOYLELONG
+ {SPR_BGAR, 2, 6, {NULL}, 0, 0, S_GLAREGOYLELONG_BLINK}, // S_GLAREGOYLELONG_CHARGE
+ {SPR_BGAR, FF_ANIMATE|1, 18, {NULL}, 1, 3, S_GLAREGOYLELONG_HOLD}, // S_GLAREGOYLELONG_BLINK
+ {SPR_BGAR, 1, 9, {NULL}, 0, 0, S_GLAREGOYLELONG_FIRE}, // S_GLAREGOYLELONG_HOLD
+ {SPR_BGAR, 1, 1, {A_TrapShot}, (16<<16)+MT_DEMONFIRE, (30<<16), S_GLAREGOYLELONG_LOOP}, // S_GLAREGOYLELONG_FIRE
+ {SPR_BGAR, 1, 0, {A_Repeat}, 5, S_GLAREGOYLELONG_FIRE, S_GLAREGOYLELONG_COOLDOWN}, // S_GLAREGOYLELONG_LOOP
+ {SPR_BGAR, FF_ANIMATE|1, 15, {NULL}, 1, 9, S_GLAREGOYLELONG}, // S_GLAREGOYLELONG_COOLDOWN
// Target/Red Crystal
{SPR_RCRY, 0, -1, {NULL}, 0, 0, S_TARGET_IDLE}, // S_TARGET_IDLE
@@ -2532,6 +2564,12 @@ state_t states[NUMSTATES] =
{SPR_RCRY, 1, 0, {A_SpawnObjectRelative}, 0, MT_TARGET, S_NULL}, // S_TARGET_RESPAWN
{SPR_RCRY, FF_FULLBRIGHT|1, -1, {A_SetObjectFlags}, MF_PUSHABLE, 1, S_TARGET_ALLDONE}, // S_TARGET_ALLDONE
+ // Green flame
+ {SPR_CFLM, FF_FULLBRIGHT|FF_ANIMATE|FF_RANDOMANIM, -1, {NULL}, 7, 3, S_GREENFLAME}, // S_GREENFLAME
+
+ // ATZ Blue Gargoyle
+ {SPR_BGAR, 3, -1, {NULL}, 0, 0, S_NULL}, // S_BLUEGARGOYLE
+
// Stalagmites
{SPR_STLG, 0, -1, {NULL}, 0, 0, S_NULL}, // S_STG0
{SPR_STLG, 1, -1, {NULL}, 0, 0, S_NULL}, // S_STG1
@@ -2552,6 +2590,7 @@ state_t states[NUMSTATES] =
{SPR_XMS4, 0, -1, {NULL}, 0, 0, S_NULL}, // S_LAMPPOST1
{SPR_XMS4, 1, -1, {NULL}, 0, 0, S_NULL}, // S_LAMPPOST2
{SPR_XMS5, 0, -1, {NULL}, 0, 0, S_NULL}, // S_HANGSTAR
+ {SPR_XMS6, 0, -1, {NULL}, 0, 0, S_NULL}, // S_MISTLETOE
// Xmas GFZ bushes
{SPR_BUS3, 1, -1, {NULL}, 0, 0, S_NULL}, // S_XMASBLUEBERRYBUSH
{SPR_BUS1, 1, -1, {NULL}, 0, 0, S_NULL}, // S_XMASBERRYBUSH
@@ -2559,6 +2598,16 @@ state_t states[NUMSTATES] =
// FHZ
{SPR_FHZI, 0, -1, {NULL}, 0, 0, S_NULL}, // S_FHZICE1
{SPR_FHZI, 1, -1, {NULL}, 0, 0, S_NULL}, // S_FHZICE2
+ {SPR_ROSY, 16, 8, {NULL}, 0, 0, S_ROSY_IDLE2}, // S_ROSY_IDLE1
+ {SPR_ROSY, 17, 4, {NULL}, 0, 0, S_ROSY_IDLE3}, // S_ROSY_IDLE2
+ {SPR_ROSY, 18, 8, {NULL}, 0, 0, S_ROSY_IDLE4}, // S_ROSY_IDLE3
+ {SPR_ROSY, 17, 4, {NULL}, 0, 0, S_ROSY_IDLE1}, // S_ROSY_IDLE4
+ {SPR_ROSY, 14, -1, {NULL}, 1, 0, S_NULL}, // S_ROSY_JUMP
+ {SPR_ROSY, 5, -1, {NULL}, 7, 0, S_NULL}, // S_ROSY_WALK
+ {SPR_ROSY, 19, -1, {NULL}, 0, 0, S_NULL}, // S_ROSY_HUG
+ {SPR_ROSY, 13, -1, {NULL}, 0, 0, S_NULL}, // S_ROSY_PAIN
+ {SPR_ROSY, 1|FF_ANIMATE, -1, {NULL}, 3, 16, S_NULL}, // S_ROSY_STND
+ {SPR_ROSY, 20|FF_ANIMATE, TICRATE, {NULL}, 3, 4, S_ROSY_WALK}, // S_ROSY_UNHAPPY
// Halloween Scenery
// Pumpkins
@@ -3214,6 +3263,17 @@ state_t states[NUMSTATES] =
{SPR_SSWB, 2, 1, {NULL}, 0, 0, S_BHORIZ8}, // S_BHORIZ7
{SPR_SSWB, 1, 1, {NULL}, 0, 0, S_BHORIZ1}, // S_BHORIZ8
+ // Boosters
+ {SPR_NULL, 0, 1, {A_Pain}, 0, 0, S_INVISIBLE}, // S_BOOSTERSOUND
+ {SPR_BSTY, FF_ANIMATE, -1, {NULL}, 2, 1, S_NULL}, // S_YELLOWBOOSTERROLLER
+ {SPR_BSTY, 3|FF_PAPERSPRITE|FF_ANIMATE, -1, {NULL}, 2, 3, S_NULL}, // S_YELLOWBOOSTERSEG_LEFT
+ {SPR_BSTY, 6|FF_PAPERSPRITE|FF_ANIMATE, -1, {NULL}, 2, 3, S_NULL}, // S_YELLOWBOOSTERSEG_RIGHT
+ {SPR_BSTY, 9|FF_PAPERSPRITE, -1, {NULL}, 0, 0, S_NULL}, // S_YELLOWBOOSTERSEG_FACE
+ {SPR_BSTR, FF_ANIMATE, -1, {NULL}, 2, 1, S_NULL}, // S_REDBOOSTERROLLER
+ {SPR_BSTR, 3|FF_PAPERSPRITE|FF_ANIMATE, -1, {NULL}, 2, 3, S_NULL}, // S_REDBOOSTERSEG_LEFT
+ {SPR_BSTR, 6|FF_PAPERSPRITE|FF_ANIMATE, -1, {NULL}, 2, 3, S_NULL}, // S_REDBOOSTERSEG_RIGHT
+ {SPR_BSTR, 9|FF_PAPERSPRITE, -1, {NULL}, 0, 0, S_NULL}, // S_REDBOOSTERSEG_FACE
+
// Rain
{SPR_RAIN, FF_FULLBRIGHT|FF_TRANS50, -1, {NULL}, 0, 0, S_NULL}, // S_RAIN1
{SPR_RAIN, FF_FULLBRIGHT|FF_TRANS50, 1, {NULL}, 0, 0, S_RAIN1}, // S_RAINRETURN
@@ -3234,6 +3294,9 @@ state_t states[NUMSTATES] =
{SPR_SPLH, FF_TRANS50|7, 2, {NULL}, 0, 0, S_SPLISH9}, // S_SPLISH8
{SPR_SPLH, FF_TRANS50|8, 2, {NULL}, 0, 0, S_NULL}, // S_SPLISH9
+ // Lava splish
+ {SPR_LSPL, FF_ANIMATE, 16, {NULL}, 7, 2, S_NULL}, // S_LAVASPLISH
+
// Water Splash
{SPR_SPLA, FF_TRANS50 , 3, {NULL}, 0, 0, S_SPLASH2}, // S_SPLASH1
{SPR_SPLA, FF_TRANS70|1, 3, {NULL}, 0, 0, S_SPLASH3}, // S_SPLASH2
@@ -3545,7 +3608,7 @@ state_t states[NUMSTATES] =
// Puma (Mario fireball)
{SPR_PUMA, FF_FULLBRIGHT|2, 1, {A_FishJump}, 0, MT_PUMATRAIL, S_PUMA_START2}, // S_PUMA_START1
- {SPR_PUMA, FF_FULLBRIGHT|2, 1, {A_PlaySound}, sfx_s3k70, 1, S_PUMA_UP1}, // S_PUMA_START2
+ {SPR_PUMA, FF_FULLBRIGHT|2, 1, {A_PlaySound}, sfx_s3k70, 1 + (1<<16), S_PUMA_UP1}, // S_PUMA_START2
{SPR_PUMA, FF_FULLBRIGHT , 2, {A_FishJump}, 0, MT_PUMATRAIL, S_PUMA_UP2}, // S_PUMA_UP1
{SPR_PUMA, FF_FULLBRIGHT|1, 2, {A_FishJump}, 0, MT_PUMATRAIL, S_PUMA_UP3}, // S_PUMA_UP2
{SPR_PUMA, FF_FULLBRIGHT|2, 2, {A_FishJump}, 0, MT_PUMATRAIL, S_PUMA_UP1}, // S_PUMA_UP3
@@ -3754,8 +3817,8 @@ state_t states[NUMSTATES] =
{SPR_BUMB, 5, 120, {NULL}, 0, 0, S_BUMBLEBORE_DIE}, // S_BUMBLEBORE_STUCK2
{SPR_BUMB, 5, 0, {A_CryingToMomma}, 0, 0, S_XPLD1}, // S_BUMBLEBORE_DIE
- {SPR_BBUZ, 0, 2, {NULL}, 0, 0, S_BBUZZFLY2}, // S_BBUZZFLY1
- {SPR_BBUZ, 1, 2, {NULL}, 0, 0, S_BBUZZFLY1}, // S_BBUZZFLY2
+ {SPR_BBUZ, 0, -1, {NULL}, 0, 0, S_NULL}, // S_BUGGLEIDLE
+ {SPR_BBUZ, FF_ANIMATE, -1, {NULL}, 1, 2, S_NULL}, // S_BUGGLEFLY
{SPR_FMCE, 0, 20, {NULL}, 0, 0, S_SMASHSPIKE_EASE1}, // S_SMASHSPIKE_FLOAT
{SPR_FMCE, 0, 4, {A_ZThrust}, 4, (1<<16)|1, S_SMASHSPIKE_EASE2}, // S_SMASHSPIKE_EASE1
@@ -3998,7 +4061,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
MT_THOK, // damage
sfx_None, // activesound
MF_SOLID|MF_SHOOTABLE, // flags
- MT_NULL // raisestate
+ (statenum_t)MT_NULL// raisestate
},
{ // MT_TAILSOVERLAY
@@ -4028,6 +4091,33 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
+ { // MT_METALJETFUME
+ -1, // doomednum
+ S_INVISIBLE, // spawnstate
+ 1000, // spawnhealth
+ S_JETFUMEFLASH, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 8, // speed
+ 8*FRACUNIT, // radius
+ 16*FRACUNIT, // height
+ 2, // display offset
+ 16, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY|MF_SCENERY, // flags
+ S_JETFUME1 // raisestate
+ },
+
{ // MT_BLUECRAWLA
100, // doomednum
S_POSS_STND, // spawnstate
@@ -4422,7 +4512,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_XPLD1, // deathstate
S_NULL, // xdeathstate
sfx_pop, // deathsound
- 1, // speed
+ 600, // speed
22*FRACUNIT, // radius
24*FRACUNIT, // height
0, // display offset
@@ -4430,7 +4520,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
0, // damage
sfx_s3kd2l, // activesound
MF_PAIN|MF_NOGRAVITY|MF_NOCLIPHEIGHT, // flags
- MT_CRUSHCHAIN // raisestate
+ (statenum_t)MT_CRUSHCHAIN// raisestate
},
{ // MT_CRUSHCHAIN
@@ -4460,6 +4550,60 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
+ { // MT_BANPYURA
+ 138, // doomednum
+ S_BANPYURA_ROAM1, // spawnstate
+ 1, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 32, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_XPLD_FLICKY, // deathstate
+ S_NULL, // xdeathstate
+ sfx_pop, // deathsound
+ 8, // speed
+ 24*FRACUNIT, // radius
+ 32*FRACUNIT, // height
+ 0, // display offset
+ 0, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_ENEMY|MF_SPECIAL|MF_SHOOTABLE, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_BANPSPRING
+ -1, // doomednum
+ S_CDIAG1, // spawnstate
+ 1, // spawnhealth
+ S_CDIAG2, // seestate
+ sfx_None, // seesound
+ 0, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_cdfm08, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_XPLD1, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 300, // speed
+ 22*FRACUNIT, // radius
+ 22*FRACUNIT, // height
+ 0, // display offset
+ 11*FRACUNIT, // mass
+ 11*FRACUNIT, // damage
+ sfx_None, // activesound
+ MF_SPRING|MF_NOGRAVITY, // flags
+ S_CDIAG2 // raisestate
+ },
+
{ // MT_JETJAW
113, // doomednum
S_JETJAW_ROAM1, // spawnstate
@@ -4780,7 +4924,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
100, // mass
0, // damage
sfx_None, // activesound
- MF_SCENERY|MF_PAIN|MF_NOCLIPHEIGHT|MF_NOBLOCKMAP|MF_NOGRAVITY, // flags
+ MF_SCENERY|MF_PAIN|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOBLOCKMAP|MF_NOGRAVITY, // flags
S_SNAPPER_LEGRAISE // raisestate
},
@@ -4807,7 +4951,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
100, // mass
0, // damage
sfx_None, // activesound
- MF_PAIN|MF_NOBLOCKMAP|MF_NOGRAVITY, // flags
+ MF_PAIN|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOBLOCKMAP|MF_NOGRAVITY, // flags
S_NULL // raisestate
},
@@ -5027,6 +5171,141 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
+ { // MT_PYREFLY
+ 136, // doomednum
+ S_PYREFLY_FLY, // spawnstate
+ 1, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 0, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_PYREFLY_BURN, // meleestate
+ S_NULL, // missilestate
+ S_XPLD_FLICKY, // deathstate
+ S_NULL, // xdeathstate
+ sfx_pop, // deathsound
+ 1, // speed
+ 24*FRACUNIT, // radius
+ 34*FRACUNIT, // height
+ 0, // display offset
+ DMG_FIRE, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_NOGRAVITY|MF_SPECIAL|MF_SHOOTABLE|MF_ENEMY|MF_SLIDEME, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_PYREFLY_FIRE
+ -1, // doomednum
+ S_PYREFIRE1, // spawnstate
+ 1, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 0, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 24*FRACUNIT, // radius
+ 34*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_NOGRAVITY|MF_NOBLOCKMAP|MF_FIRE|MF_PAIN, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_PTERABYTESPAWNER
+ 135, // doomednum
+ S_PTERABYTESPAWNER, // spawnstate
+ 1, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 0, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 16*FRACUNIT, // radius
+ 16*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_NOGRAVITY|MF_NOCLIPTHING|MF_NOBLOCKMAP|MF_RUNSPAWNFUNC|MF_SCENERY, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_PTERABYTEWAYPOINT
+ -1, // doomednum
+ S_PTERABYTEWAYPOINT, // spawnstate
+ 1, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 0, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 4*FRACUNIT, // speed
+ 24*FRACUNIT, // radius
+ 48*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_NOGRAVITY|MF_NOCLIPTHING|MF_NOBLOCKMAP|MF_RUNSPAWNFUNC|MF_SCENERY, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_PTERABYTE
+ -1, // doomednum
+ S_PTERABYTE_FLY1, // spawnstate
+ 1, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 0, // reactiontime
+ sfx_pscree, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_XPLD_FLICKY, // deathstate
+ S_NULL, // xdeathstate
+ sfx_pop, // deathsound
+ 4*FRACUNIT, // speed
+ 24*FRACUNIT, // radius
+ 48*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_SPECIAL|MF_SHOOTABLE|MF_ENEMY|MF_NOGRAVITY|MF_SLIDEME, // flags
+ S_NULL // raisestate
+ },
+
{ // MT_BOSSEXPLODE
-1, // doomednum
S_BOSSEXPLODE, // spawnstate
@@ -6352,18 +6631,18 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
{ // MT_METALSONIC_RACE
207, // doomednum
- S_METALSONIC_STAND, // spawnstate
+ S_METALSONIC_RACE, // spawnstate
8, // spawnhealth
- S_METALSONIC_WALK1, // seestate
+ S_NULL, // seestate
sfx_None, // seesound
0, // reactiontime
sfx_None, // attacksound
S_NULL, // painstate
0, // painchance
sfx_None, // painsound
- S_METALSONIC_RUN1, // meleestate
+ S_NULL, // meleestate
S_NULL, // missilestate
- S_NULL, // deathstate
+ S_PLAY_DEAD, // deathstate
S_NULL, // xdeathstate
sfx_None, // deathsound
0, // speed
@@ -6373,7 +6652,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
0, // mass
0, // damage
sfx_None, // activesound
- MF_SCENERY|MF_NOGRAVITY|MF_NOCLIPHEIGHT, // flags
+ MF_NOGRAVITY|MF_NOCLIPHEIGHT, // flags
S_NULL // raisestate
},
@@ -6423,7 +6702,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
0, // speed
32*FRACUNIT, // radius
52*FRACUNIT, // height
- 0, // display offset
+ 1, // display offset
0, // mass
0, // damage
sfx_None, // activesound
@@ -7364,19 +7643,19 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
32*FRACUNIT, // height
0, // display offset
0, // mass
- 1*FRACUNIT, // damage
+ 11*FRACUNIT, // damage
sfx_None, // activesound
MF_SPRING|MF_NOGRAVITY, // flags
S_BHORIZ2 // raisestate
},
- { // MT_BUBBLES
- 500, // doomednum
- S_BUBBLES1, // spawnstate
- 1000, // spawnhealth
+ { // MT_BOOSTERSEG
+ -1, // doomednum
+ S_INVISIBLE, // spawnstate
+ 1, // spawnhealth
S_NULL, // seestate
sfx_None, // seesound
- 8, // reactiontime
+ 0, // reactiontime
sfx_None, // attacksound
S_NULL, // painstate
0, // painchance
@@ -7387,23 +7666,23 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL, // xdeathstate
sfx_None, // deathsound
0, // speed
- 8*FRACUNIT, // radius
- 8*FRACUNIT, // height
+ 28*FRACUNIT, // radius
+ 16*FRACUNIT, // height
0, // display offset
100, // mass
0, // damage
sfx_None, // activesound
- MF_NOBLOCKMAP|MF_NOCLIP|MF_SCENERY|MF_RUNSPAWNFUNC, // flags
+ MF_NOBLOCKMAP|MF_NOGRAVITY|MF_NOCLIPHEIGHT|MF_NOCLIP, // flags
S_NULL // raisestate
},
- { // MT_SIGN
- 501, // doomednum
- S_SIGN52, // spawnstate
- 1000, // spawnhealth
- S_PLAY_SIGN, // seestate
- sfx_lvpass, // seesound
- 8, // reactiontime
+ { // MT_BOOSTERROLLER
+ -1, // doomednum
+ S_INVISIBLE, // spawnstate
+ 1, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 0, // reactiontime
sfx_None, // attacksound
S_NULL, // painstate
0, // painchance
@@ -7413,41 +7692,149 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL, // deathstate
S_NULL, // xdeathstate
sfx_None, // deathsound
- 8, // speed
- 8*FRACUNIT, // radius
+ 0, // speed
+ 14*FRACUNIT, // radius
32*FRACUNIT, // height
0, // display offset
- 16, // mass
+ 100, // mass
0, // damage
sfx_None, // activesound
- MF_NOCLIP|MF_SCENERY, // flags
+ MF_NOBLOCKMAP|MF_NOGRAVITY|MF_NOCLIPHEIGHT|MF_NOCLIP, // flags
S_NULL // raisestate
},
- { // MT_SPIKEBALL
- 521, // doomednum
- S_SPIKEBALL1, // spawnstate
- 1000, // spawnhealth
+ { // MT_YELLOWBOOSTER
+ 544, // doomednum
+ S_INVISIBLE, // spawnstate
+ 1, // spawnhealth
S_NULL, // seestate
sfx_None, // seesound
- 8, // reactiontime
+ 0, // reactiontime
sfx_None, // attacksound
S_NULL, // painstate
- 0, // painchance
- sfx_None, // painsound
+ 3, // painchance
+ sfx_cdfm62, // painsound
S_NULL, // meleestate
S_NULL, // missilestate
S_NULL, // deathstate
S_NULL, // xdeathstate
sfx_None, // deathsound
- 10*FRACUNIT, // speed
- 12*FRACUNIT, // radius
- 8*FRACUNIT, // height
+ 0, // speed
+ 28*FRACUNIT, // radius
+ FRACUNIT, // height
0, // display offset
- DMG_SPIKE, // mass
- 1, // damage
+ 0, // mass
+ 36*FRACUNIT, // damage
sfx_None, // activesound
- MF_PAIN|MF_NOGRAVITY, // flags
+ MF_SPRING|MF_NOGRAVITY, // flags
+ S_BOOSTERSOUND // raisestate
+ },
+
+ { // MT_REDBOOSTER
+ 545, // doomednum
+ S_INVISIBLE, // spawnstate
+ 1, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 0, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 3, // painchance
+ sfx_cdfm62, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 28*FRACUNIT, // radius
+ FRACUNIT, // height
+ 0, // display offset
+ 0, // mass
+ 72*FRACUNIT, // damage
+ sfx_None, // activesound
+ MF_SPRING|MF_NOGRAVITY, // flags
+ S_BOOSTERSOUND // raisestate
+ },
+
+ { // MT_BUBBLES
+ 500, // doomednum
+ S_BUBBLES1, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 8*FRACUNIT, // radius
+ 8*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_NOBLOCKMAP|MF_NOCLIP|MF_SCENERY|MF_RUNSPAWNFUNC, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_SIGN
+ 501, // doomednum
+ S_SIGN, // spawnstate
+ 1000, // spawnhealth
+ S_PLAY_SIGN, // seestate
+ sfx_lvpass, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_SIGNPLAYER, // painstate
+ MT_SPARK, // painchance
+ sfx_None, // painsound
+ S_EGGMANSIGN, // meleestate
+ S_NULL, // missilestate
+ S_SIGNSTOP, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 8, // speed
+ 36*FRACUNIT, // radius
+ 32*FRACUNIT, // height
+ 0, // display offset
+ 16, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_NOCLIP|MF_SCENERY|MF_BOUNCE|MF_RUNSPAWNFUNC, // flags
+ S_SIGNBOARD // raisestate
+ },
+
+ { // MT_SPIKEBALL
+ 521, // doomednum
+ S_SPIKEBALL1, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 10*FRACUNIT, // speed
+ 12*FRACUNIT, // radius
+ 8*FRACUNIT, // height
+ 0, // display offset
+ DMG_SPIKE, // mass
+ 1, // damage
+ sfx_None, // activesound
+ MF_PAIN|MF_NOGRAVITY, // flags
S_NULL // raisestate
},
@@ -10908,7 +11295,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
},
{ // MT_SMALLMACE
- -1, // doomednum
+ 1130, // doomednum
S_SMALLMACE, // spawnstate
1000, // spawnhealth
S_NULL, // seestate
@@ -10935,7 +11322,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
},
{ // MT_BIGMACE
- -1, // doomednum
+ 1131, // doomednum
S_BIGMACE, // spawnstate
1000, // spawnhealth
S_NULL, // seestate
@@ -10990,7 +11377,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
{ // MT_BIGGRABCHAIN
-1, // doomednum
- S_BIGGRABCHAIN, // spawnstate
+ S_BIGGRABCHAIN, // spawnstate
1000, // spawnhealth
S_NULL, // seestate
sfx_None, // seesound
@@ -11016,7 +11403,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
},
{ // MT_YELLOWSPRINGBALL
- -1, // doomednum
+ 1134, // doomednum
S_YELLOWSPRINGBALL, // spawnstate
1000, // spawnhealth
S_YELLOWSPRINGBALL2, // seestate
@@ -11043,7 +11430,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
},
{ // MT_REDSPRINGBALL
- -1, // doomednum
+ 1135, // doomednum
S_REDSPRINGBALL, // spawnstate
1000, // spawnhealth
S_REDSPRINGBALL2, // seestate
@@ -11070,7 +11457,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
},
{ // MT_SMALLFIREBAR
- -1, // doomednum
+ 1136, // doomednum
S_SMALLFIREBAR1, // spawnstate
1000, // spawnhealth
S_NULL, // seestate
@@ -11097,7 +11484,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
},
{ // MT_BIGFIREBAR
- -1, // doomednum
+ 1137, // doomednum
S_BIGFIREBAR1, // spawnstate
1000, // spawnhealth
S_NULL, // seestate
@@ -11633,7 +12020,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
0, // damage
sfx_None, // activesound
MF_SLIDEME|MF_SOLID|MF_PUSHABLE, // flags
- MT_ROCKCRUMBLE3 // raisestate
+ (statenum_t)MT_ROCKCRUMBLE3// raisestate
},
{ // MT_BRAMBLES
@@ -12199,7 +12586,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
100, // mass
0, // damage
sfx_None, // activesound
- MF_SOLID|MF_SHOOTABLE|MF_ENEMY|MF_PUSHABLE, // flags
+ MF_SOLID|MF_SHOOTABLE|MF_PUSHABLE, // flags
S_NULL // raisestate
},
@@ -12335,7 +12722,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
0, // damage
sfx_s3k76, // activesound
MF_PUSHABLE, // flags
- MT_MINECARTSIDEMARK // raisestate
+ (statenum_t)MT_MINECARTSIDEMARK// raisestate
},
{ // MT_MINECARTSEG
@@ -12527,9 +12914,9 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
- { // MT_SALOONDOORTHINKER
+ { // MT_SALOONDOORCENTER
1221, // doomednum
- S_SALOONDOORTHINKER, // spawnstate
+ S_SALOONDOORCENTER, // spawnstate
1, // spawnhealth
S_NULL, // seestate
sfx_None, // seesound
@@ -12550,7 +12937,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
100, // mass
0, // damage
sfx_None, // activesound
- MF_NOGRAVITY|MF_RUNSPAWNFUNC, // flags
+ MF_SOLID|MF_NOGRAVITY|MF_RUNSPAWNFUNC|MF_PAPERCOLLISION|MF_NOCLIPHEIGHT, // flags
S_NULL // raisestate
},
@@ -12851,9 +13238,306 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
- { // MT_TRAPGOYLE
+ { // MT_LAVAFALL
+ 1304, // doomednum
+ S_LAVAFALL_DORMANT, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_lvfal1, // seesound
+ 8, // reactiontime
+ sfx_s3kd5l, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 3200*FRACUNIT, // speed
+ 30*FRACUNIT, // radius
+ 32*FRACUNIT, // height
+ 1, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_NOGRAVITY|MF_SPAWNCEILING, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_LAVAFALL_LAVA
+ -1, // doomednum
+ S_LAVAFALL_LAVA1, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_LAVAFALL_LAVA3, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 30*FRACUNIT, // radius
+ 48*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_SPECIAL|MF_PAIN|MF_NOGRAVITY, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_LAVAFALLROCK
+ -1, // doomednum
+ S_LAVAFALLROCK, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 8*FRACUNIT, // radius
+ 8*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_NOBLOCKMAP, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_ROLLOUTSPAWN
+ 1305, // doomednum
+ S_ROLLOUTSPAWN, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 0, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 8*FRACUNIT, // radius
+ 8*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_NOBLOCKMAP|MF_NOGRAVITY|MF_NOCLIP|MF_SPAWNCEILING|MF_SCENERY, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_ROLLOUTROCK
+ -1, // doomednum
+ S_ROLLOUTROCK, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime (sets number of frames the rock cycles through)
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 12*TICRATE, // painchance (sets how long an unridden rock should last before disappearing - set to 0 to disable)
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 32*FRACUNIT, // speed
+ 30*FRACUNIT, // radius
+ 60*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_PUSHABLE|MF_SOLID|MF_SLIDEME, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_BIGFERNLEAF
+ -1, // doomednum
+ S_BIGFERNLEAF, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 32*FRACUNIT, // radius
+ 48*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_SCENERY|MF_NOBLOCKMAP, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_BIGFERN
+ 1306, // doomednum
+ S_BIGFERN1, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 32*FRACUNIT, // radius
+ 48*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_SCENERY|MF_NOBLOCKMAP|MF_RUNSPAWNFUNC, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_JUNGLEPALM
+ 1307, // doomednum
+ S_JUNGLEPALM, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 32*FRACUNIT, // radius
+ 48*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_SCENERY|MF_NOBLOCKMAP, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_TORCHFLOWER
+ 1308, // doomednum
+ S_TORCHFLOWER, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 14*FRACUNIT, // radius
+ 110*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_SCENERY|MF_NOBLOCKMAP, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_WALLVINE_LONG
+ 1309, // doomednum
+ S_WALLVINE_LONG, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 1*FRACUNIT, // radius
+ 288*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_SCENERY|MF_NOBLOCKMAP|MF_NOGRAVITY|MF_NOCLIP, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_WALLVINE_SHORT
+ 1310, // doomednum
+ S_WALLVINE_SHORT, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 1*FRACUNIT, // radius
+ 288*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_SCENERY|MF_NOBLOCKMAP|MF_NOGRAVITY|MF_NOCLIP, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_GLAREGOYLE
1500, // doomednum
- S_TRAPGOYLE, // spawnstate
+ S_GLAREGOYLE, // spawnstate
1000, // spawnhealth
S_NULL, // seestate
sfx_None, // seesound
@@ -12878,9 +13562,9 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
- { // MT_TRAPGOYLEUP
+ { // MT_GLAREGOYLEUP
1501, // doomednum
- S_TRAPGOYLEUP, // spawnstate
+ S_GLAREGOYLEUP, // spawnstate
1000, // spawnhealth
S_NULL, // seestate
sfx_None, // seesound
@@ -12905,9 +13589,9 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
- { // MT_TRAPGOYLEDOWN
+ { // MT_GLAREGOYLEDOWN
1502, // doomednum
- S_TRAPGOYLEDOWN,// spawnstate
+ S_GLAREGOYLEDOWN,// spawnstate
1000, // spawnhealth
S_NULL, // seestate
sfx_None, // seesound
@@ -12932,9 +13616,9 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
- { // MT_TRAPGOYLELONG
+ { // MT_GLAREGOYLELONG
1503, // doomednum
- S_TRAPGOYLELONG,// spawnstate
+ S_GLAREGOYLELONG,// spawnstate
1000, // spawnhealth
S_NULL, // seestate
sfx_None, // seesound
@@ -12986,6 +13670,60 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
+ { // MT_GREENFLAME
+ 1505, // doomednum
+ S_GREENFLAME, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ MT_NULL, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 8*FRACUNIT, // radius
+ 32*FRACUNIT, // height
+ 0, // display offset
+ 0, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_NOGRAVITY|MF_PAIN, // flags
+ S_NULL // raisestate
+ },
+
+ { // MT_BLUEGARGOYLE
+ 1506, // doomednum
+ S_BLUEGARGOYLE, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 21*FRACUNIT, // speed
+ 16*FRACUNIT, // radius
+ 40*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 1, // damage
+ sfx_statu2, // activesound
+ MF_SLIDEME|MF_SOLID|MF_PUSHABLE, // flags
+ S_NULL // raisestate
+ },
+
{ // MT_STALAGMITE0
1900, // doomednum
S_STG0, // spawnstate
@@ -13445,6 +14183,33 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
+ { // MT_MISTLETOE
+ 2105, // doomednum
+ S_MISTLETOE, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 52*FRACUNIT, // radius
+ 106*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 1, // damage
+ sfx_None, // activesound
+ MF_NOBLOCKMAP|MF_NOCLIP|MF_SPAWNCEILING|MF_NOGRAVITY|MF_SCENERY, // flags
+ S_NULL // raisestate
+ },
+
{ // MT_XMASBLUEBERRYBUSH
1859, // doomednum
S_XMASBLUEBERRYBUSH, // spawnstate
@@ -13580,6 +14345,60 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
+ { // MT_ROSY
+ 2104, // doomednum
+ S_ROSY_IDLE1, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 16*FRACUNIT, // radius
+ 48*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_SCENERY|MF_ENEMY|MF_SLIDEME, // flags -- "enemy" may seem weird but it doesn't have any unintended consequences in context because no MF_SHOOTABLE|MF_SPECIAL
+ S_NULL // raisestate
+ },
+
+ { // MT_CDLHRT
+ -1, // doomednum
+ S_LHRT, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 4*FRACUNIT, // speed
+ 4*FRACUNIT, // radius
+ 4*FRACUNIT, // height
+ 1, // display offset
+ 4, // mass
+ 0, // damage
+ sfx_None, // activesound
+ MF_NOBLOCKMAP|MF_NOGRAVITY|MF_NOCLIPHEIGHT|MF_NOCLIP|MF_SCENERY, // flags
+ S_NULL // raisestate
+ },
+
{ // MT_JACKO1
2006, // doomednum
S_JACKO1, // spawnstate
@@ -16635,6 +17454,33 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
+ { // MT_LAVASPLISH
+ -1, // doomednum
+ S_LAVASPLISH, // spawnstate
+ 1000, // spawnhealth
+ S_NULL, // seestate
+ sfx_None, // seesound
+ 8, // reactiontime
+ sfx_None, // attacksound
+ S_NULL, // painstate
+ 0, // painchance
+ sfx_None, // painsound
+ S_NULL, // meleestate
+ S_NULL, // missilestate
+ S_NULL, // deathstate
+ S_NULL, // xdeathstate
+ sfx_None, // deathsound
+ 0, // speed
+ 6*FRACUNIT, // radius
+ 1*FRACUNIT, // height
+ 0, // display offset
+ 100, // mass
+ 1, // damage
+ sfx_None, // activesound
+ MF_NOBLOCKMAP|MF_NOCLIP|MF_NOGRAVITY|MF_SCENERY, // flags
+ S_NULL // raisestate
+ },
+
{ // MT_SMOKE
-1, // doomednum
S_SMOKE1, // spawnstate
@@ -18173,7 +19019,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL, // deathstate
S_PUMA_DOWN3, // xdeathstate
sfx_None, // deathsound
- 0, // speed
+ 2000*FRACUNIT, // speed
8*FRACUNIT, // radius
16*FRACUNIT, // height
0, // display offset
@@ -18207,7 +19053,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
100, // mass
0, // damage
sfx_None, // activesound
- MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY, // flags
+ MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY|MF_SCENERY, // flags
S_NULL // raisestate
},
@@ -19263,11 +20109,11 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
S_NULL // raisestate
},
- { // MT_BUBBLEBUZZ
+ { // MT_BUGGLE
124, // doomednum
- S_BBUZZFLY1, // spawnstate
+ S_BUGGLEIDLE, // spawnstate
1, // spawnhealth
- S_BBUZZFLY1, // seestate
+ S_BUGGLEFLY, // seestate
sfx_None, // seesound
2, // reactiontime
sfx_None, // attacksound
diff --git a/src/info.h b/src/info.h
index 79a191cccd67bb25f19ee4025b1d9ed9a364313a..812c31cbab07fd77aa1fc196d6c10ce35ac082fa 100644
--- a/src/info.h
+++ b/src/info.h
@@ -63,6 +63,7 @@ void A_FishJump(); // Fish Jump
void A_ThrownRing(); // Sparkle trail for red ring
void A_SetSolidSteam();
void A_UnsetSolidSteam();
+void A_SignSpin();
void A_SignPlayer();
void A_OverlayThink();
void A_JetChase();
@@ -268,6 +269,14 @@ void A_SnapperThinker();
void A_SaloonDoorSpawn();
void A_MinecartSparkThink();
void A_ModuloToState();
+void A_LavafallRocks();
+void A_LavafallLava();
+void A_FallingLavaCheck();
+void A_FireShrink();
+void A_SpawnPterabytes();
+void A_PterabyteHover();
+void A_RolloutSpawn();
+void A_RolloutRock();
// ratio of states to sprites to mobj types is roughly 6 : 1 : 1
#define NUMMOBJFREESLOTS 512
@@ -298,6 +307,8 @@ typedef enum sprite
SPR_TURR, // Pop-Up Turret
SPR_SHRP, // Sharp
SPR_CRAB, // Crushstacean
+ SPR_CR2B, // Banpyura
+ SPR_CSPR, // Banpyura spring
SPR_JJAW, // Jet Jaw
SPR_SNLR, // Snailer
SPR_VLTR, // BASH
@@ -316,6 +327,8 @@ typedef enum sprite
SPR_UNID, // Unidus
SPR_CANA, // Canarivore
SPR_CANG, // Canarivore gas
+ SPR_PYRE, // Pyre Fly
+ SPR_PTER, // Pterabyte
// Generic Boss Items
SPR_JETF, // Boss jet fumes
@@ -397,6 +410,7 @@ typedef enum sprite
SPR_WSPB, // Wall spike base
SPR_STPT, // Starpost
SPR_BMNE, // Big floating mine
+ SPR_PUMI, // Rollout Rock
// Monitor Boxes
SPR_MSTV, // MiSc TV sprites
@@ -511,7 +525,6 @@ typedef enum sprite
SPR_ADST, // Arid dust
SPR_MCRT, // Minecart
SPR_MCSP, // Minecart spark
- SPR_NON2, // Saloon door thinker
SPR_SALD, // Saloon door
SPR_TRAE, // Train cameo locomotive
SPR_TRAI, // Train cameo wagon
@@ -520,6 +533,10 @@ typedef enum sprite
// Red Volcano Scenery
SPR_FLME, // Flame jet
SPR_DFLM, // Blade's flame
+ SPR_LFAL, // Lavafall
+ SPR_JPLA, // Jungle palm
+ SPR_TFLO, // Torch flower
+ SPR_WVIN, // Wall vines
// Dark City Scenery
@@ -531,7 +548,9 @@ typedef enum sprite
SPR_XMS3, // Snowman
SPR_XMS4, // Lamppost
SPR_XMS5, // Hanging Star
+ SPR_XMS6, // Mistletoe
SPR_FHZI, // FHZ Ice
+ SPR_ROSY,
// Halloween Scenery
SPR_PUMK, // Pumpkins
@@ -539,6 +558,11 @@ typedef enum sprite
SPR_SHRM, // Mushroom
SPR_HHZM, // Misc
+ // Azure Temple Scenery
+ SPR_BGAR, // ATZ Gargoyles
+ SPR_RCRY, // ATZ Red Crystal (Target)
+ SPR_CFLM, // Green torch flame
+
// Botanic Serenity Scenery
SPR_BSZ1, // Tall flowers
SPR_BSZ2, // Medium flowers
@@ -558,7 +582,6 @@ typedef enum sprite
// Misc Scenery
SPR_STLG, // Stalagmites
SPR_DBAL, // Disco
- SPR_RCRY, // ATZ Red Crystal (Target)
// Powerup Indicators
SPR_ARMA, // Armageddon Shield Orb
@@ -612,11 +635,14 @@ typedef enum sprite
SPR_SSWY, // Yellow Side Spring
SPR_SSWR, // Red Side Spring
SPR_SSWB, // Blue Side Spring
+ SPR_BSTY, // Yellow Booster
+ SPR_BSTR, // Red Booster
// Environmental Effects
SPR_RAIN, // Rain
SPR_SNO1, // Snowflake
SPR_SPLH, // Water Splish
+ SPR_LSPL, // Lava Splish
SPR_SPLA, // Water Splash
SPR_SMOK,
SPR_BUBL, // Bubble
@@ -771,6 +797,7 @@ typedef enum playersprite
SPR2_TIRE, // tired
SPR2_GLID, // glide
+ SPR2_LAND, // landing after glide/bounce
SPR2_CLNG, // cling
SPR2_CLMB, // climb
@@ -778,7 +805,6 @@ typedef enum playersprite
SPR2_FRUN, // float run
SPR2_BNCE, // bounce
- SPR2_BLND, // bounce landing
SPR2_FIRE, // fire
@@ -854,6 +880,12 @@ typedef enum playersprite
NUMPLAYERSPRITES
} playersprite_t;
+// SPR2_XTRA
+#define XTRA_LIFEPIC 0 // Life icon patch
+#define XTRA_CHARSEL 1 // Character select picture
+#define XTRA_CONTINUE 2 // Continue icon
+#define XTRA_ENDING 3 // Ending finale patches
+
typedef enum state
{
S_NULL,
@@ -900,6 +932,7 @@ typedef enum state
// CA_GLIDEANDCLIMB
S_PLAY_GLIDE,
+ S_PLAY_GLIDE_LANDING,
S_PLAY_CLING,
S_PLAY_CLIMB,
@@ -999,6 +1032,9 @@ typedef enum state
S_TAILSOVERLAY_GASP,
S_TAILSOVERLAY_EDGE,
+ // [:
+ S_JETFUMEFLASH,
+
// Blue Crawla
S_POSS_STND,
S_POSS_RUN1,
@@ -1147,6 +1183,21 @@ typedef enum state
S_CRUSHCLAW_WAIT,
S_CRUSHCHAIN,
+ // Banpyura
+ S_BANPYURA_ROAM1,
+ S_BANPYURA_ROAM2,
+ S_BANPYURA_ROAM3,
+ S_BANPYURA_ROAM4,
+ S_BANPYURA_ROAMPAUSE,
+ S_CDIAG1,
+ S_CDIAG2,
+ S_CDIAG3,
+ S_CDIAG4,
+ S_CDIAG5,
+ S_CDIAG6,
+ S_CDIAG7,
+ S_CDIAG8,
+
// Jet Jaw
S_JETJAW_ROAM1,
S_JETJAW_ROAM2,
@@ -1333,6 +1384,22 @@ typedef enum state
S_CANARIVOREGAS_7,
S_CANARIVOREGAS_8,
+ // Pyre Fly
+ S_PYREFLY_FLY,
+ S_PYREFLY_BURN,
+ S_PYREFIRE1,
+ S_PYREFIRE2,
+
+ // Pterabyte
+ S_PTERABYTESPAWNER,
+ S_PTERABYTEWAYPOINT,
+ S_PTERABYTE_FLY1,
+ S_PTERABYTE_FLY2,
+ S_PTERABYTE_FLY3,
+ S_PTERABYTE_FLY4,
+ S_PTERABYTE_SWOOPDOWN,
+ S_PTERABYTE_SWOOPUP,
+
// Boss Explosion
S_BOSSEXPLODE,
@@ -1867,25 +1934,7 @@ typedef enum state
S_CYBRAKDEMONVILEEXPLOSION3,
// Metal Sonic (Race)
- // S_PLAY_STND
- S_METALSONIC_STAND,
- // S_PLAY_TAP1
- S_METALSONIC_WAIT1,
- S_METALSONIC_WAIT2,
- // S_PLAY_WALK
- S_METALSONIC_WALK1,
- S_METALSONIC_WALK2,
- S_METALSONIC_WALK3,
- S_METALSONIC_WALK4,
- S_METALSONIC_WALK5,
- S_METALSONIC_WALK6,
- S_METALSONIC_WALK7,
- S_METALSONIC_WALK8,
- // S_PLAY_SPD1
- S_METALSONIC_RUN1,
- S_METALSONIC_RUN2,
- S_METALSONIC_RUN3,
- S_METALSONIC_RUN4,
+ S_METALSONIC_RACE,
// Metal Sonic (Battle)
S_METALSONIC_FLOAT,
S_METALSONIC_VECTOR,
@@ -1992,59 +2041,18 @@ typedef enum state
S_BUBBLES4,
// Level End Sign
- S_SIGN1,
- S_SIGN2,
- S_SIGN3,
- S_SIGN4,
- S_SIGN5,
- S_SIGN6,
- S_SIGN7,
- S_SIGN8,
- S_SIGN9,
- S_SIGN10,
- S_SIGN11,
- S_SIGN12,
- S_SIGN13,
- S_SIGN14,
- S_SIGN15,
- S_SIGN16,
- S_SIGN17,
- S_SIGN18,
- S_SIGN19,
- S_SIGN20,
- S_SIGN21,
- S_SIGN22,
- S_SIGN23,
- S_SIGN24,
- S_SIGN25,
- S_SIGN26,
- S_SIGN27,
- S_SIGN28,
- S_SIGN29,
- S_SIGN30,
- S_SIGN31,
- S_SIGN32,
- S_SIGN33,
- S_SIGN34,
- S_SIGN35,
- S_SIGN36,
- S_SIGN37,
- S_SIGN38,
- S_SIGN39,
- S_SIGN40,
- S_SIGN41,
- S_SIGN42,
- S_SIGN43,
- S_SIGN44,
- S_SIGN45,
- S_SIGN46,
- S_SIGN47,
- S_SIGN48,
- S_SIGN49,
- S_SIGN50,
- S_SIGN51,
- S_SIGN52, // Eggman
- S_SIGN53,
+ S_SIGN,
+ S_SIGNSPIN1,
+ S_SIGNSPIN2,
+ S_SIGNSPIN3,
+ S_SIGNSPIN4,
+ S_SIGNSPIN5,
+ S_SIGNSPIN6,
+ S_SIGNPLAYER,
+ S_SIGNSLOW,
+ S_SIGNSTOP,
+ S_SIGNBOARD,
+ S_EGGMANSIGN,
// Spike Ball
S_SPIKEBALL1,
@@ -2269,7 +2277,7 @@ typedef enum state
S_ARROW,
S_ARROWBONK,
- // Trapgoyle Demon fire
+ // Glaregoyle Demon fire
S_DEMONFIRE,
// GFZ flowers
@@ -2576,7 +2584,7 @@ typedef enum state
// Saloon door
S_SALOONDOOR,
- S_SALOONDOORTHINKER,
+ S_SALOONDOORCENTER,
// Train cameo
S_TRAINCAMEOSPAWNER_1,
@@ -2597,6 +2605,12 @@ typedef enum state
S_FLAMEJETFLAME1,
S_FLAMEJETFLAME2,
S_FLAMEJETFLAME3,
+ S_FLAMEJETFLAME4,
+ S_FLAMEJETFLAME5,
+ S_FLAMEJETFLAME6,
+ S_FLAMEJETFLAME7,
+ S_FLAMEJETFLAME8,
+ S_FLAMEJETFLAME9,
// Spinning flame jets
S_FJSPINAXISA1, // Counter-clockwise
@@ -2609,29 +2623,57 @@ typedef enum state
S_FLAMEJETFLAMEB2,
S_FLAMEJETFLAMEB3,
- // Trapgoyles
- S_TRAPGOYLE,
- S_TRAPGOYLE_CHECK,
- S_TRAPGOYLE_FIRE1,
- S_TRAPGOYLE_FIRE2,
- S_TRAPGOYLE_FIRE3,
- S_TRAPGOYLEUP,
- S_TRAPGOYLEUP_CHECK,
- S_TRAPGOYLEUP_FIRE1,
- S_TRAPGOYLEUP_FIRE2,
- S_TRAPGOYLEUP_FIRE3,
- S_TRAPGOYLEDOWN,
- S_TRAPGOYLEDOWN_CHECK,
- S_TRAPGOYLEDOWN_FIRE1,
- S_TRAPGOYLEDOWN_FIRE2,
- S_TRAPGOYLEDOWN_FIRE3,
- S_TRAPGOYLELONG,
- S_TRAPGOYLELONG_CHECK,
- S_TRAPGOYLELONG_FIRE1,
- S_TRAPGOYLELONG_FIRE2,
- S_TRAPGOYLELONG_FIRE3,
- S_TRAPGOYLELONG_FIRE4,
- S_TRAPGOYLELONG_FIRE5,
+ // Lavafall
+ S_LAVAFALL_DORMANT,
+ S_LAVAFALL_TELL,
+ S_LAVAFALL_SHOOT,
+ S_LAVAFALL_LAVA1,
+ S_LAVAFALL_LAVA2,
+ S_LAVAFALL_LAVA3,
+ S_LAVAFALLROCK,
+
+ // Rollout Rock
+ S_ROLLOUTSPAWN,
+ S_ROLLOUTROCK,
+
+ // RVZ scenery
+ S_BIGFERNLEAF,
+ S_BIGFERN1,
+ S_BIGFERN2,
+ S_JUNGLEPALM,
+ S_TORCHFLOWER,
+ S_WALLVINE_LONG,
+ S_WALLVINE_SHORT,
+
+ // Glaregoyles
+ S_GLAREGOYLE,
+ S_GLAREGOYLE_CHARGE,
+ S_GLAREGOYLE_BLINK,
+ S_GLAREGOYLE_HOLD,
+ S_GLAREGOYLE_FIRE,
+ S_GLAREGOYLE_LOOP,
+ S_GLAREGOYLE_COOLDOWN,
+ S_GLAREGOYLEUP,
+ S_GLAREGOYLEUP_CHARGE,
+ S_GLAREGOYLEUP_BLINK,
+ S_GLAREGOYLEUP_HOLD,
+ S_GLAREGOYLEUP_FIRE,
+ S_GLAREGOYLEUP_LOOP,
+ S_GLAREGOYLEUP_COOLDOWN,
+ S_GLAREGOYLEDOWN,
+ S_GLAREGOYLEDOWN_CHARGE,
+ S_GLAREGOYLEDOWN_BLINK,
+ S_GLAREGOYLEDOWN_HOLD,
+ S_GLAREGOYLEDOWN_FIRE,
+ S_GLAREGOYLEDOWN_LOOP,
+ S_GLAREGOYLEDOWN_COOLDOWN,
+ S_GLAREGOYLELONG,
+ S_GLAREGOYLELONG_CHARGE,
+ S_GLAREGOYLELONG_BLINK,
+ S_GLAREGOYLELONG_HOLD,
+ S_GLAREGOYLELONG_FIRE,
+ S_GLAREGOYLELONG_LOOP,
+ S_GLAREGOYLELONG_COOLDOWN,
// ATZ's Red Crystal/Target
S_TARGET_IDLE,
@@ -2640,6 +2682,12 @@ typedef enum state
S_TARGET_RESPAWN,
S_TARGET_ALLDONE,
+ // ATZ's green flame
+ S_GREENFLAME,
+
+ // ATZ Blue Gargoyle
+ S_BLUEGARGOYLE,
+
// Stalagmites
S_STG0,
S_STG1,
@@ -2660,6 +2708,7 @@ typedef enum state
S_LAMPPOST1, // normal
S_LAMPPOST2, // with snow
S_HANGSTAR,
+ S_MISTLETOE,
// Xmas GFZ bushes
S_XMASBLUEBERRYBUSH,
S_XMASBERRYBUSH,
@@ -2667,6 +2716,16 @@ typedef enum state
// FHZ
S_FHZICE1,
S_FHZICE2,
+ S_ROSY_IDLE1,
+ S_ROSY_IDLE2,
+ S_ROSY_IDLE3,
+ S_ROSY_IDLE4,
+ S_ROSY_JUMP,
+ S_ROSY_WALK,
+ S_ROSY_HUG,
+ S_ROSY_PAIN,
+ S_ROSY_STND,
+ S_ROSY_UNHAPPY,
// Halloween Scenery
// Pumpkins
@@ -3318,6 +3377,17 @@ typedef enum state
S_BHORIZ7,
S_BHORIZ8,
+ // Booster
+ S_BOOSTERSOUND,
+ S_YELLOWBOOSTERROLLER,
+ S_YELLOWBOOSTERSEG_LEFT,
+ S_YELLOWBOOSTERSEG_RIGHT,
+ S_YELLOWBOOSTERSEG_FACE,
+ S_REDBOOSTERROLLER,
+ S_REDBOOSTERSEG_LEFT,
+ S_REDBOOSTERSEG_RIGHT,
+ S_REDBOOSTERSEG_FACE,
+
// Rain
S_RAIN1,
S_RAINRETURN,
@@ -3338,6 +3408,9 @@ typedef enum state
S_SPLISH8,
S_SPLISH9,
+ // Lava Splish
+ S_LAVASPLISH,
+
// added water splash
S_SPLASH1,
S_SPLASH2,
@@ -3805,8 +3878,8 @@ typedef enum state
S_BUMBLEBORE_STUCK2,
S_BUMBLEBORE_DIE,
- S_BBUZZFLY1,
- S_BBUZZFLY2,
+ S_BUGGLEIDLE,
+ S_BUGGLEFLY,
S_SMASHSPIKE_FLOAT,
S_SMASHSPIKE_EASE1,
@@ -3971,6 +4044,7 @@ typedef enum mobj_type
MT_THOK, // Thok! mobj
MT_PLAYER,
MT_TAILSOVERLAY, // c:
+ MT_METALJETFUME,
// Enemies
MT_BLUECRAWLA, // Crawla (Blue)
@@ -3989,6 +4063,8 @@ typedef enum mobj_type
MT_CRUSHSTACEAN, // Crushstacean
MT_CRUSHCLAW, // Big meaty claw
MT_CRUSHCHAIN, // Chain
+ MT_BANPYURA, // Banpyura
+ MT_BANPSPRING, // Banpyura spring
MT_JETJAW, // Jet Jaw
MT_SNAILER, // Snailer
MT_VULTURE, // BASH
@@ -4010,6 +4086,11 @@ typedef enum mobj_type
MT_UNIBALL, // Unidus Ball
MT_CANARIVORE, // Canarivore
MT_CANARIVORE_GAS, // Canarivore gas
+ MT_PYREFLY, // Pyre Fly
+ MT_PYREFLY_FIRE, // Pyre Fly fire
+ MT_PTERABYTESPAWNER, // Pterabyte spawner
+ MT_PTERABYTEWAYPOINT, // Pterabyte waypoint
+ MT_PTERABYTE, // Pterabyte
// Generic Boss Items
MT_BOSSEXPLODE,
@@ -4121,6 +4202,11 @@ typedef enum mobj_type
MT_REDHORIZ,
MT_BLUEHORIZ,
+ MT_BOOSTERSEG,
+ MT_BOOSTERROLLER,
+ MT_YELLOWBOOSTER,
+ MT_REDBOOSTER,
+
// Interactive Objects
MT_BUBBLES, // Bubble source
MT_SIGN, // Level end sign
@@ -4211,7 +4297,7 @@ typedef enum mobj_type
MT_CANNONBALL, // Cannonball
MT_CANNONBALLDECOR, // Decorative/still cannonball
MT_ARROW, // Arrow
- MT_DEMONFIRE, // Trapgoyle fire
+ MT_DEMONFIRE, // Glaregoyle fire
// Greenflower Scenery
MT_GFZFLOWER1,
@@ -4338,7 +4424,7 @@ typedef enum mobj_type
MT_MINECARTSIDEMARK,
MT_MINECARTSPARK,
MT_SALOONDOOR,
- MT_SALOONDOORTHINKER,
+ MT_SALOONDOORCENTER,
MT_TRAINCAMEOSPAWNER,
MT_TRAINSEG,
MT_TRAINDUSTSPAWNER,
@@ -4355,16 +4441,32 @@ typedef enum mobj_type
MT_FLAMEJETFLAMEB, // Blade's flame
+ MT_LAVAFALL,
+ MT_LAVAFALL_LAVA,
+ MT_LAVAFALLROCK,
+
+ MT_ROLLOUTSPAWN,
+ MT_ROLLOUTROCK,
+
+ MT_BIGFERNLEAF,
+ MT_BIGFERN,
+ MT_JUNGLEPALM,
+ MT_TORCHFLOWER,
+ MT_WALLVINE_LONG,
+ MT_WALLVINE_SHORT,
+
// Dark City Scenery
// Egg Rock Scenery
// Azure Temple Scenery
- MT_TRAPGOYLE,
- MT_TRAPGOYLEUP,
- MT_TRAPGOYLEDOWN,
- MT_TRAPGOYLELONG,
+ MT_GLAREGOYLE,
+ MT_GLAREGOYLEUP,
+ MT_GLAREGOYLEDOWN,
+ MT_GLAREGOYLELONG,
MT_TARGET, // AKA Red Crystal
+ MT_GREENFLAME,
+ MT_BLUEGARGOYLE,
// Stalagmites
MT_STALAGMITE0,
@@ -4386,6 +4488,7 @@ typedef enum mobj_type
MT_LAMPPOST1, // normal
MT_LAMPPOST2, // with snow
MT_HANGSTAR,
+ MT_MISTLETOE,
// Xmas GFZ bushes
MT_XMASBLUEBERRYBUSH,
MT_XMASBERRYBUSH,
@@ -4393,6 +4496,8 @@ typedef enum mobj_type
// FHZ
MT_FHZICE1,
MT_FHZICE2,
+ MT_ROSY,
+ MT_CDLHRT,
// Halloween Scenery
// Pumpkins
@@ -4521,6 +4626,7 @@ typedef enum mobj_type
MT_RAIN, // Rain
MT_SNOWFLAKE, // Snowflake
MT_SPLISH, // Water splish!
+ MT_LAVASPLISH, // Lava splish!
MT_SMOKE,
MT_SMALLBUBBLE, // small bubble
MT_MEDIUMBUBBLE, // medium bubble
@@ -4635,7 +4741,7 @@ typedef enum mobj_type
MT_HIVEELEMENTAL,
MT_BUMBLEBORE,
- MT_BUBBLEBUZZ,
+ MT_BUGGLE,
MT_SMASHINGSPIKEBALL,
MT_CACOLANTERN,
diff --git a/src/lua_baselib.c b/src/lua_baselib.c
index a69e8a188d0030a2893ce4e4eac8237130edafc9..8f173e32ede8f26cda15a3fb1a91a048690601ac 100644
--- a/src/lua_baselib.c
+++ b/src/lua_baselib.c
@@ -816,15 +816,12 @@ static int lib_pCheckDeathPitCollide(lua_State *L)
static int lib_pCheckSolidLava(lua_State *L)
{
- mobj_t *mo = *((mobj_t **)luaL_checkudata(L, 1, META_MOBJ));
ffloor_t *rover = *((ffloor_t **)luaL_checkudata(L, 2, META_FFLOOR));
//HUDSAFE
INLEVEL
- if (!mo)
- return LUA_ErrInvalid(L, "mobj_t");
if (!rover)
return LUA_ErrInvalid(L, "ffloor_t");
- lua_pushboolean(L, P_CheckSolidLava(mo, rover));
+ lua_pushboolean(L, P_CheckSolidLava(rover));
return 1;
}
diff --git a/src/lua_hook.h b/src/lua_hook.h
index 45e116c344243ec23a78f05eb1d0581160747d52..37b1f3e0663e90882e5a5a3ec78fec4c925c05f7 100644
--- a/src/lua_hook.h
+++ b/src/lua_hook.h
@@ -50,6 +50,7 @@ enum hook {
hook_FollowMobj,
hook_PlayerCanDamage,
hook_PlayerQuit,
+ hook_IntermissionThinker,
hook_MAX // last hook
};
@@ -91,5 +92,6 @@ boolean LUAh_MapThingSpawn(mobj_t *mo, mapthing_t *mthing); // Hook for P_SpawnM
boolean LUAh_FollowMobj(player_t *player, mobj_t *mobj); // Hook for P_PlayerAfterThink Smiles mobj-following
UINT8 LUAh_PlayerCanDamage(player_t *player, mobj_t *mobj); // Hook for P_PlayerCanDamage
void LUAh_PlayerQuit(player_t *plr, int reason); // Hook for player quitting
+void LUAh_IntermissionThinker(void); // Hook for Y_Ticker
#endif
diff --git a/src/lua_hooklib.c b/src/lua_hooklib.c
index 7f7e8adc672d19dcb6276bcff0075bc51f56bfb8..03c7ce9113094ef6425a560bdac2ed9410cb8c76 100644
--- a/src/lua_hooklib.c
+++ b/src/lua_hooklib.c
@@ -61,6 +61,7 @@ const char *const hookNames[hook_MAX+1] = {
"FollowMobj",
"PlayerCanDamage",
"PlayerQuit",
+ "IntermissionThinker",
NULL
};
@@ -1322,4 +1323,27 @@ void LUAh_PlayerQuit(player_t *plr, int reason)
lua_settop(gL, 0);
}
+// Hook for Y_Ticker
+void LUAh_IntermissionThinker(void)
+{
+ hook_p hookp;
+ if (!gL || !(hooksAvailable[hook_IntermissionThinker/8] & (1<<(hook_IntermissionThinker%8))))
+ return;
+
+ for (hookp = roothook; hookp; hookp = hookp->next)
+ {
+ if (hookp->type != hook_IntermissionThinker)
+ continue;
+
+ lua_pushfstring(gL, FMT_HOOKID, hookp->id);
+ lua_gettable(gL, LUA_REGISTRYINDEX);
+ if (lua_pcall(gL, 0, 0, 0)) {
+ if (!hookp->error || cv_debug & DBG_LUA)
+ CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
+ lua_pop(gL, 1);
+ hookp->error = true;
+ }
+ }
+}
+
#endif
diff --git a/src/lua_hudlib.c b/src/lua_hudlib.c
index 1fc47c4047d07af04c9cd14fc6d5cff17e678291..de87ef027b3edcb90a6ed8983add0ab7b950ae90 100644
--- a/src/lua_hudlib.c
+++ b/src/lua_hudlib.c
@@ -718,6 +718,68 @@ static int libd_drawString(lua_State *L)
return 0;
}
+static int libd_drawNameTag(lua_State *L)
+{
+ INT32 x;
+ INT32 y;
+ const char *str;
+ INT32 flags;
+ UINT8 basecolor;
+ UINT8 outlinecolor;
+ UINT8 *basecolormap = NULL;
+ UINT8 *outlinecolormap = NULL;
+
+ HUDONLY
+
+ x = luaL_checkinteger(L, 1);
+ y = luaL_checkinteger(L, 2);
+ str = luaL_checkstring(L, 3);
+ flags = luaL_optinteger(L, 4, 0);
+ basecolor = luaL_optinteger(L, 5, SKINCOLOR_BLUE);
+ outlinecolor = luaL_optinteger(L, 6, SKINCOLOR_ORANGE);
+ if (basecolor != SKINCOLOR_NONE)
+ basecolormap = R_GetTranslationColormap(TC_DEFAULT, basecolor, GTC_CACHE);
+ if (outlinecolor != SKINCOLOR_NONE)
+ outlinecolormap = R_GetTranslationColormap(TC_DEFAULT, outlinecolor, GTC_CACHE);
+
+ flags &= ~V_PARAMMASK; // Don't let crashes happen.
+ V_DrawNameTag(x, y, flags, FRACUNIT, basecolormap, outlinecolormap, str);
+ return 0;
+}
+
+static int libd_drawScaledNameTag(lua_State *L)
+{
+ fixed_t x;
+ fixed_t y;
+ const char *str;
+ INT32 flags;
+ fixed_t scale;
+ UINT8 basecolor;
+ UINT8 outlinecolor;
+ UINT8 *basecolormap = NULL;
+ UINT8 *outlinecolormap = NULL;
+
+ HUDONLY
+
+ x = luaL_checkfixed(L, 1);
+ y = luaL_checkfixed(L, 2);
+ str = luaL_checkstring(L, 3);
+ flags = luaL_optinteger(L, 4, 0);
+ scale = luaL_optinteger(L, 5, FRACUNIT);
+ if (scale < 0)
+ return luaL_error(L, "negative scale");
+ basecolor = luaL_optinteger(L, 6, SKINCOLOR_BLUE);
+ outlinecolor = luaL_optinteger(L, 7, SKINCOLOR_ORANGE);
+ if (basecolor != SKINCOLOR_NONE)
+ basecolormap = R_GetTranslationColormap(TC_DEFAULT, basecolor, GTC_CACHE);
+ if (outlinecolor != SKINCOLOR_NONE)
+ outlinecolormap = R_GetTranslationColormap(TC_DEFAULT, outlinecolor, GTC_CACHE);
+
+ flags &= ~V_PARAMMASK; // Don't let crashes happen.
+ V_DrawNameTag(FixedInt(x), FixedInt(y), flags, scale, basecolormap, outlinecolormap, str);
+ return 0;
+}
+
static int libd_stringWidth(lua_State *L)
{
const char *str = luaL_checkstring(L, 1);
@@ -740,6 +802,13 @@ static int libd_stringWidth(lua_State *L)
return 1;
}
+static int libd_nameTagWidth(lua_State *L)
+{
+ HUDONLY
+ lua_pushinteger(L, V_NameTagWidth(luaL_checkstring(L, 1)));
+ return 1;
+}
+
static int libd_getColormap(lua_State *L)
{
INT32 skinnum = TC_DEFAULT;
@@ -918,9 +987,12 @@ static luaL_Reg lib_draw[] = {
{"drawPaddedNum", libd_drawPaddedNum},
{"drawFill", libd_drawFill},
{"drawString", libd_drawString},
+ {"drawNameTag", libd_drawNameTag},
+ {"drawScaledNameTag", libd_drawScaledNameTag},
{"fadeScreen", libd_fadeScreen},
// misc
{"stringWidth", libd_stringWidth},
+ {"nameTagWidth", libd_nameTagWidth},
// m_random
{"RandomFixed",libd_RandomFixed},
{"RandomByte",libd_RandomByte},
diff --git a/src/lua_maplib.c b/src/lua_maplib.c
index dbb69b7e26dd4129600a7915a7a8426a6cd23c54..1da232efa0e07bd9899d45333f05fa78aa564c63 100644
--- a/src/lua_maplib.c
+++ b/src/lua_maplib.c
@@ -411,37 +411,53 @@ static int sector_iterate(lua_State *L)
// sector.lines, i -> sector.lines[i]
// sector.lines.valid, for validity checking
+//
+// 25/9/19 Monster Iestyn
+// Modified this and _num to use triple pointers, to allow for a new hack of mine involving offsetof
+// this way we don't need to check frontsector or backsector of line #0 in the array
+//
static int sectorlines_get(lua_State *L)
{
- line_t **seclines = *((line_t ***)luaL_checkudata(L, 1, META_SECTORLINES));
+ line_t ***seclines = *((line_t ****)luaL_checkudata(L, 1, META_SECTORLINES));
size_t i;
size_t numoflines = 0;
lua_settop(L, 2);
if (!lua_isnumber(L, 2))
{
int field = luaL_checkoption(L, 2, NULL, valid_opt);
- if (!seclines)
+ if (!seclines || !(*seclines))
{
if (field == 0) {
lua_pushboolean(L, 0);
return 1;
}
- return luaL_error(L, "accessed sector_t doesn't exist anymore.");
+ return luaL_error(L, "accessed sector_t.lines doesn't exist anymore.");
} else if (field == 0) {
lua_pushboolean(L, 1);
return 1;
}
}
+/* a snip from sector_t struct in r_defs.h, for reference
+ size_t linecount;
+ struct line_s **lines; // [linecount] size
+*/
+ // get the "linecount" by shifting our retrieved memory address of "lines" to where "linecount" is in the sector_t, then dereferencing the result
+ // we need this to determine the array's actual size, and therefore also the maximum value allowed as an index
+ // this only works if seclines is actually a pointer to a sector's lines member in memory, oh boy
+ numoflines = (size_t)(*(seclines - (offsetof(sector_t, lines) - offsetof(sector_t, linecount))));
+
+/* OLD HACK
// check first linedef to figure which of its sectors owns this sector->lines pointer
// then check that sector's linecount to get a maximum index
- //if (!seclines[0])
+ //if (!(*seclines)[0])
//return luaL_error(L, "no lines found!"); // no first linedef?????
- if (seclines[0]->frontsector->lines == seclines)
- numoflines = seclines[0]->frontsector->linecount;
- else if (seclines[0]->backsector && seclines[0]->backsector->lines == seclines) // check backsector exists first
- numoflines = seclines[0]->backsector->linecount;
+ if ((*seclines)[0]->frontsector->lines == *seclines)
+ numoflines = (*seclines)[0]->frontsector->linecount;
+ else if ((*seclines)[0]->backsector && *seclines[0]->backsector->lines == *seclines) // check backsector exists first
+ numoflines = (*seclines)[0]->backsector->linecount;
//if neither sector has it then ???
+*/
if (!numoflines)
return luaL_error(L, "no lines found!");
@@ -449,23 +465,21 @@ static int sectorlines_get(lua_State *L)
i = (size_t)lua_tointeger(L, 2);
if (i >= numoflines)
return 0;
- LUA_PushUserdata(L, seclines[i], META_LINE);
+ LUA_PushUserdata(L, (*seclines)[i], META_LINE);
return 1;
}
+// #(sector.lines) -> sector.linecount
static int sectorlines_num(lua_State *L)
{
- line_t **seclines = *((line_t ***)luaL_checkudata(L, 1, META_SECTORLINES));
+ line_t ***seclines = *((line_t ****)luaL_checkudata(L, 1, META_SECTORLINES));
size_t numoflines = 0;
- // check first linedef to figure which of its sectors owns this sector->lines pointer
- // then check that sector's linecount to get a maximum index
- //if (!seclines[0])
- //return luaL_error(L, "no lines found!"); // no first linedef?????
- if (seclines[0]->frontsector->lines == seclines)
- numoflines = seclines[0]->frontsector->linecount;
- else if (seclines[0]->backsector && seclines[0]->backsector->lines == seclines) // check backsector exists first
- numoflines = seclines[0]->backsector->linecount;
- //if neither sector has it then ???
+
+ if (!seclines || !(*seclines))
+ return luaL_error(L, "accessed sector_t.lines doesn't exist anymore.");
+
+ // see comments in the _get function above
+ numoflines = (size_t)(*(seclines - (offsetof(sector_t, lines) - offsetof(sector_t, linecount))));
lua_pushinteger(L, numoflines);
return 1;
}
@@ -543,7 +557,7 @@ static int sector_get(lua_State *L)
LUA_PushUserdata(L, §ors[sector->camsec], META_SECTOR);
return 1;
case sector_lines: // lines
- LUA_PushUserdata(L, sector->lines, META_SECTORLINES);
+ LUA_PushUserdata(L, §or->lines, META_SECTORLINES); // push the address of the "lines" member in the struct, to allow our hacks in sectorlines_get/_num to work
return 1;
case sector_ffloors: // ffloors
lua_pushcfunction(L, lib_iterateSectorFFloors);
@@ -579,6 +593,7 @@ static int sector_set(lua_State *L)
case sector_thinglist: // thinglist
case sector_heightsec: // heightsec
case sector_camsec: // camsec
+ case sector_lines: // lines
case sector_ffloors: // ffloors
#ifdef ESLOPE
case sector_fslope: // f_slope
diff --git a/src/lua_mobjlib.c b/src/lua_mobjlib.c
index 063158b263b58b4f4a6b7764a6c3075a4e72867c..30026da49bdf2c4d8d4e5ad9b045e00615d10b2d 100644
--- a/src/lua_mobjlib.c
+++ b/src/lua_mobjlib.c
@@ -164,6 +164,8 @@ static int mobj_get(lua_State *L)
enum mobj_e field = Lua_optoption(L, 2, NULL, mobj_opt);
lua_settop(L, 2);
+ INLEVEL
+
if (!mo) {
if (field == mobj_valid) {
lua_pushboolean(L, 0);
@@ -409,6 +411,8 @@ static int mobj_set(lua_State *L)
enum mobj_e field = Lua_optoption(L, 2, mobj_opt[0], mobj_opt);
lua_settop(L, 3);
+ INLEVEL
+
if (!mo)
return LUA_ErrInvalid(L, "mobj_t");
diff --git a/src/lua_playerlib.c b/src/lua_playerlib.c
index dd9959afbdf3300bc150438e2e5cedce2f40d298..b1222ce672fbc64c4487b6c46cb31498a9de7944 100644
--- a/src/lua_playerlib.c
+++ b/src/lua_playerlib.c
@@ -25,7 +25,6 @@
static int lib_iteratePlayers(lua_State *L)
{
INT32 i = -1;
- INLEVEL
if (lua_gettop(L) < 2)
{
//return luaL_error(L, "Don't call players.iterate() directly, use it as 'for player in players.iterate do <block> end'.");
@@ -52,7 +51,6 @@ static int lib_getPlayer(lua_State *L)
{
const char *field;
// i -> players[i]
- INLEVEL
if (lua_type(L, 2) == LUA_TNUMBER)
{
lua_Integer i = luaL_checkinteger(L, 2);
diff --git a/src/lua_script.c b/src/lua_script.c
index deb644dc0351c169c60cb859952627278538241c..ec73d7bf70136762eeec08edda22ccdf9ac762d4 100644
--- a/src/lua_script.c
+++ b/src/lua_script.c
@@ -431,7 +431,7 @@ void LUA_InvalidateLevel(void)
for (i = 0; i < numsectors; i++)
{
LUA_InvalidateUserdata(§ors[i]);
- LUA_InvalidateUserdata(sectors[i].lines);
+ LUA_InvalidateUserdata(§ors[i].lines);
if (sectors[i].ffloors)
{
for (rover = sectors[i].ffloors; rover; rover = rover->next)
@@ -1121,7 +1121,7 @@ void LUA_Archive(void)
for (i = 0; i < MAXPLAYERS; i++)
{
- if (!playeringame[i])
+ if (!playeringame[i] && i > 0) // dedicated servers...
continue;
// all players in game will be archived, even if they just add a 0.
ArchiveExtVars(&players[i], "player");
@@ -1157,7 +1157,7 @@ void LUA_UnArchive(void)
for (i = 0; i < MAXPLAYERS; i++)
{
- if (!playeringame[i])
+ if (!playeringame[i] && i > 0) // dedicated servers...
continue;
UnArchiveExtVars(&players[i]);
}
diff --git a/src/m_cond.c b/src/m_cond.c
index 539c6d1f6d1fc38efacad7d1e56329a323010afb..b7520aba78e1be64ef810e46bfbb58c3d593b155 100644
--- a/src/m_cond.c
+++ b/src/m_cond.c
@@ -528,12 +528,22 @@ skincolors_t M_GetEmblemColor(emblem_t *em)
return em->color;
}
-const char *M_GetEmblemPatch(emblem_t *em)
+const char *M_GetEmblemPatch(emblem_t *em, boolean big)
{
- static char pnamebuf[7] = "GOTITn";
+ static char pnamebuf[7];
+
+ if (!big)
+ strcpy(pnamebuf, "GOTITn");
+ else
+ strcpy(pnamebuf, "EMBMn0");
I_Assert(em->sprite >= 'A' && em->sprite <= 'Z');
- pnamebuf[5] = em->sprite;
+
+ if (!big)
+ pnamebuf[5] = em->sprite;
+ else
+ pnamebuf[4] = em->sprite;
+
return pnamebuf;
}
@@ -544,11 +554,21 @@ skincolors_t M_GetExtraEmblemColor(extraemblem_t *em)
return em->color;
}
-const char *M_GetExtraEmblemPatch(extraemblem_t *em)
+const char *M_GetExtraEmblemPatch(extraemblem_t *em, boolean big)
{
- static char pnamebuf[7] = "GOTITn";
+ static char pnamebuf[7];
+
+ if (!big)
+ strcpy(pnamebuf, "GOTITn");
+ else
+ strcpy(pnamebuf, "EMBMn0");
I_Assert(em->sprite >= 'A' && em->sprite <= 'Z');
- pnamebuf[5] = em->sprite;
+
+ if (!big)
+ pnamebuf[5] = em->sprite;
+ else
+ pnamebuf[4] = em->sprite;
+
return pnamebuf;
}
diff --git a/src/m_cond.h b/src/m_cond.h
index f82e49372ed0120da76cdd2bd8d8c0a7f2a128c5..e9859cf11552125e40fdfffba8b57bb2f5497386 100644
--- a/src/m_cond.h
+++ b/src/m_cond.h
@@ -171,9 +171,9 @@ INT32 M_CountEmblems(void);
// Emblem shit
emblem_t *M_GetLevelEmblems(INT32 mapnum);
skincolors_t M_GetEmblemColor(emblem_t *em);
-const char *M_GetEmblemPatch(emblem_t *em);
+const char *M_GetEmblemPatch(emblem_t *em, boolean big);
skincolors_t M_GetExtraEmblemColor(extraemblem_t *em);
-const char *M_GetExtraEmblemPatch(extraemblem_t *em);
+const char *M_GetExtraEmblemPatch(extraemblem_t *em, boolean big);
// If you're looking to compare stats for unlocks or what not, use these
// They stop checking upon reaching the target number so they
diff --git a/src/m_fixed.c b/src/m_fixed.c
index d45bb70bf572dabacef5f9874dfe84d3b9bdef32..5e78967396a4b9802dc29e301a14112f03b3168a 100644
--- a/src/m_fixed.c
+++ b/src/m_fixed.c
@@ -56,7 +56,7 @@ fixed_t FixedDiv2(fixed_t a, fixed_t b)
if (b == 0)
I_Error("FixedDiv: divide by zero");
- ret = (((INT64)a * FRACUNIT) ) / b;
+ ret = (((INT64)a * FRACUNIT)) / b;
if ((ret > INT32_MAX) || (ret < INT32_MIN))
I_Error("FixedDiv: divide by zero");
@@ -117,7 +117,7 @@ fixed_t FixedHypot(fixed_t x, fixed_t y)
yx = FixedDiv(y, x); // (x/y)
}
yx2 = FixedMul(yx, yx); // (x/y)^2
- yx1 = FixedSqrt(1*FRACUNIT + yx2); // (1 + (x/y)^2)^1/2
+ yx1 = FixedSqrt(1 * FRACUNIT + yx2); // (1 + (x/y)^2)^1/2
return FixedMul(ax, yx1); // |x|*((1 + (x/y)^2)^1/2)
}
@@ -191,8 +191,8 @@ vector2_t *FV2_Divide(vector2_t *a_i, fixed_t a_c)
// Vector Complex Math
vector2_t *FV2_Midpoint(const vector2_t *a_1, const vector2_t *a_2, vector2_t *a_o)
{
- a_o->x = FixedDiv(a_2->x - a_1->x, 2*FRACUNIT);
- a_o->y = FixedDiv(a_2->y - a_1->y, 2*FRACUNIT);
+ a_o->x = FixedDiv(a_2->x - a_1->x, 2 * FRACUNIT);
+ a_o->y = FixedDiv(a_2->y - a_1->y, 2 * FRACUNIT);
a_o->x = a_1->x + a_o->x;
a_o->y = a_1->y + a_o->y;
return a_o;
@@ -200,16 +200,16 @@ vector2_t *FV2_Midpoint(const vector2_t *a_1, const vector2_t *a_2, vector2_t *a
fixed_t FV2_Distance(const vector2_t *p1, const vector2_t *p2)
{
- fixed_t xs = FixedMul(p2->x-p1->x,p2->x-p1->x);
- fixed_t ys = FixedMul(p2->y-p1->y,p2->y-p1->y);
- return FixedSqrt(xs+ys);
+ fixed_t xs = FixedMul(p2->x - p1->x, p2->x - p1->x);
+ fixed_t ys = FixedMul(p2->y - p1->y, p2->y - p1->y);
+ return FixedSqrt(xs + ys);
}
fixed_t FV2_Magnitude(const vector2_t *a_normal)
{
- fixed_t xs = FixedMul(a_normal->x,a_normal->x);
- fixed_t ys = FixedMul(a_normal->y,a_normal->y);
- return FixedSqrt(xs+ys);
+ fixed_t xs = FixedMul(a_normal->x, a_normal->x);
+ fixed_t ys = FixedMul(a_normal->y, a_normal->y);
+ return FixedSqrt(xs + ys);
}
// Also returns the magnitude
@@ -240,7 +240,7 @@ vector2_t *FV2_Negate(vector2_t *a_1)
boolean FV2_Equal(const vector2_t *a_1, const vector2_t *a_2)
{
- fixed_t Epsilon = FRACUNIT/FRACUNIT;
+ fixed_t Epsilon = FRACUNIT / FRACUNIT;
if ((abs(a_2->x - a_1->x) > Epsilon) ||
(abs(a_2->y - a_1->y) > Epsilon))
@@ -261,7 +261,7 @@ fixed_t FV2_Dot(const vector2_t *a_1, const vector2_t *a_2)
//
// Given two points, create a vector between them.
//
-vector2_t *FV2_Point2Vec (const vector2_t *point1, const vector2_t *point2, vector2_t *a_o)
+vector2_t *FV2_Point2Vec(const vector2_t *point1, const vector2_t *point2, vector2_t *a_o)
{
a_o->x = point1->x - point2->x;
a_o->y = point1->y - point2->y;
@@ -344,9 +344,9 @@ vector3_t *FV3_Divide(vector3_t *a_i, fixed_t a_c)
// Vector Complex Math
vector3_t *FV3_Midpoint(const vector3_t *a_1, const vector3_t *a_2, vector3_t *a_o)
{
- a_o->x = FixedDiv(a_2->x - a_1->x, 2*FRACUNIT);
- a_o->y = FixedDiv(a_2->y - a_1->y, 2*FRACUNIT);
- a_o->z = FixedDiv(a_2->z - a_1->z, 2*FRACUNIT);
+ a_o->x = FixedDiv(a_2->x - a_1->x, 2 * FRACUNIT);
+ a_o->y = FixedDiv(a_2->y - a_1->y, 2 * FRACUNIT);
+ a_o->z = FixedDiv(a_2->z - a_1->z, 2 * FRACUNIT);
a_o->x = a_1->x + a_o->x;
a_o->y = a_1->y + a_o->y;
a_o->z = a_1->z + a_o->z;
@@ -355,18 +355,18 @@ vector3_t *FV3_Midpoint(const vector3_t *a_1, const vector3_t *a_2, vector3_t *a
fixed_t FV3_Distance(const vector3_t *p1, const vector3_t *p2)
{
- fixed_t xs = FixedMul(p2->x-p1->x,p2->x-p1->x);
- fixed_t ys = FixedMul(p2->y-p1->y,p2->y-p1->y);
- fixed_t zs = FixedMul(p2->z-p1->z,p2->z-p1->z);
- return FixedSqrt(xs+ys+zs);
+ fixed_t xs = FixedMul(p2->x - p1->x, p2->x - p1->x);
+ fixed_t ys = FixedMul(p2->y - p1->y, p2->y - p1->y);
+ fixed_t zs = FixedMul(p2->z - p1->z, p2->z - p1->z);
+ return FixedSqrt(xs + ys + zs);
}
fixed_t FV3_Magnitude(const vector3_t *a_normal)
{
- fixed_t xs = FixedMul(a_normal->x,a_normal->x);
- fixed_t ys = FixedMul(a_normal->y,a_normal->y);
- fixed_t zs = FixedMul(a_normal->z,a_normal->z);
- return FixedSqrt(xs+ys+zs);
+ fixed_t xs = FixedMul(a_normal->x, a_normal->x);
+ fixed_t ys = FixedMul(a_normal->y, a_normal->y);
+ fixed_t zs = FixedMul(a_normal->z, a_normal->z);
+ return FixedSqrt(xs + ys + zs);
}
// Also returns the magnitude
@@ -399,7 +399,7 @@ vector3_t *FV3_Negate(vector3_t *a_1)
boolean FV3_Equal(const vector3_t *a_1, const vector3_t *a_2)
{
- fixed_t Epsilon = FRACUNIT/FRACUNIT;
+ fixed_t Epsilon = FRACUNIT / FRACUNIT;
if ((abs(a_2->x - a_1->x) > Epsilon) ||
(abs(a_2->y - a_1->y) > Epsilon) ||
@@ -458,6 +458,20 @@ vector3_t *FV3_ClosestPointOnLine(const vector3_t *Line, const vector3_t *p, vec
return FV3_AddEx(&Line[0], &V, out);
}
+//
+// ClosestPointOnVector
+//
+// Similar to ClosestPointOnLine, but uses a vector instead of two points.
+//
+void FV3_ClosestPointOnVector(const vector3_t *dir, const vector3_t *p, vector3_t *out)
+{
+ fixed_t t = FV3_Dot(dir, p);
+
+ // Return the point on the line closest
+ FV3_MulEx(dir, t, out);
+ return;
+}
+
//
// ClosestPointOnTriangle
//
@@ -465,7 +479,7 @@ vector3_t *FV3_ClosestPointOnLine(const vector3_t *Line, const vector3_t *p, vec
// the closest point on the edge of
// the triangle is returned.
//
-void FV3_ClosestPointOnTriangle (const vector3_t *tri, const vector3_t *point, vector3_t *result)
+void FV3_ClosestPointOnTriangle(const vector3_t *tri, const vector3_t *point, vector3_t *result)
{
UINT8 i;
fixed_t dist, closestdist;
@@ -506,7 +520,7 @@ void FV3_ClosestPointOnTriangle (const vector3_t *tri, const vector3_t *point, v
//
// Given two points, create a vector between them.
//
-vector3_t *FV3_Point2Vec (const vector3_t *point1, const vector3_t *point2, vector3_t *a_o)
+vector3_t *FV3_Point2Vec(const vector3_t *point1, const vector3_t *point2, vector3_t *a_o)
{
a_o->x = point1->x - point2->x;
a_o->y = point1->y - point2->y;
@@ -519,7 +533,7 @@ vector3_t *FV3_Point2Vec (const vector3_t *point1, const vector3_t *point2, vect
//
// Calculates the normal of a polygon.
//
-void FV3_Normal (const vector3_t *a_triangle, vector3_t *a_normal)
+fixed_t FV3_Normal(const vector3_t *a_triangle, vector3_t *a_normal)
{
vector3_t a_1;
vector3_t a_2;
@@ -529,7 +543,28 @@ void FV3_Normal (const vector3_t *a_triangle, vector3_t *a_normal)
FV3_Cross(&a_1, &a_2, a_normal);
- FV3_NormalizeEx(a_normal, a_normal);
+ return FV3_NormalizeEx(a_normal, a_normal);
+}
+
+//
+// Strength
+//
+// Measures the 'strength' of a vector in a particular direction.
+//
+fixed_t FV3_Strength(const vector3_t *a_1, const vector3_t *dir)
+{
+ vector3_t normal;
+ fixed_t dist = FV3_NormalizeEx(a_1, &normal);
+ fixed_t dot = FV3_Dot(&normal, dir);
+
+ FV3_ClosestPointOnVector(dir, a_1, &normal);
+
+ dist = FV3_Magnitude(&normal);
+
+ if (dot < 0) // Not facing same direction, so negate result.
+ dist = -dist;
+
+ return dist;
}
//
@@ -550,11 +585,11 @@ boolean FV3_IntersectedPlane(const vector3_t *a_triangle, const vector3_t *a_lin
*originDistance = FV3_PlaneDistance(a_normal, &a_triangle[0]);
- distance1 = (FixedMul(a_normal->x, a_line[0].x) + FixedMul(a_normal->y, a_line[0].y)
- + FixedMul(a_normal->z, a_line[0].z)) + *originDistance;
+ distance1 = (FixedMul(a_normal->x, a_line[0].x) + FixedMul(a_normal->y, a_line[0].y)
+ + FixedMul(a_normal->z, a_line[0].z)) + *originDistance;
- distance2 = (FixedMul(a_normal->x, a_line[1].x) + FixedMul(a_normal->y, a_line[1].y)
- + FixedMul(a_normal->z, a_line[1].z)) + *originDistance;
+ distance2 = (FixedMul(a_normal->x, a_line[1].x) + FixedMul(a_normal->y, a_line[1].y)
+ + FixedMul(a_normal->z, a_line[1].z)) + *originDistance;
// Positive or zero number means no intersection
if (FixedMul(distance1, distance2) >= 0)
@@ -575,8 +610,8 @@ boolean FV3_IntersectedPlane(const vector3_t *a_triangle, const vector3_t *a_lin
fixed_t FV3_PlaneIntersection(const vector3_t *pOrigin, const vector3_t *pNormal, const vector3_t *rOrigin, const vector3_t *rVector)
{
fixed_t d = -(FV3_Dot(pNormal, pOrigin));
- fixed_t number = FV3_Dot(pNormal,rOrigin) + d;
- fixed_t denom = FV3_Dot(pNormal,rVector);
+ fixed_t number = FV3_Dot(pNormal, rOrigin) + d;
+ fixed_t denom = FV3_Dot(pNormal, rVector);
return -FixedDiv(number, denom);
}
@@ -597,11 +632,11 @@ fixed_t FV3_IntersectRaySphere(const vector3_t *rO, const vector3_t *rV, const v
c = FV3_Magnitude(&Q);
v = FV3_Dot(&Q, rV);
- d = FixedMul(sR, sR) - (FixedMul(c,c) - FixedMul(v,v));
+ d = FixedMul(sR, sR) - (FixedMul(c, c) - FixedMul(v, v));
// If there was no intersection, return -1
- if (d < 0*FRACUNIT)
- return (-1*FRACUNIT);
+ if (d < 0 * FRACUNIT)
+ return (-1 * FRACUNIT);
// Return the distance to the [first] intersecting point
return (v - FixedSqrt(d));
@@ -629,9 +664,9 @@ vector3_t *FV3_IntersectionPoint(const vector3_t *vNormal, const vector3_t *vLin
// Here I just chose a arbitrary point as the point to find that distance. You notice we negate that
// distance. We negate the distance because we want to eventually go BACKWARDS from our point to the plane.
// By doing this is will basically bring us back to the plane to find our intersection point.
- Numerator = - (FixedMul(vNormal->x, vLine[0].x) + // Use the plane equation with the normal and the line
- FixedMul(vNormal->y, vLine[0].y) +
- FixedMul(vNormal->z, vLine[0].z) + distance);
+ Numerator = -(FixedMul(vNormal->x, vLine[0].x) + // Use the plane equation with the normal and the line
+ FixedMul(vNormal->y, vLine[0].y) +
+ FixedMul(vNormal->z, vLine[0].z) + distance);
// 3) If we take the dot product between our line vector and the normal of the polygon,
// this will give us the cosine of the angle between the 2 (since they are both normalized - length 1).
@@ -643,7 +678,7 @@ vector3_t *FV3_IntersectionPoint(const vector3_t *vNormal, const vector3_t *vLin
// on the plane (the normal is perpendicular to the line - (Normal.Vector = 0)).
// In this case, we should just return any point on the line.
- if( Denominator == 0*FRACUNIT) // Check so we don't divide by zero
+ if (Denominator == 0 * FRACUNIT) // Check so we don't divide by zero
{
ReturnVec->x = vLine[0].x;
ReturnVec->y = vLine[0].y;
@@ -686,8 +721,8 @@ vector3_t *FV3_IntersectionPoint(const vector3_t *vNormal, const vector3_t *vLin
//
UINT8 FV3_PointOnLineSide(const vector3_t *point, const vector3_t *line)
{
- fixed_t s1 = FixedMul((point->y - line[0].y),(line[1].x - line[0].x));
- fixed_t s2 = FixedMul((point->x - line[0].x),(line[1].y - line[0].y));
+ fixed_t s1 = FixedMul((point->y - line[0].y), (line[1].x - line[0].x));
+ fixed_t s2 = FixedMul((point->x - line[0].x), (line[1].y - line[0].y));
return (UINT8)(s1 - s2 < 0);
}
@@ -752,7 +787,7 @@ void FM_CreateObjectMatrix(matrix_t *matrix, fixed_t x, fixed_t y, fixed_t z, fi
matrix->m[0] = upcross.x;
matrix->m[1] = upcross.y;
matrix->m[2] = upcross.z;
- matrix->m[3] = 0*FRACUNIT;
+ matrix->m[3] = 0 * FRACUNIT;
matrix->m[4] = upx;
matrix->m[5] = upy;
@@ -764,9 +799,9 @@ void FM_CreateObjectMatrix(matrix_t *matrix, fixed_t x, fixed_t y, fixed_t z, fi
matrix->m[10] = anglez;
matrix->m[11] = 0;
- matrix->m[12] = x - FixedMul(upx,radius);
- matrix->m[13] = y - FixedMul(upy,radius);
- matrix->m[14] = z - FixedMul(upz,radius);
+ matrix->m[12] = x - FixedMul(upx, radius);
+ matrix->m[13] = y - FixedMul(upy, radius);
+ matrix->m[14] = z - FixedMul(upz, radius);
matrix->m[15] = FRACUNIT;
}
@@ -778,20 +813,20 @@ void FM_CreateObjectMatrix(matrix_t *matrix, fixed_t x, fixed_t y, fixed_t z, fi
void FM_MultMatrixVec3(const matrix_t *matrix, const vector3_t *vec, vector3_t *out)
{
#define M(row,col) matrix->m[col * 4 + row]
- out->x = FixedMul(vec->x,M(0, 0))
- + FixedMul(vec->y,M(0, 1))
- + FixedMul(vec->z,M(0, 2))
- + M(0, 3);
-
- out->y = FixedMul(vec->x,M(1, 0))
- + FixedMul(vec->y,M(1, 1))
- + FixedMul(vec->z,M(1, 2))
- + M(1, 3);
-
- out->z = FixedMul(vec->x,M(2, 0))
- + FixedMul(vec->y,M(2, 1))
- + FixedMul(vec->z,M(2, 2))
- + M(2, 3);
+ out->x = FixedMul(vec->x, M(0, 0))
+ + FixedMul(vec->y, M(0, 1))
+ + FixedMul(vec->z, M(0, 2))
+ + M(0, 3);
+
+ out->y = FixedMul(vec->x, M(1, 0))
+ + FixedMul(vec->y, M(1, 1))
+ + FixedMul(vec->z, M(1, 2))
+ + M(1, 3);
+
+ out->z = FixedMul(vec->x, M(2, 0))
+ + FixedMul(vec->y, M(2, 1))
+ + FixedMul(vec->z, M(2, 2))
+ + M(2, 3);
#undef M
}
@@ -811,7 +846,7 @@ void FM_MultMatrix(matrix_t *dest, const matrix_t *multme)
for (i = 0; i < 4; i++)
{
for (j = 0; j < 4; j++)
- R(i, j) = FixedMul(D(i, 0),M(0, j)) + FixedMul(D(i, 1),M(1, j)) + FixedMul(D(i, 2),M(2, j)) + FixedMul(D(i, 3),M(3, j));
+ R(i, j) = FixedMul(D(i, 0), M(0, j)) + FixedMul(D(i, 1), M(1, j)) + FixedMul(D(i, 2), M(2, j)) + FixedMul(D(i, 3), M(3, j));
}
M_Memcpy(dest, &result, sizeof(matrix_t));
@@ -869,8 +904,8 @@ void FM_Scale(matrix_t *dest, fixed_t x, fixed_t y, fixed_t z)
static inline void M_print(INT64 a)
{
- const fixed_t w = (a>>FRACBITS);
- fixed_t f = a%FRACUNIT;
+ const fixed_t w = (a >> FRACBITS);
+ fixed_t f = a % FRACUNIT;
fixed_t d = FRACUNIT;
if (f == 0)
@@ -878,7 +913,7 @@ static inline void M_print(INT64 a)
printf("%d", (fixed_t)w);
return;
}
- else while (f != 1 && f/2 == f>>1)
+ else while (f != 1 && f / 2 == f >> 1)
{
d /= 2;
f /= 2;
@@ -892,7 +927,7 @@ static inline void M_print(INT64 a)
FUNCMATH FUNCINLINE static inline fixed_t FixedMulC(fixed_t a, fixed_t b)
{
- return (fixed_t)((((INT64)a * b) ) / FRACUNIT);
+ return (fixed_t)((((INT64)a * b)) / FRACUNIT);
}
FUNCMATH FUNCINLINE static inline fixed_t FixedDivC2(fixed_t a, fixed_t b)
@@ -902,7 +937,7 @@ FUNCMATH FUNCINLINE static inline fixed_t FixedDivC2(fixed_t a, fixed_t b)
if (b == 0)
I_Error("FixedDiv: divide by zero");
- ret = (((INT64)a * FRACUNIT) ) / b;
+ ret = (((INT64)a * FRACUNIT)) / b;
if ((ret > INT32_MAX) || (ret < INT32_MIN))
I_Error("FixedDiv: divide by zero");
@@ -911,7 +946,7 @@ FUNCMATH FUNCINLINE static inline fixed_t FixedDivC2(fixed_t a, fixed_t b)
FUNCMATH FUNCINLINE static inline fixed_t FixedDivC(fixed_t a, fixed_t b)
{
- if ((abs(a) >> (FRACBITS-2)) >= abs(b))
+ if ((abs(a) >> (FRACBITS - 2)) >= abs(b))
return (a^b) < 0 ? INT32_MIN : INT32_MAX;
return FixedDivC2(a, b);
@@ -938,43 +973,43 @@ int main(int argc, char** argv)
#ifdef MULDIV_TEST
for (a = 1; a <= INT32_MAX; a += FRACUNIT)
- for (b = 0; b <= INT32_MAX; b += FRACUNIT)
- {
- c = FixedMul(a, b);
- d = FixedMulC(a, b);
- if (c != d)
+ for (b = 0; b <= INT32_MAX; b += FRACUNIT)
{
- printf("(");
- M_print(a);
- printf(") * (");
- M_print(b);
- printf(") = (");
- M_print(c);
- printf(") != (");
- M_print(d);
- printf(") \n");
- n--;
- printf("%d != %d\n", c, d);
+ c = FixedMul(a, b);
+ d = FixedMulC(a, b);
+ if (c != d)
+ {
+ printf("(");
+ M_print(a);
+ printf(") * (");
+ M_print(b);
+ printf(") = (");
+ M_print(c);
+ printf(") != (");
+ M_print(d);
+ printf(") \n");
+ n--;
+ printf("%d != %d\n", c, d);
+ }
+ c = FixedDiv(a, b);
+ d = FixedDivC(a, b);
+ if (c != d)
+ {
+ printf("(");
+ M_print(a);
+ printf(") / (");
+ M_print(b);
+ printf(") = (");
+ M_print(c);
+ printf(") != (");
+ M_print(d);
+ printf(")\n");
+ n--;
+ printf("%d != %d\n", c, d);
+ }
+ if (n <= 0)
+ exit(-1);
}
- c = FixedDiv(a, b);
- d = FixedDivC(a, b);
- if (c != d)
- {
- printf("(");
- M_print(a);
- printf(") / (");
- M_print(b);
- printf(") = (");
- M_print(c);
- printf(") != (");
- M_print(d);
- printf(")\n");
- n--;
- printf("%d != %d\n", c, d);
- }
- if (n <= 0)
- exit(-1);
- }
#endif
#ifdef SQRT_TEST
@@ -982,7 +1017,7 @@ int main(int argc, char** argv)
{
c = FixedSqrt(a);
d = FixedSqrtC(a);
- b = abs(c-d);
+ b = abs(c - d);
if (b > 1)
{
printf("sqrt(");
diff --git a/src/m_fixed.h b/src/m_fixed.h
index d8e722b13c8f0117f10098064973997cf0695df8..370633c1f6b0de4752f575bc3ab5929fd0a329cd 100644
--- a/src/m_fixed.h
+++ b/src/m_fixed.h
@@ -389,9 +389,11 @@ boolean FV3_Equal(const vector3_t *a_1, const vector3_t *a_2);
fixed_t FV3_Dot(const vector3_t *a_1, const vector3_t *a_2);
vector3_t *FV3_Cross(const vector3_t *a_1, const vector3_t *a_2, vector3_t *a_o);
vector3_t *FV3_ClosestPointOnLine(const vector3_t *Line, const vector3_t *p, vector3_t *out);
+void FV3_ClosestPointOnVector(const vector3_t *dir, const vector3_t *p, vector3_t *out);
void FV3_ClosestPointOnTriangle(const vector3_t *tri, const vector3_t *point, vector3_t *result);
vector3_t *FV3_Point2Vec(const vector3_t *point1, const vector3_t *point2, vector3_t *a_o);
-void FV3_Normal(const vector3_t *a_triangle, vector3_t *a_normal);
+fixed_t FV3_Normal(const vector3_t *a_triangle, vector3_t *a_normal);
+fixed_t FV3_Strength(const vector3_t *a_1, const vector3_t *dir);
fixed_t FV3_PlaneDistance(const vector3_t *a_normal, const vector3_t *a_point);
boolean FV3_IntersectedPlane(const vector3_t *a_triangle, const vector3_t *a_line, vector3_t *a_normal, fixed_t *originDistance);
fixed_t FV3_PlaneIntersection(const vector3_t *pOrigin, const vector3_t *pNormal, const vector3_t *rOrigin, const vector3_t *rVector);
diff --git a/src/m_menu.c b/src/m_menu.c
index 05af481e83929f07dde815664264d03da339e36d..69c0802f2e74d9c5969b8057d432fe3fbc761eba 100644
--- a/src/m_menu.c
+++ b/src/m_menu.c
@@ -127,7 +127,6 @@ const char *quitmsg[NUM_QUITMESSAGES];
description_t description[MAXSKINS];
INT16 char_on = -1, startchar = 0;
static char *char_notes = NULL;
-static fixed_t char_scroll = 0;
boolean menuactive = false;
boolean fromlevelselect = false;
@@ -167,6 +166,16 @@ static INT32 vidm_selected = 0;
static INT32 vidm_nummodes;
static INT32 vidm_column_size;
+// new menus
+static tic_t recatkdrawtimer = 0;
+static tic_t ntsatkdrawtimer = 0;
+
+static tic_t charseltimer = 0;
+static fixed_t char_scroll = 0;
+#define charscrollamt 128*FRACUNIT
+
+static tic_t keydown = 0;
+
//
// PROTOTYPES
//
@@ -247,6 +256,7 @@ menu_t MISC_ScrambleTeamDef, MISC_ChangeTeamDef;
// Single Player
static void M_StartTutorial(INT32 choice);
static void M_LoadGame(INT32 choice);
+static void M_HandleTimeAttackLevelSelect(INT32 choice);
static void M_TimeAttackLevelSelect(INT32 choice);
static void M_TimeAttack(INT32 choice);
static void M_NightsAttackLevelSelect(INT32 choice);
@@ -387,9 +397,12 @@ static void Dummymares_OnChange(void);
// CONSOLE VARIABLES AND THEIR POSSIBLE VALUES GO HERE.
// ==========================================================================
+consvar_t cv_showfocuslost = {"showfocuslost", "Yes", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL };
+
static CV_PossibleValue_t map_cons_t[] = {
{1,"MIN"},
- {NUMMAPS, "MAX"}
+ {NUMMAPS, "MAX"},
+ {0,NULL}
};
consvar_t cv_nextmap = {"nextmap", "1", CV_HIDEN|CV_CALL, map_cons_t, Nextmap_OnChange, 0, NULL, NULL, 0, 0, NULL};
@@ -407,7 +420,7 @@ static CV_PossibleValue_t serversort_cons_t[] = {
{1,"Modified State"},
{2,"Most Players"},
{3,"Least Players"},
- {4,"Max Players"},
+ {4,"Max Player Slots"},
{5,"Gametype"},
{0,NULL}
};
@@ -434,7 +447,8 @@ consvar_t cv_ghost_guest = {"ghost_guest", "Show", CV_SAVE, ghost2_cons_
static CV_PossibleValue_t dummyteam_cons_t[] = {{0, "Spectator"}, {1, "Red"}, {2, "Blue"}, {0, NULL}};
static CV_PossibleValue_t dummyscramble_cons_t[] = {{0, "Random"}, {1, "Points"}, {0, NULL}};
static CV_PossibleValue_t ringlimit_cons_t[] = {{0, "MIN"}, {9999, "MAX"}, {0, NULL}};
-static CV_PossibleValue_t liveslimit_cons_t[] = {{-1, "MIN"}, {99, "MAX"}, {0, NULL}};
+static CV_PossibleValue_t liveslimit_cons_t[] = {{1, "MIN"}, {99, "MAX"}, {-1, "Infinite"}, {0, NULL}};
+static CV_PossibleValue_t contlimit_cons_t[] = {{0, "MIN"}, {99, "MAX"}, {0, NULL}};
static CV_PossibleValue_t dummymares_cons_t[] = {
{-1, "END"}, {0,"Overall"}, {1,"Mare 1"}, {2,"Mare 2"}, {3,"Mare 3"}, {4,"Mare 4"}, {5,"Mare 5"}, {6,"Mare 6"}, {7,"Mare 7"}, {8,"Mare 8"}, {0,NULL}
};
@@ -443,7 +457,7 @@ static consvar_t cv_dummyteam = {"dummyteam", "Spectator", CV_HIDEN, dummyteam_c
static consvar_t cv_dummyscramble = {"dummyscramble", "Random", CV_HIDEN, dummyscramble_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
static consvar_t cv_dummyrings = {"dummyrings", "0", CV_HIDEN, ringlimit_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
static consvar_t cv_dummylives = {"dummylives", "0", CV_HIDEN, liveslimit_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
-static consvar_t cv_dummycontinues = {"dummycontinues", "0", CV_HIDEN, liveslimit_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
+static consvar_t cv_dummycontinues = {"dummycontinues", "0", CV_HIDEN, contlimit_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
static consvar_t cv_dummymares = {"dummymares", "Overall", CV_HIDEN|CV_CALL, dummymares_cons_t, Dummymares_OnChange, 0, NULL, NULL, 0, 0, NULL};
// ==========================================================================
@@ -744,8 +758,8 @@ static menuitem_t SP_TimeAttackLevelSelectMenu[] =
// Single Player Time Attack
static menuitem_t SP_TimeAttackMenu[] =
{
- {IT_STRING|IT_CALL, NULL, "Level Select...", &M_TimeAttackLevelSelect, 52},
- {IT_STRING|IT_CVAR, NULL, "Character", &cv_chooseskin, 62},
+ {IT_STRING|IT_KEYHANDLER, NULL, "Level Select...", M_HandleTimeAttackLevelSelect, 62},
+ {IT_STRING|IT_CVAR, NULL, "Character", &cv_chooseskin, 72},
{IT_DISABLED, NULL, "Guest Option...", &SP_GuestReplayDef, 100},
{IT_DISABLED, NULL, "Replay...", &SP_ReplayDef, 110},
@@ -1222,15 +1236,16 @@ static menuitem_t OP_VideoOptionsMenu[] =
{IT_HEADER, NULL, "Level", NULL, 155},
{IT_STRING | IT_CVAR, NULL, "Draw Distance", &cv_drawdist, 161},
{IT_STRING | IT_CVAR, NULL, "Weather Draw Dist.", &cv_drawdist_precip, 166},
- {IT_STRING | IT_CVAR, NULL, "NiGHTS mode Draw Dist.", &cv_drawdist_nights, 171},
+ {IT_STRING | IT_CVAR, NULL, "NiGHTS Hoop Draw Dist.", &cv_drawdist_nights, 171},
{IT_HEADER, NULL, "Diagnostic", NULL, 180},
{IT_STRING | IT_CVAR, NULL, "Show FPS", &cv_ticrate, 186},
{IT_STRING | IT_CVAR, NULL, "Clear Before Redraw", &cv_homremoval, 191},
+ {IT_STRING | IT_CVAR, NULL, "Show \"FOCUS LOST\"", &cv_showfocuslost, 196},
#ifdef HWRENDER
- {IT_HEADER, NULL, "Renderer", NULL, 200},
- {IT_CALL|IT_STRING, NULL, "OpenGL Options...", M_OpenGLOptionsMenu, 206},
+ {IT_HEADER, NULL, "Renderer", NULL, 205},
+ {IT_CALL|IT_STRING, NULL, "OpenGL Options...", M_OpenGLOptionsMenu, 211},
#endif
};
@@ -1283,18 +1298,21 @@ static menuitem_t OP_ColorOptionsMenu[] =
#ifdef HWRENDER
static menuitem_t OP_OpenGLOptionsMenu[] =
{
- {IT_STRING|IT_CVAR, NULL, "Field of view", &cv_grfov, 10},
- {IT_STRING|IT_CVAR, NULL, "Quality", &cv_scr_depth, 20},
- {IT_STRING|IT_CVAR, NULL, "Texture Filter", &cv_grfiltermode, 30},
- {IT_STRING|IT_CVAR, NULL, "Anisotropic", &cv_granisotropicmode,40},
+ {IT_STRING|IT_CVAR, NULL, "Models", &cv_grmodels, 10},
+ {IT_STRING|IT_CVAR, NULL, "Model interpolation", &cv_grmodelinterpolation, 20},
+
+ {IT_STRING|IT_CVAR, NULL, "Field of view", &cv_grfov, 40},
+ {IT_STRING|IT_CVAR, NULL, "Quality", &cv_scr_depth, 50},
+ {IT_STRING|IT_CVAR, NULL, "Texture Filter", &cv_grfiltermode, 60},
+ {IT_STRING|IT_CVAR, NULL, "Anisotropic", &cv_granisotropicmode,70},
#if defined (_WINDOWS) && (!((defined (__unix__) && !defined (MSDOS)) || defined (UNIXCOMMON) || defined (HAVE_SDL)))
- {IT_STRING|IT_CVAR, NULL, "Fullscreen", &cv_fullscreen, 50},
+ {IT_STRING|IT_CVAR, NULL, "Fullscreen", &cv_fullscreen, 80},
#endif
#ifdef ALAM_LIGHTING
- {IT_SUBMENU|IT_STRING, NULL, "Lighting...", &OP_OpenGLLightingDef, 70},
+ {IT_SUBMENU|IT_STRING, NULL, "Lighting...", &OP_OpenGLLightingDef, 100},
#endif
- {IT_SUBMENU|IT_STRING, NULL, "Fog...", &OP_OpenGLFogDef, 80},
- {IT_SUBMENU|IT_STRING, NULL, "Gamma...", &OP_OpenGLColorDef, 90},
+ {IT_SUBMENU|IT_STRING, NULL, "Fog...", &OP_OpenGLFogDef, 110},
+ {IT_SUBMENU|IT_STRING, NULL, "Gamma...", &OP_OpenGLColorDef, 120},
};
#ifdef ALAM_LIGHTING
@@ -1325,22 +1343,25 @@ static menuitem_t OP_OpenGLColorMenu[] =
static menuitem_t OP_SoundOptionsMenu[] =
{
- {IT_HEADER, NULL, "Game Audio", NULL, 0}, // 0 // ScrollMenu offsets
- {IT_STRING | IT_CVAR, NULL, "Sound Effects", &cv_gamesounds, 13}, // 6
- {IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Sound Volume", &cv_soundvolume, 23}, // 11
+ {IT_HEADER, NULL, "Game Audio", NULL, 0},
+ {IT_STRING | IT_CVAR, NULL, "Sound Effects", &cv_gamesounds, 6},
+ {IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Sound Volume", &cv_soundvolume, 11},
+
+ {IT_STRING | IT_CVAR, NULL, "Digital Music", &cv_gamedigimusic, 21},
+ {IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Digital Music Volume", &cv_digmusicvolume, 26},
- {IT_STRING | IT_CVAR, NULL, "Digital Music", &cv_gamedigimusic, 43}, // 21
- {IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Digital Music Volume", &cv_digmusicvolume, 53}, // 26
+ {IT_STRING | IT_CVAR, NULL, "MIDI Music", &cv_gamemidimusic, 36},
+ {IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "MIDI Music Volume", &cv_midimusicvolume, 41},
- {IT_STRING | IT_CVAR, NULL, "MIDI Music", &cv_gamemidimusic, 73}, // 36
- {IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "MIDI Music Volume", &cv_midimusicvolume, 83}, // 41
+ {IT_HEADER, NULL, "Accessibility", NULL, 50},
+ {IT_STRING | IT_CVAR, NULL, "Closed Captioning", &cv_closedcaptioning, 56},
+ {IT_STRING | IT_CVAR, NULL, "Reset Music Upon Dying", &cv_resetmusic, 61},
- {IT_HEADER, NULL, "Accessibility", NULL, 103}, // 50
- {IT_STRING | IT_CVAR, NULL, "Closed Captioning", &cv_closedcaptioning, 115}, // 56
- {IT_STRING | IT_CVAR, NULL, "Reset Music Upon Dying", &cv_resetmusic, 125}, // 62
+ {IT_STRING | IT_CVAR, NULL, "Play Sound Effects if Unfocused", &cv_playsoundsifunfocused, 71},
+ {IT_STRING | IT_CVAR, NULL, "Play Music if Unfocused", &cv_playmusicifunfocused, 76},
#ifdef HAVE_MIXERX
- {IT_STRING | IT_SUBMENU, NULL, "Advanced Settings...", &OP_SoundAdvancedDef, 143},
+ {IT_STRING | IT_SUBMENU, NULL, "Advanced Settings...", &OP_SoundAdvancedDef, 94},
#endif
};
@@ -1963,18 +1984,9 @@ menu_t OP_ColorOptionsDef =
0,
NULL
};
-menu_t OP_SoundOptionsDef =
-{
+menu_t OP_SoundOptionsDef = DEFAULTSCROLLMENUSTYLE(
MN_OP_MAIN + (MN_OP_SOUND << 6),
- "M_SOUND",
- sizeof (OP_SoundOptionsMenu)/sizeof (menuitem_t),
- &OP_MainDef,
- OP_SoundOptionsMenu,
- M_DrawGenericMenu,
- 30, 30,
- 0,
- NULL
-};
+ "M_SOUND", OP_SoundOptionsMenu, &OP_MainDef, 30, 30);
#ifdef HAVE_MIXERX
menu_t OP_SoundAdvancedDef = DEFAULTMENUSTYLE(MN_OP_MAIN + (MN_OP_SOUND << 6), "M_SOUND", OP_SoundAdvancedMenu, &OP_SoundOptionsDef, 30, 30);
#endif
@@ -2291,6 +2303,13 @@ void M_InitMenuPresTables(void)
// so-called "undefined"
menupres[i].fadestrength = -1;
menupres[i].hidetitlepics = -1; // inherits global hidetitlepics
+ menupres[i].ttmode = TTMODE_NONE;
+ menupres[i].ttscale = UINT8_MAX;
+ menupres[i].ttname[0] = 0;
+ menupres[i].ttx = INT16_MAX;
+ menupres[i].tty = INT16_MAX;
+ menupres[i].ttloop = INT16_MAX;
+ menupres[i].tttics = UINT16_MAX;
menupres[i].enterwipe = -1;
menupres[i].exitwipe = -1;
menupres[i].bgcolor = -1;
@@ -2305,9 +2324,11 @@ void M_InitMenuPresTables(void)
{
menupres[i].muslooping = true;
}
- if (i == MN_SP_TIMEATTACK || i == MN_SP_NIGHTSATTACK)
- strncpy(menupres[i].musname, "_inter", 7);
- else if (i == MN_SP_PLAYER)
+ if (i == MN_SP_TIMEATTACK)
+ strncpy(menupres[i].musname, "_recat", 7);
+ else if (i == MN_SP_NIGHTSATTACK)
+ strncpy(menupres[i].musname, "_nitat", 7);
+ else if (i == MN_SP_PLAYER || i == MN_SR_PLAYER)
strncpy(menupres[i].musname, "_chsel", 7);
}
}
@@ -2399,7 +2420,7 @@ static boolean MIT_SetCurBackground(UINT32 menutype, INT32 level, INT32 *retval,
}
else if (menupres[menutype].bgname[0])
{
- strncpy(curbgname, menupres[menutype].bgname, 9);
+ strncpy(curbgname, menupres[menutype].bgname, 8);
curbgxspeed = menupres[menutype].titlescrollxspeed != INT32_MAX ? menupres[menutype].titlescrollxspeed : titlescrollxspeed;
curbgyspeed = menupres[menutype].titlescrollyspeed != INT32_MAX ? menupres[menutype].titlescrollyspeed : titlescrollyspeed;
return true;
@@ -2467,7 +2488,7 @@ static boolean MIT_SetCurFadeValue(UINT32 menutype, INT32 level, INT32 *retval,
return false;
}
-static boolean MIT_SetCurHideTitlePics(UINT32 menutype, INT32 level, INT32 *retval, void **input, boolean fromoldest)
+static boolean MIT_SetCurTitlePics(UINT32 menutype, INT32 level, INT32 *retval, void **input, boolean fromoldest)
{
(void)input;
(void)retval;
@@ -2481,8 +2502,41 @@ static boolean MIT_SetCurHideTitlePics(UINT32 menutype, INT32 level, INT32 *retv
curhidepics = menupres[menutype].hidetitlepics;
return true;
}
+ else if (menupres[menutype].ttmode == TTMODE_USER)
+ {
+ if (menupres[menutype].ttname[0])
+ {
+ curhidepics = menupres[menutype].hidetitlepics;
+ curttmode = menupres[menutype].ttmode;
+ curttscale = (menupres[menutype].ttscale != UINT8_MAX ? menupres[menutype].ttscale : ttscale);
+ strncpy(curttname, menupres[menutype].ttname, 9);
+ curttx = (menupres[menutype].ttx != INT16_MAX ? menupres[menutype].ttx : ttx);
+ curtty = (menupres[menutype].tty != INT16_MAX ? menupres[menutype].tty : tty);
+ curttloop = (menupres[menutype].ttloop != INT16_MAX ? menupres[menutype].ttloop : ttloop);
+ curtttics = (menupres[menutype].tttics != UINT16_MAX ? menupres[menutype].tttics : tttics);
+ }
+ else
+ curhidepics = menupres[menutype].hidetitlepics;
+ return true;
+ }
+ else if (menupres[menutype].ttmode != TTMODE_NONE)
+ {
+ curhidepics = menupres[menutype].hidetitlepics;
+ curttmode = menupres[menutype].ttmode;
+ curttscale = (menupres[menutype].ttscale != UINT8_MAX ? menupres[menutype].ttscale : ttscale);
+ return true;
+ }
else if (!level)
+ {
curhidepics = hidetitlepics;
+ curttmode = ttmode;
+ curttscale = ttscale;
+ strncpy(curttname, ttname, 9);
+ curttx = ttx;
+ curtty = tty;
+ curttloop = ttloop;
+ curtttics = tttics;
+ }
return false;
}
@@ -2517,7 +2571,7 @@ void M_ChangeMenuMusic(const char *defaultmusname, boolean defaultmuslooping)
void M_SetMenuCurBackground(const char *defaultname)
{
- char name[8];
+ char name[9];
strncpy(name, defaultname, 8);
M_IterateMenuTree(MIT_SetCurBackground, &name);
}
@@ -2527,9 +2581,9 @@ void M_SetMenuCurFadeValue(UINT8 defaultvalue)
M_IterateMenuTree(MIT_SetCurFadeValue, &defaultvalue);
}
-void M_SetMenuCurHideTitlePics(void)
+void M_SetMenuCurTitlePics(void)
{
- M_IterateMenuTree(MIT_SetCurHideTitlePics, NULL);
+ M_IterateMenuTree(MIT_SetCurTitlePics, NULL);
}
// ====================================
@@ -2579,14 +2633,20 @@ static void M_HandleMenuPresState(menu_t *newMenu)
curbgyspeed = titlescrollyspeed;
curbghide = (gamestate != GS_TIMEATTACK); // show in time attack, hide in other menus
+ curttmode = ttmode;
+ curttscale = ttscale;
+ strncpy(curttname, ttname, 9);
+ curttx = ttx;
+ curtty = tty;
+ curttloop = ttloop;
+ curtttics = tttics;
+
// don't do the below during the in-game menus
if (gamestate != GS_TITLESCREEN && gamestate != GS_TIMEATTACK)
return;
- // Find current presentation values
- M_SetMenuCurBackground((gamestate == GS_TIMEATTACK) ? "SRB2BACK" : "TITLESKY");
M_SetMenuCurFadeValue(16);
- M_SetMenuCurHideTitlePics();
+ M_SetMenuCurTitlePics();
// Loop through both menu IDs in parallel and look for type changes
// The youngest child in activeMenuId is the entered menu
@@ -2797,31 +2857,19 @@ static void M_ChangeCvar(INT32 choice)
choice = (choice<<1) - 1;
- if (((currentMenu->menuitems[itemOn].status & IT_CVARTYPE) == IT_CV_SLIDER)
- ||((currentMenu->menuitems[itemOn].status & IT_CVARTYPE) == IT_CV_INVISSLIDER)
- ||((currentMenu->menuitems[itemOn].status & IT_CVARTYPE) == IT_CV_NOMOD))
+ if (cv->flags & CV_FLOAT)
{
- if (cv->flags & CV_FLOAT && (currentMenu->menuitems[itemOn].status & IT_CV_FLOATSLIDER) == IT_CV_FLOATSLIDER)
+ if (((currentMenu->menuitems[itemOn].status & IT_CVARTYPE) == IT_CV_SLIDER)
+ ||((currentMenu->menuitems[itemOn].status & IT_CVARTYPE) == IT_CV_INVISSLIDER)
+ ||((currentMenu->menuitems[itemOn].status & IT_CVARTYPE) == IT_CV_NOMOD)
+ || !(currentMenu->menuitems[itemOn].status & IT_CV_INTEGERSTEP))
{
char s[20];
sprintf(s,"%f",FIXED_TO_FLOAT(cv->value)+(choice)*(1.0f/16.0f));
CV_Set(cv,s);
}
else
- CV_SetValue(cv,cv->value+(choice));
- }
- else if (cv->flags & CV_FLOAT)
- {
- if (currentMenu->menuitems[itemOn].status & IT_CV_INTEGERSTEP)
- {
CV_SetValue(cv,FIXED_TO_FLOAT(cv->value)+(choice));
- }
- else
- {
- char s[20];
- sprintf(s,"%f",FIXED_TO_FLOAT(cv->value)+(choice)*(1.0f/16.0f));
- CV_Set(cv,s);
- }
}
else
CV_AddValue(cv,choice);
@@ -2906,6 +2954,15 @@ static void M_PrevOpt(void)
// (in other words -- stop bullshit happening by mashing buttons in fades)
static boolean noFurtherInput = false;
+static void Command_Manual_f(void)
+{
+ if (modeattacking)
+ return;
+ M_StartControlPanel();
+ currentMenu = &MISC_HelpDef;
+ itemOn = 0;
+}
+
//
// M_Responder
//
@@ -2934,6 +2991,7 @@ boolean M_Responder(event_t *ev)
{
if (ev->type == ev_keydown)
{
+ keydown++;
ch = ev->data1;
// added 5-2-98 remap virtual keys (mouse & joystick buttons)
@@ -3040,6 +3098,8 @@ boolean M_Responder(event_t *ev)
pmousex = lastx += 30;
}
}
+ else if (ev->type == ev_keyup) // Preserve event for other responders
+ keydown = 0;
}
else if (ev->type == ev_keydown) // Preserve event for other responders
ch = ev->data1;
@@ -3056,11 +3116,7 @@ boolean M_Responder(event_t *ev)
switch (ch)
{
case KEY_F1: // Help key
- if (modeattacking)
- return true;
- M_StartControlPanel();
- currentMenu = &MISC_HelpDef;
- itemOn = 0;
+ Command_Manual_f();
return true;
case KEY_F2: // Empty
@@ -3332,7 +3388,7 @@ void M_Drawer(void)
}
// focus lost notification goes on top of everything, even the former everything
- if (window_notinfocus)
+ if (window_notinfocus && cv_showfocuslost.value)
{
M_DrawTextBox((BASEVIDWIDTH/2) - (60), (BASEVIDHEIGHT/2) - (16), 13, 2);
if (gamestate == GS_LEVEL && (P_AutoPause() || paused))
@@ -3487,6 +3543,7 @@ void M_ClearMenus(boolean callexitmenufunc)
if (currentMenu == &MessageDef) // Oh sod off!
currentMenu = &MainDef; // Not like it matters
menuactive = false;
+ hidetitlemap = false;
}
//
@@ -3525,6 +3582,8 @@ void M_SetupNextMenu(menu_t *menudef)
}
}
}
+
+ hidetitlemap = false;
}
//
@@ -3557,6 +3616,8 @@ void M_Init(void)
{
int i;
+ COM_AddCommand("manual", Command_Manual_f);
+
CV_RegisterVar(&cv_nextmap);
CV_RegisterVar(&cv_newgametype);
CV_RegisterVar(&cv_chooseskin);
@@ -3630,9 +3691,13 @@ void M_InitCharacterTables(void)
description[i].used = false;
strcpy(description[i].notes, "???");
strcpy(description[i].picname, "");
+ strcpy(description[i].nametag, "");
strcpy(description[i].skinname, "");
+ strcpy(description[i].displayname, "");
description[i].prev = description[i].next = 0;
- description[i].pic = NULL;
+ description[i].charpic = NULL;
+ description[i].namepic = NULL;
+ description[i].oppositecolor = description[i].tagtextcolor = description[i].tagoutlinecolor = 0;
}
}
@@ -3895,7 +3960,7 @@ static void M_DrawMapEmblems(INT32 mapnum, INT32 x, INT32 y)
lasttype = curtype;
if (emblem->collected)
- V_DrawSmallMappedPatch(x, y, 0, W_CachePatchName(M_GetEmblemPatch(emblem), PU_CACHE),
+ V_DrawSmallMappedPatch(x, y, 0, W_CachePatchName(M_GetEmblemPatch(emblem, false), PU_CACHE),
R_GetTranslationColormap(TC_DEFAULT, M_GetEmblemColor(emblem), GTC_CACHE));
else
V_DrawSmallScaledPatch(x, y, 0, W_CachePatchName("NEEDIT", PU_CACHE));
@@ -4334,7 +4399,7 @@ static void M_DrawPauseMenu(void)
continue;
if (emblem->collected)
- V_DrawSmallMappedPatch(40, 44 + (i*8), 0, W_CachePatchName(M_GetEmblemPatch(emblem), PU_CACHE),
+ V_DrawSmallMappedPatch(40, 44 + (i*8), 0, W_CachePatchName(M_GetEmblemPatch(emblem, false), PU_CACHE),
R_GetTranslationColormap(TC_DEFAULT, M_GetEmblemColor(emblem), GTC_CACHE));
else
V_DrawSmallScaledPatch(40, 44 + (i*8), 0, W_CachePatchName("NEEDIT", PU_CACHE));
@@ -4554,10 +4619,12 @@ static boolean M_LevelAvailableOnPlatter(INT32 mapnum)
if (!(mapheaderinfo[mapnum]->typeoflevel & TOL_COOP))
return true;
- if (mapvisited[mapnum]) // MV_MP
+ if (mapnum+1 == spstage_start)
return true;
- if (mapnum+1 == spstage_start)
+#ifndef DEVELOP
+ if (mapvisited[mapnum]) // MV_MP
+#endif
return true;
/* FALLTHRU */
@@ -4903,13 +4970,25 @@ static void M_HandleLevelPlatter(INT32 choice)
{
boolean exitmenu = false; // exit to previous menu
INT32 selectval;
+ UINT8 iter;
switch (choice)
{
case KEY_DOWNARROW:
+ if (lsrow == levelselect.numrows-1)
+ {
+ if (levelselect.numrows < 3)
+ {
+ if (!lsoffs[0]) // prevent sound spam
+ {
+ lsoffs[0] = -8;
+ S_StartSound(NULL,sfx_s3kb7);
+ }
+ return;
+ }
+ lsrow = UINT8_MAX;
+ }
lsrow++;
- if (lsrow == levelselect.numrows)
- lsrow = 0;
lsoffs[0] = lsvseperation(lsrow);
@@ -4923,17 +5002,29 @@ static void M_HandleLevelPlatter(INT32 choice)
break;
case KEY_UPARROW:
- lsoffs[0] = -lsvseperation(lsrow);
-
+ iter = lsrow;
+ if (!lsrow)
+ {
+ if (levelselect.numrows < 3)
+ {
+ if (!lsoffs[0]) // prevent sound spam
+ {
+ lsoffs[0] = 8;
+ S_StartSound(NULL,sfx_s3kb7);
+ }
+ return;
+ }
+ lsrow = levelselect.numrows;
+ }
lsrow--;
- if (lsrow == UINT8_MAX)
- lsrow = levelselect.numrows-1;
+
+ lsoffs[0] = -lsvseperation(iter);
if (levelselect.rows[lsrow].header[0])
lshli = lsrow;
else
{
- UINT8 iter = lsrow;
+ iter = lsrow;
do
iter = ((iter == 0) ? levelselect.numrows-1 : iter-1);
while ((iter != lsrow) && !(levelselect.rows[iter].header[0]));
@@ -4966,7 +5057,7 @@ static void M_HandleLevelPlatter(INT32 choice)
M_LevelSelectWarp(0);
Nextmap_OnChange();
}
- else if (!lsoffs[0]) // prevent sound spam
+ else if (!lsoffs[0]) // prevent sound spam
{
lsoffs[0] = -8;
S_StartSound(NULL,sfx_s3kb2);
@@ -4996,7 +5087,7 @@ static void M_HandleLevelPlatter(INT32 choice)
ifselectvalnextmap(lscol) else ifselectvalnextmap(0)
}
- else if (!lsoffs[1]) // prevent sound spam
+ else if (!lsoffs[1]) // prevent sound spam
{
lsoffs[1] = 8;
S_StartSound(NULL,sfx_s3kb7);
@@ -5025,7 +5116,7 @@ static void M_HandleLevelPlatter(INT32 choice)
ifselectvalnextmap(lscol) else ifselectvalnextmap(0)
}
- else if (!lsoffs[1]) // prevent sound spam
+ else if (!lsoffs[1]) // prevent sound spam
{
lsoffs[1] = -8;
S_StartSound(NULL,sfx_s3kb7);
@@ -5177,18 +5268,187 @@ static void M_DrawLevelPlatterRow(UINT8 row, INT32 y)
}
}
+// new menus
+static void M_DrawRecordAttackForeground(void)
+{
+ patch_t *fg = W_CachePatchName("RECATKFG", PU_CACHE);
+ patch_t *clock = W_CachePatchName("RECCLOCK", PU_CACHE);
+ angle_t fa;
+
+ INT32 i;
+ INT32 height = (SHORT(fg->height)/2);
+ INT32 dupz = (vid.dupx < vid.dupy ? vid.dupx : vid.dupy);
+
+ for (i = -12; i < (BASEVIDHEIGHT/height) + 12; i++)
+ {
+ INT32 y = ((i*height) - (height - ((recatkdrawtimer*2)%height)));
+ // don't draw above the screen
+ {
+ INT32 sy = FixedMul(y, dupz<<FRACBITS) >> FRACBITS;
+ if (vid.height != BASEVIDHEIGHT * dupz)
+ sy += (vid.height - (BASEVIDHEIGHT * dupz)) / 2;
+ if ((sy+height) < 0)
+ continue;
+ }
+ V_DrawFixedPatch(0, y<<FRACBITS, FRACUNIT/2, V_SNAPTOLEFT, fg, NULL);
+ V_DrawFixedPatch(BASEVIDWIDTH<<FRACBITS, y<<FRACBITS, FRACUNIT/2, V_SNAPTORIGHT|V_FLIP, fg, NULL);
+ // don't draw below the screen
+ if (y > vid.height)
+ break;
+ }
+
+ // draw clock
+ fa = (FixedAngle(((recatkdrawtimer * 4) % 360)<<FRACBITS)>>ANGLETOFINESHIFT) & FINEMASK;
+ V_DrawSciencePatch(160<<FRACBITS, (80<<FRACBITS) + (4*FINESINE(fa)), 0, clock, FRACUNIT);
+
+ // Increment timer.
+ recatkdrawtimer++;
+}
+
+// NiGHTS Attack background.
+static void M_DrawNightsAttackMountains(void)
+{
+ static INT32 bgscrollx;
+ INT32 dupz = (vid.dupx < vid.dupy ? vid.dupx : vid.dupy);
+ patch_t *background = W_CachePatchName(curbgname, PU_CACHE);
+ INT32 x = FixedInt(bgscrollx) % SHORT(background->width);
+ INT32 y = BASEVIDHEIGHT - SHORT(background->height)*2;
+
+ if (vid.height != BASEVIDHEIGHT * dupz)
+ V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 158);
+ V_DrawFill(0, y+50, vid.width, BASEVIDHEIGHT, V_SNAPTOLEFT|31);
+
+ V_DrawScaledPatch(x, y, V_SNAPTOLEFT, background);
+ x += SHORT(background->width);
+ if (x < BASEVIDWIDTH)
+ V_DrawScaledPatch(x, y, V_SNAPTOLEFT, background);
+
+ bgscrollx -= (FRACUNIT/2);
+}
+
+// NiGHTS Attack foreground.
+static void M_DrawNightsAttackBackground(void)
+{
+ INT32 x, y = 0;
+ INT32 i;
+
+ // top
+ patch_t *backtopfg = W_CachePatchName("NTSATKT1", PU_CACHE);
+ patch_t *fronttopfg = W_CachePatchName("NTSATKT2", PU_CACHE);
+ INT32 backtopwidth = SHORT(backtopfg->width);
+ //INT32 backtopheight = SHORT(backtopfg->height);
+ INT32 fronttopwidth = SHORT(fronttopfg->width);
+ //INT32 fronttopheight = SHORT(fronttopfg->height);
+
+ // bottom
+ patch_t *backbottomfg = W_CachePatchName("NTSATKB1", PU_CACHE);
+ patch_t *frontbottomfg = W_CachePatchName("NTSATKB2", PU_CACHE);
+ INT32 backbottomwidth = SHORT(backbottomfg->width);
+ INT32 backbottomheight = SHORT(backbottomfg->height);
+ INT32 frontbottomwidth = SHORT(frontbottomfg->width);
+ INT32 frontbottomheight = SHORT(frontbottomfg->height);
+
+ // background
+ M_DrawNightsAttackMountains();
+
+ // back top foreground patch
+ x = -(ntsatkdrawtimer%backtopwidth);
+ V_DrawScaledPatch(x, y, V_SNAPTOTOP|V_SNAPTOLEFT, backtopfg);
+ for (i = 0; i < 3; i++)
+ {
+ x += (backtopwidth);
+ if (x >= vid.width)
+ break;
+ V_DrawScaledPatch(x, y, V_SNAPTOTOP|V_SNAPTOLEFT, backtopfg);
+ }
+
+ // front top foreground patch
+ x = -((ntsatkdrawtimer*2)%fronttopwidth);
+ V_DrawScaledPatch(x, y, V_SNAPTOTOP|V_SNAPTOLEFT, fronttopfg);
+ for (i = 0; i < 3; i++)
+ {
+ x += (fronttopwidth);
+ if (x >= vid.width)
+ break;
+ V_DrawScaledPatch(x, y, V_SNAPTOTOP|V_SNAPTOLEFT, fronttopfg);
+ }
+
+ // back bottom foreground patch
+ x = -(ntsatkdrawtimer%backbottomwidth);
+ y = BASEVIDHEIGHT - backbottomheight;
+ V_DrawScaledPatch(x, y, V_SNAPTOBOTTOM|V_SNAPTOLEFT, backbottomfg);
+ for (i = 0; i < 3; i++)
+ {
+ x += (backbottomwidth);
+ if (x >= vid.width)
+ break;
+ V_DrawScaledPatch(x, y, V_SNAPTOBOTTOM|V_SNAPTOLEFT, backbottomfg);
+ }
+
+ // front bottom foreground patch
+ x = -((ntsatkdrawtimer*2)%frontbottomwidth);
+ y = BASEVIDHEIGHT - frontbottomheight;
+ V_DrawScaledPatch(x, y, V_SNAPTOBOTTOM|V_SNAPTOLEFT, frontbottomfg);
+ for (i = 0; i < 3; i++)
+ {
+ x += (frontbottomwidth);
+ if (x >= vid.width)
+ break;
+ V_DrawScaledPatch(x, y, V_SNAPTOBOTTOM|V_SNAPTOLEFT, frontbottomfg);
+ }
+
+ // Increment timer.
+ ntsatkdrawtimer++;
+}
+
+// NiGHTS Attack floating Super Sonic.
+static patch_t *ntssupersonic[2];
+static void M_DrawNightsAttackSuperSonic(void)
+{
+ const UINT8 *colormap = R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_YELLOW, GTC_CACHE);
+ INT32 timer = (ntsatkdrawtimer/4) % 2;
+ angle_t fa = (FixedAngle(((ntsatkdrawtimer * 4) % 360)<<FRACBITS)>>ANGLETOFINESHIFT) & FINEMASK;
+ V_DrawFixedPatch(235<<FRACBITS, (120<<FRACBITS) - (8*FINESINE(fa)), FRACUNIT, 0, ntssupersonic[timer], colormap);
+}
+
static void M_DrawLevelPlatterMenu(void)
{
UINT8 iter = lsrow, sizeselect = (lswide(lsrow) ? 1 : 0);
INT32 y = lsbasey + lsoffs[0] - getheadingoffset(lsrow);
const INT32 cursorx = (sizeselect ? 0 : (lscol*lshseperation));
- if (gamestate == GS_TIMEATTACK)
+ if (currentMenu->prevMenu == &SP_TimeAttackDef)
{
+ M_SetMenuCurBackground("RECATKBG");
+
+ curbgxspeed = 0;
+ curbgyspeed = 18;
+
if (curbgcolor >= 0)
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, curbgcolor);
else if (!curbghide || !titlemapinaction)
+ {
F_SkyScroll(curbgxspeed, curbgyspeed, curbgname);
+ // Draw and animate foreground
+ if (!strncmp("RECATKBG", curbgname, 8))
+ M_DrawRecordAttackForeground();
+ }
+
+ if (curfadevalue)
+ V_DrawFadeScreen(0xFF00, curfadevalue);
+ }
+
+ if (currentMenu->prevMenu == &SP_NightsAttackDef)
+ {
+ M_SetMenuCurBackground("NTSATKBG");
+
+ if (curbgcolor >= 0)
+ V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, curbgcolor);
+ else if (!curbghide || !titlemapinaction)
+ {
+ V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 158);
+ M_DrawNightsAttackMountains();
+ }
if (curfadevalue)
V_DrawFadeScreen(0xFF00, curfadevalue);
}
@@ -5196,7 +5456,13 @@ static void M_DrawLevelPlatterMenu(void)
// finds row at top of the screen
while (y > -8)
{
- iter = ((iter == 0) ? levelselect.numrows-1 : iter-1);
+ if (iter == 0)
+ {
+ if (levelselect.numrows < 3)
+ break;
+ iter = levelselect.numrows;
+ }
+ iter--;
y -= lsvseperation(iter);
}
@@ -5205,7 +5471,13 @@ static void M_DrawLevelPlatterMenu(void)
{
M_DrawLevelPlatterRow(iter, y);
y += lsvseperation(iter);
- iter = ((iter == levelselect.numrows-1) ? 0 : iter+1);
+ if (iter == levelselect.numrows-1)
+ {
+ if (levelselect.numrows < 3)
+ break;
+ iter = UINT8_MAX;
+ }
+ iter++;
}
// draw cursor box
@@ -5397,7 +5669,19 @@ static void M_DrawMessageMenu(void)
if (curbgcolor >= 0)
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, curbgcolor);
else if (!curbghide || !titlemapinaction)
- F_SkyScroll(curbgxspeed, curbgyspeed, curbgname);
+ {
+ if (levellistmode == LLM_NIGHTSATTACK)
+ {
+ V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 158);
+ M_DrawNightsAttackMountains();
+ }
+ else
+ {
+ F_SkyScroll(curbgxspeed, curbgyspeed, curbgname);
+ if (!strncmp("RECATKBG", curbgname, 8))
+ M_DrawRecordAttackForeground();
+ }
+ }
if (curfadevalue)
V_DrawFadeScreen(0xFF00, curfadevalue);
}
@@ -6098,9 +6382,9 @@ static void M_PandorasBox(INT32 choice)
else
CV_StealthSetValue(&cv_dummyrings, max(players[consoleplayer].rings, 0));
if (players[consoleplayer].lives == INFLIVES)
- CV_StealthSetValue(&cv_dummylives, -1);
+ CV_StealthSet(&cv_dummylives, "Infinite");
else
- CV_StealthSetValue(&cv_dummylives, players[consoleplayer].lives);
+ CV_StealthSetValue(&cv_dummylives, max(players[consoleplayer].lives, 1));
CV_StealthSetValue(&cv_dummycontinues, players[consoleplayer].continues);
SR_PandorasBox[6].status = ((players[consoleplayer].charflags & SF_SUPER)
#ifndef DEVELOP
@@ -6297,7 +6581,7 @@ static void M_LevelSelectWarp(INT32 choice)
if (W_CheckNumForName(G_BuildMapName(cv_nextmap.value)) == LUMPERROR)
{
-// CONS_Alert(CONS_WARNING, "Internal game map '%s' not found\n", G_BuildMapName(cv_nextmap.value));
+ CONS_Alert(CONS_WARNING, "Internal game map '%s' not found\n", G_BuildMapName(cv_nextmap.value));
return;
}
@@ -6682,7 +6966,7 @@ static void M_DrawEmblemHints(void)
if (emblem->collected)
{
collected = V_GREENMAP;
- V_DrawMappedPatch(12, 12+(28*j), 0, W_CachePatchName(M_GetEmblemPatch(emblem), PU_CACHE),
+ V_DrawMappedPatch(12, 12+(28*j), 0, W_CachePatchName(M_GetEmblemPatch(emblem, false), PU_CACHE),
R_GetTranslationColormap(TC_DEFAULT, M_GetEmblemColor(emblem), GTC_CACHE));
}
else
@@ -7633,6 +7917,8 @@ static void M_HandleLoadSave(INT32 choice)
}
if (exitmenu)
{
+ // Is this a hack?
+ charseltimer = 0;
if (currentMenu->prevMenu)
M_SetupNextMenu(currentMenu->prevMenu);
else
@@ -7709,69 +7995,102 @@ static void M_SetupChoosePlayer(INT32 choice)
UINT8 firstvalid = 255;
UINT8 lastvalid = 0;
boolean allowed = false;
- char *name;
+ char *and;
(void)choice;
- SP_PlayerMenu[0].status &= ~IT_DYBIGSPACE; // Correcting a hack that may be made below.
-
- for (i = 0; i < 32; i++) // Handle charsels, availability, and unlocks.
+ if (!(mapheaderinfo[startmap-1]
+ && (mapheaderinfo[startmap-1]->forcecharacter[0] != '\0'
+ || (mapheaderinfo[startmap-1]->typeoflevel & TOL_NIGHTS)) // remove this later when everyone gets their own nights sprites, maybe
+ ))
{
- if (description[i].used) // If the character's disabled through SOC, there's nothing we can do for it.
+ for (i = 0; i < 32; i++) // Handle charsels, availability, and unlocks.
{
- name = strtok(Z_StrDup(description[i].skinname), "&");
- skinnum = R_SkinAvailable(name);
- if ((skinnum != -1) && (R_SkinUsable(-1, skinnum)))
+ if (description[i].used) // If the character's disabled through SOC, there's nothing we can do for it.
{
- // Handling order.
- if (firstvalid == 255)
- firstvalid = i;
+ and = strchr(description[i].skinname, '&');
+ if (and)
+ {
+ char firstskin[SKINNAMESIZE+1];
+ strncpy(firstskin, description[i].skinname, (and - description[i].skinname));
+ firstskin[(and - description[i].skinname)] = '\0';
+ description[i].skinnum[0] = R_SkinAvailable(firstskin);
+ description[i].skinnum[1] = R_SkinAvailable(and+1);
+ }
else
{
- description[i].prev = lastvalid;
- description[lastvalid].next = i;
+ description[i].skinnum[0] = R_SkinAvailable(description[i].skinname);
+ description[i].skinnum[1] = -1;
}
- lastvalid = i;
+ skinnum = description[i].skinnum[0];
+ if ((skinnum != -1) && (R_SkinUsable(-1, skinnum)))
+ {
+ // Handling order.
+ if (firstvalid == 255)
+ firstvalid = i;
+ else
+ {
+ description[i].prev = lastvalid;
+ description[lastvalid].next = i;
+ }
+ lastvalid = i;
- if (i == char_on)
- allowed = true;
+ if (i == char_on)
+ allowed = true;
- if (!(description[i].picname[0]))
- {
- if (skins[skinnum].sprites[SPR2_XTRA].numframes >= 2)
+ if (!(description[i].picname[0]))
{
- spritedef_t *sprdef = &skins[skinnum].sprites[SPR2_XTRA];
- spriteframe_t *sprframe = &sprdef->spriteframes[1];
- description[i].pic = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
+ if (skins[skinnum].sprites[SPR2_XTRA].numframes >= XTRA_CHARSEL+1)
+ {
+ spritedef_t *sprdef = &skins[skinnum].sprites[SPR2_XTRA];
+ spriteframe_t *sprframe = &sprdef->spriteframes[XTRA_CHARSEL];
+ description[i].charpic = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
+ }
+ else
+ description[i].charpic = W_CachePatchName("MISSING", PU_CACHE);
}
else
- description[i].pic = W_CachePatchName("MISSING", PU_PATCH);
+ description[i].charpic = W_CachePatchName(description[i].picname, PU_PATCH);
+
+ if (description[i].nametag[0])
+ {
+ const char *nametag = description[i].nametag;
+ description[i].namepic = NULL;
+ if (W_LumpExists(nametag))
+ description[i].namepic = W_CachePatchName(nametag, PU_CACHE);
+ }
}
- else
- description[i].pic = W_CachePatchName(description[i].picname, PU_PATCH);
+ // else -- Technically, character select icons without corresponding skins get bundled away behind this too. Sucks to be them.
}
- // else -- Technically, character select icons without corresponding skins get bundled away behind this too. Sucks to be them.
- Z_Free(name);
}
}
- if ((firstvalid != 255)
- && !(mapheaderinfo[startmap-1]
- && (mapheaderinfo[startmap-1]->forcecharacter[0] != '\0')
- )
- )
+ if (firstvalid != 255)
{ // One last bit of order we can't do in the iteration above.
description[firstvalid].prev = lastvalid;
description[lastvalid].next = firstvalid;
}
- else // We're being forced into a specific character, so might as well.
+ else // We're being forced into a specific character, so might as well just skip it.
{
- SP_PlayerMenu[0].status |= IT_DYBIGSPACE; // This is a dummy flag hack to make a non-IT_CALL character in slot 0 not softlock the game.
- M_ChoosePlayer(0);
+ M_ChoosePlayer(-1);
return;
}
- if (Playing() == false)
- M_ChangeMenuMusic("_chsel", true);
+ M_ChangeMenuMusic("_chsel", true);
+
+ /* the menus suck -James */
+ if (currentMenu == &SP_LoadDef)/* from save states */
+ {
+ SP_PlayerDef.menuid =
+ MN_SP_MAIN +
+ ( MN_SP_LOAD << 6 ) +
+ ( MN_SP_PLAYER << 12 );
+ }
+ else/* from Secret level select */
+ {
+ SP_PlayerDef.menuid =
+ MN_SR_MAIN +
+ ( MN_SR_PLAYER << 6 );
+ }
SP_PlayerDef.prevMenu = currentMenu;
M_SetupNextMenu(&SP_PlayerDef);
@@ -7785,7 +8104,11 @@ static void M_SetupChoosePlayer(INT32 choice)
char_on = description[char_on].next;
}
}
- char_scroll = 0; // finish scrolling the menu
+
+ // finish scrolling the menu
+ char_scroll = 0;
+ charseltimer = 0;
+
Z_Free(char_notes);
char_notes = V_WordWrap(0, 21*8, V_ALLOWLOWERCASE, description[char_on].notes);
}
@@ -7800,6 +8123,9 @@ static void M_HandleChoosePlayerMenu(INT32 choice)
boolean exitmenu = false; // exit to previous menu
INT32 selectval;
+ if (keydown > 1)
+ return;
+
switch (choice)
{
case KEY_DOWNARROW:
@@ -7807,7 +8133,7 @@ static void M_HandleChoosePlayerMenu(INT32 choice)
{
S_StartSound(NULL,sfx_s3kb7);
char_on = selectval;
- char_scroll = -128*FRACUNIT;
+ char_scroll = -charscrollamt;
Z_Free(char_notes);
char_notes = V_WordWrap(0, 21*8, V_ALLOWLOWERCASE, description[char_on].notes);
}
@@ -7823,7 +8149,7 @@ static void M_HandleChoosePlayerMenu(INT32 choice)
{
S_StartSound(NULL,sfx_s3kb7);
char_on = selectval;
- char_scroll = 128*FRACUNIT;
+ char_scroll = charscrollamt;
Z_Free(char_notes);
char_notes = V_WordWrap(0, 21*8, V_ALLOWLOWERCASE, description[char_on].notes);
}
@@ -7849,6 +8175,8 @@ static void M_HandleChoosePlayerMenu(INT32 choice)
if (exitmenu)
{
+ // Is this a hack?
+ charseltimer = 0;
if (currentMenu->prevMenu)
M_SetupNextMenu(currentMenu->prevMenu);
else
@@ -7857,138 +8185,255 @@ static void M_HandleChoosePlayerMenu(INT32 choice)
}
// Draw the choose player setup menu, had some fun with player anim
+//define CHOOSEPLAYER_DRAWHEADER
+
static void M_DrawSetupChoosePlayerMenu(void)
{
- const INT32 my = 24;
- patch_t *patch;
- INT32 i, o;
- UINT8 prev, next;
+ const INT32 my = 16;
- // Black BG
- if (curbgcolor >= 0)
- V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, curbgcolor);
- else if (!curbghide || !titlemapinaction)
- F_SkyScroll(curbgxspeed, curbgyspeed, curbgname);
- if (curfadevalue)
- V_DrawFadeScreen(0xFF00, curfadevalue);
-
- // Character select profile images!1
- M_DrawTextBox(0, my, 16, 20);
+ skin_t *charskin = &skins[0];
+ INT32 skinnum = 0;
+ UINT8 col;
+ UINT8 *colormap = NULL;
+ INT32 prev = -1, next = -1;
+
+ patch_t *charbg = W_CachePatchName("CHARBG", PU_CACHE);
+ patch_t *charfg = W_CachePatchName("CHARFG", PU_CACHE);
+ INT16 bgheight = SHORT(charbg->height);
+ INT16 fgheight = SHORT(charfg->height);
+ INT16 bgwidth = SHORT(charbg->width);
+ INT16 fgwidth = SHORT(charfg->width);
+ INT32 x, y;
+ INT32 w = (vid.width/vid.dupx);
if (abs(char_scroll) > FRACUNIT)
char_scroll -= (char_scroll>>2);
else // close enough.
char_scroll = 0; // just be exact now.
- o = (char_scroll >> FRACBITS) + 16;
+ // Get prev character...
+ prev = description[char_on].prev;
+ // If there's more than one character available...
+ if (prev != char_on)
+ // Let's get the next character now.
+ next = description[char_on].next;
+ else
+ // No there isn't.
+ prev = -1;
+
+ // Find skin number from description[]
+ skinnum = description[char_on].skinnum[0];
+ charskin = &skins[skinnum];
+
+ // Use the opposite of the character's skincolor
+ col = description[char_on].oppositecolor;
+ if (!col)
+ col = Color_Opposite[charskin->prefcolor - 1][0];
+
+ // Make the translation colormap
+ colormap = R_GetTranslationColormap(TC_DEFAULT, col, 0);
- if (o < 0) // A little hacky...
+ // Don't render the title map
+ hidetitlemap = true;
+ charseltimer++;
+
+ // Background and borders
+ V_DrawFill(0, 0, bgwidth, vid.height, V_SNAPTOTOP|colormap[101]);
{
- i = description[char_on].prev;
- o += 128;
+ INT32 sw = (BASEVIDWIDTH * vid.dupx);
+ INT32 bw = (vid.width - sw) / 2;
+ col = colormap[106];
+ if (bw)
+ V_DrawFill(0, 0, bw, vid.height, V_NOSCALESTART|col);
}
- else
- i = char_on;
- // Get prev character...
- prev = description[i].prev;
+ y = (charseltimer%32);
+ V_DrawMappedPatch(0, y-bgheight, V_SNAPTOTOP, charbg, colormap);
+ V_DrawMappedPatch(0, y, V_SNAPTOTOP, charbg, colormap);
+ V_DrawMappedPatch(0, y+bgheight, V_SNAPTOTOP, charbg, colormap);
+ V_DrawMappedPatch(0, -y, V_SNAPTOTOP, charfg, colormap);
+ V_DrawMappedPatch(0, -y+fgheight, V_SNAPTOTOP, charfg, colormap);
+ V_DrawFill(fgwidth, 0, vid.width, vid.height, V_SNAPTOTOP|colormap[106]);
- if (prev != i) // If there's more than one character available...
+ // Character pictures
{
- // Let's get the next character now.
- next = description[i].next;
+ x = 8;
+ y = (my+16) - FixedInt(char_scroll);
+ V_DrawScaledPatch(x, y, 0, description[char_on].charpic);
+ if (prev != -1)
+ V_DrawScaledPatch(x, y - 144, 0, description[prev].charpic);
+ if (next != -1)
+ V_DrawScaledPatch(x, y + 144, 0, description[next].charpic);
+ }
+
+ // Character description
+ {
+ INT32 flags = V_ALLOWLOWERCASE|V_RETURN8;
+ x = 146;
+ y = my + 9;
+ V_DrawString(x, y, flags, char_notes);
+ }
+
+ // Name tags
+ {
+ INT32 ox, oxsh = FixedInt(FixedMul(BASEVIDWIDTH*FRACUNIT, FixedDiv(char_scroll, 128*FRACUNIT))), txsh;
+ patch_t *curpatch = NULL, *prevpatch = NULL, *nextpatch = NULL;
+ const char *curtext = NULL, *prevtext = NULL, *nexttext = NULL;
+ UINT8 curtextcolor = 0, prevtextcolor = 0, nexttextcolor = 0;
+ UINT8 curoutlinecolor = 0, prevoutlinecolor = 0, nextoutlinecolor = 0;
- // Draw prev character if it's visible and its number isn't greater than the current one or there's more than two
- if (o < 32)
+ // Name tag
+ curtext = description[char_on].displayname;
+ curtextcolor = description[char_on].tagtextcolor;
+ curoutlinecolor = description[char_on].tagoutlinecolor;
+ if (curtext[0] == '\0')
+ curpatch = description[char_on].namepic;
+ if (!curtextcolor)
+ curtextcolor = charskin->prefcolor;
+ if (!curoutlinecolor)
+ curoutlinecolor = Color_Opposite[charskin->prefcolor - 1][0];
+
+ txsh = oxsh;
+ ox = 8 + SHORT((description[char_on].charpic)->width)/2;
+ y = my + 144;
+
+ // cur
{
- patch = description[prev].pic;
- if (SHORT(patch->width) >= 256)
- V_DrawCroppedPatch(8<<FRACBITS, (my + 8)<<FRACBITS, FRACUNIT/2, 0, patch, 0, SHORT(patch->height) + 2*(o-32), SHORT(patch->width), 64 - 2*o);
- else
- V_DrawCroppedPatch(8<<FRACBITS, (my + 8)<<FRACBITS, FRACUNIT, 0, patch, 0, SHORT(patch->height) + o - 32, SHORT(patch->width), 32 - o);
- W_UnlockCachedPatch(patch);
+ x = ox - txsh;
+ if (curpatch)
+ x -= (SHORT(curpatch->width)/2);
+
+ if (curtext[0] != '\0')
+ {
+ V_DrawNameTag(
+ x, y, V_CENTERNAMETAG, FRACUNIT,
+ R_GetTranslationColormap(TC_DEFAULT, curtextcolor, 0),
+ R_GetTranslationColormap(TC_DEFAULT, curoutlinecolor, 0),
+ curtext
+ );
+ }
+ else if (curpatch)
+ V_DrawScaledPatch(x, y, 0, curpatch);
}
- // Draw next character if it's visible and its number isn't less than the current one or there's more than two
- if (o < 128) // (next != i) was previously a part of this, but it's implicitly true if (prev != i) is true.
+ if (char_scroll)
{
- patch = description[next].pic;
- if (SHORT(patch->width) >= 256)
- V_DrawCroppedPatch(8<<FRACBITS, (my + 168 - o)<<FRACBITS, FRACUNIT/2, 0, patch, 0, 0, SHORT(patch->width), 2*o);
- else
- V_DrawCroppedPatch(8<<FRACBITS, (my + 168 - o)<<FRACBITS, FRACUNIT, 0, patch, 0, 0, SHORT(patch->width), o);
- W_UnlockCachedPatch(patch);
+ // prev
+ if ((prev != -1) && char_scroll < 0)
+ {
+ prevtext = description[prev].displayname;
+ prevtextcolor = description[prev].tagtextcolor;
+ prevoutlinecolor = description[prev].tagoutlinecolor;
+ if (prevtext[0] == '\0')
+ prevpatch = description[prev].namepic;
+ charskin = &skins[description[prev].skinnum[0]];
+ if (!prevtextcolor)
+ prevtextcolor = charskin->prefcolor;
+ if (!prevoutlinecolor)
+ prevoutlinecolor = Color_Opposite[charskin->prefcolor - 1][0];
+
+ x = (ox - txsh) - w;
+ if (prevpatch)
+ x -= (SHORT(prevpatch->width)/2);
+
+ if (prevtext[0] != '\0')
+ {
+ V_DrawNameTag(
+ x, y, V_CENTERNAMETAG, FRACUNIT,
+ R_GetTranslationColormap(TC_DEFAULT, prevtextcolor, 0),
+ R_GetTranslationColormap(TC_DEFAULT, prevoutlinecolor, 0),
+ prevtext
+ );
+ }
+ else if (prevpatch)
+ V_DrawScaledPatch(x, y, 0, prevpatch);
+ }
+ // next
+ else if ((next != -1) && char_scroll > 0)
+ {
+ nexttext = description[next].displayname;
+ nexttextcolor = description[next].tagtextcolor;
+ nextoutlinecolor = description[next].tagoutlinecolor;
+ if (nexttext[0] == '\0')
+ nextpatch = description[next].namepic;
+ charskin = &skins[description[next].skinnum[0]];
+ if (!nexttextcolor)
+ nexttextcolor = charskin->prefcolor;
+ if (!nextoutlinecolor)
+ nextoutlinecolor = Color_Opposite[charskin->prefcolor - 1][0];
+
+ x = (ox - txsh) + w;
+ if (nextpatch)
+ x -= (SHORT(nextpatch->width)/2);
+
+ if (nexttext[0] != '\0')
+ {
+ V_DrawNameTag(
+ x, y, V_CENTERNAMETAG, FRACUNIT,
+ R_GetTranslationColormap(TC_DEFAULT, nexttextcolor, 0),
+ R_GetTranslationColormap(TC_DEFAULT, nextoutlinecolor, 0),
+ nexttext
+ );
+ }
+ else if (nextpatch)
+ V_DrawScaledPatch(x, y, 0, nextpatch);
+ }
}
}
- patch = description[i].pic;
- if (o >= 0 && o <= 32)
+ // Alternative menu header
+#ifdef CHOOSEPLAYER_DRAWHEADER
{
- if (SHORT(patch->width) >= 256)
- V_DrawSmallScaledPatch(8, my + 40 - o, 0, patch);
- else
- V_DrawScaledPatch(8, my + 40 - o, 0, patch);
+ patch_t *header = W_CachePatchName("M_PICKP", PU_CACHE);
+ INT32 xtitle = 146;
+ INT32 ytitle = (35 - SHORT(header->height))/2;
+ V_DrawFixedPatch(xtitle<<FRACBITS, ytitle<<FRACBITS, FRACUNIT/2, 0, header, NULL);
}
- else
- {
- if (SHORT(patch->width) >= 256)
- V_DrawCroppedPatch(8<<FRACBITS, (my + 8)<<FRACBITS, FRACUNIT/2, 0, patch, 0, (o-32)*2, SHORT(patch->width), SHORT(patch->height) - 2*(o-32));
- else
- V_DrawCroppedPatch(8<<FRACBITS, (my + 8)<<FRACBITS, FRACUNIT, 0, patch, 0, (o-32), SHORT(patch->width), SHORT(patch->height) - (o-32));
- }
- W_UnlockCachedPatch(patch);
+#endif // CHOOSEPLAYER_DRAWHEADER
- // draw title (or big pic)
M_DrawMenuTitle();
-
- // Character description
- M_DrawTextBox(136, my, 21, 20);
- V_DrawString(146, my + 9, V_RETURN8|V_ALLOWLOWERCASE, char_notes);
}
// Chose the player you want to use Tails 03-02-2002
static void M_ChoosePlayer(INT32 choice)
{
- char *skin1,*skin2;
- INT32 skinnum;
boolean ultmode = (ultimate_selectable && SP_PlayerDef.prevMenu == &SP_LoadDef && saveSlotSelected == NOSAVESLOT);
+ UINT8 skinnum;
// skip this if forcecharacter or no characters available
- if (!(SP_PlayerMenu[0].status & IT_DYBIGSPACE))
+ if (choice == -1)
+ {
+ skinnum = botskin = 0;
+ botingame = false;
+ }
+ // M_SetupChoosePlayer didn't call us directly, that means we've been properly set up.
+ else
{
- // M_SetupChoosePlayer didn't call us directly, that means we've been properly set up.
char_scroll = 0; // finish scrolling the menu
M_DrawSetupChoosePlayerMenu(); // draw the finally selected character one last time for the fadeout
- }
- M_ClearMenus(true);
-
- skin1 = strtok(description[choice].skinname, "&");
- skin2 = strtok(NULL, "&");
-
- if (skin2) {
- // this character has a second skin
- skinnum = R_SkinAvailable(skin1);
- botskin = (UINT8)(R_SkinAvailable(skin2)+1);
- botingame = true;
+ // Is this a hack?
+ charseltimer = 0;
- botcolor = skins[botskin-1].prefcolor;
+ skinnum = description[choice].skinnum[0];
- // undo the strtok
- description[choice].skinname[strlen(skin1)] = '&';
- } else {
- skinnum = R_SkinAvailable(description[choice].skinname);
- botingame = false;
- botskin = 0;
- botcolor = 0;
+ if ((botingame = (description[choice].skinnum[1] != -1))) {
+ // this character has a second skin
+ botskin = (UINT8)(description[choice].skinnum[1]+1);
+ botcolor = skins[description[choice].skinnum[1]].prefcolor;
+ }
+ else
+ botskin = botcolor = 0;
}
+ M_ClearMenus(true);
+
if (startmap != spstage_start)
cursaveslot = 0;
//lastmapsaved = 0;
gamecomplete = false;
- G_DeferedInitNew(ultmode, G_BuildMapName(startmap), (UINT8)skinnum, false, fromlevelselect);
+ G_DeferedInitNew(ultmode, G_BuildMapName(startmap), skinnum, false, fromlevelselect);
COM_BufAddText("dummyconsvar 1\n"); // G_DeferedInitNew doesn't do this
if (levelselect.rows)
@@ -8109,7 +8554,7 @@ static void M_DrawStatsMaps(int location)
exemblem = &extraemblems[i];
if (exemblem->collected)
- V_DrawSmallMappedPatch(292, y, 0, W_CachePatchName(M_GetExtraEmblemPatch(exemblem), PU_CACHE),
+ V_DrawSmallMappedPatch(292, y, 0, W_CachePatchName(M_GetExtraEmblemPatch(exemblem, false), PU_CACHE),
R_GetTranslationColormap(TC_DEFAULT, M_GetExtraEmblemColor(exemblem), GTC_CACHE));
else
V_DrawSmallScaledPatch(292, y, 0, W_CachePatchName("NEEDIT", PU_CACHE));
@@ -8254,16 +8699,27 @@ static void M_HandleLevelStats(INT32 choice)
// Drawing function for Time Attack
void M_DrawTimeAttackMenu(void)
{
- INT32 i, x, y, cursory = 0;
+ INT32 i, x, y, empatx, empaty, cursory = 0;
UINT16 dispstatus;
- patch_t *PictureOfUrFace;
+ patch_t *PictureOfUrFace; // my WHAT
+ patch_t *empatch;
+
+ M_SetMenuCurBackground("RECATKBG");
+
+ curbgxspeed = 0;
+ curbgyspeed = 18;
- M_ChangeMenuMusic("_inter", true); // Eww, but needed for when user hits escape during demo playback
+ M_ChangeMenuMusic("_recat", true); // Eww, but needed for when user hits escape during demo playback
if (curbgcolor >= 0)
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, curbgcolor);
else if (!curbghide || !titlemapinaction)
+ {
F_SkyScroll(curbgxspeed, curbgyspeed, curbgname);
+ // Draw and animate foreground
+ if (!strncmp("RECATKBG", curbgname, 8))
+ M_DrawRecordAttackForeground();
+ }
if (curfadevalue)
V_DrawFadeScreen(0xFF00, curfadevalue);
@@ -8314,10 +8770,10 @@ void M_DrawTimeAttackMenu(void)
// Character face!
{
- if (skins[cv_chooseskin.value-1].sprites[SPR2_XTRA].numframes >= 2)
+ if (skins[cv_chooseskin.value-1].sprites[SPR2_XTRA].numframes >= XTRA_CHARSEL+1)
{
spritedef_t *sprdef = &skins[cv_chooseskin.value-1].sprites[SPR2_XTRA];
- spriteframe_t *sprframe = &sprdef->spriteframes[1];
+ spriteframe_t *sprframe = &sprdef->spriteframes[XTRA_CHARSEL];
PictureOfUrFace = W_CachePatchNum(sprframe->lumppat[0], PU_CACHE);
}
else
@@ -8337,6 +8793,11 @@ void M_DrawTimeAttackMenu(void)
patch_t *PictureOfLevel;
lumpnum_t lumpnum;
char beststr[40];
+ char reqscore[40], reqtime[40], reqrings[40];
+
+ strcpy(reqscore, "\0");
+ strcpy(reqtime, "\0");
+ strcpy(reqrings, "\0");
M_DrawLevelPlatterHeader(32-lsheadingheight/2, cv_nextmap.string, true, false);
@@ -8348,17 +8809,72 @@ void M_DrawTimeAttackMenu(void)
else
PictureOfLevel = W_CachePatchName("BLANKLVL", PU_CACHE);
- V_DrawSmallScaledPatch(208, 32+lsheadingheight, 0, PictureOfLevel);
+ y = 32+lsheadingheight;
+ V_DrawSmallScaledPatch(216, y, 0, PictureOfLevel);
+
+
+ if (currentMenu == &SP_TimeAttackDef)
+ {
+ if (itemOn == talevel)
+ {
+ /* Draw arrows !! */
+ y = y + 25 - 4;
+ V_DrawCharacter(216 - 10 - (skullAnimCounter/5), y,
+ '\x1C' | V_YELLOWMAP, false);
+ V_DrawCharacter(216 + 80 + 2 + (skullAnimCounter/5), y,
+ '\x1D' | V_YELLOWMAP, false);
+ }
+ // Draw press ESC to exit string on main record attack menu
+ V_DrawString(104-72, 180, V_TRANSLUCENT, M_GetText("Press ESC to exit"));
+ }
- V_DrawString(104 - 72, 32+lsheadingheight/2, 0, "* LEVEL RECORDS *");
+ em = M_GetLevelEmblems(cv_nextmap.value);
+ // Draw record emblems.
+ while (em)
+ {
+ switch (em->type)
+ {
+ case ET_SCORE:
+ yHeight = 33;
+ sprintf(reqscore, "(%u)", em->var);
+ break;
+ case ET_TIME:
+ yHeight = 53;
+ sprintf(reqtime, "(%i:%02i.%02i)", G_TicsToMinutes((tic_t)em->var, true),
+ G_TicsToSeconds((tic_t)em->var),
+ G_TicsToCentiseconds((tic_t)em->var));
+ break;
+ case ET_RINGS:
+ yHeight = 73;
+ sprintf(reqrings, "(%u)", em->var);
+ break;
+ default:
+ goto skipThisOne;
+ }
+
+ empatch = W_CachePatchName(M_GetEmblemPatch(em, true), PU_CACHE);
+
+ empatx = SHORT(empatch->leftoffset)/2;
+ empaty = SHORT(empatch->topoffset)/2;
+
+ if (em->collected)
+ V_DrawSmallMappedPatch(104+76+empatx, yHeight+lsheadingheight/2+empaty, 0, empatch,
+ R_GetTranslationColormap(TC_DEFAULT, M_GetEmblemColor(em), GTC_CACHE));
+ else
+ V_DrawSmallScaledPatch(104+76, yHeight+lsheadingheight/2, 0, W_CachePatchName("NEEDITL", PU_CACHE));
+
+ skipThisOne:
+ em = M_GetLevelEmblems(-1);
+ }
if (!mainrecords[cv_nextmap.value-1] || !mainrecords[cv_nextmap.value-1]->score)
sprintf(beststr, "(none)");
else
sprintf(beststr, "%u", mainrecords[cv_nextmap.value-1]->score);
- V_DrawString(104-72, 48+lsheadingheight/2, V_YELLOWMAP, "SCORE:");
- V_DrawRightAlignedString(104+72, 48+lsheadingheight/2, V_ALLOWLOWERCASE, beststr);
+ V_DrawString(104-72, 33+lsheadingheight/2, V_YELLOWMAP, "SCORE:");
+ V_DrawRightAlignedString(104+64, 33+lsheadingheight/2, V_ALLOWLOWERCASE, beststr);
+ V_DrawRightAlignedString(104+72, 43+lsheadingheight/2, V_ALLOWLOWERCASE, reqscore);
if (!mainrecords[cv_nextmap.value-1] || !mainrecords[cv_nextmap.value-1]->time)
sprintf(beststr, "(none)");
@@ -8367,39 +8883,23 @@ void M_DrawTimeAttackMenu(void)
G_TicsToSeconds(mainrecords[cv_nextmap.value-1]->time),
G_TicsToCentiseconds(mainrecords[cv_nextmap.value-1]->time));
- V_DrawString(104-72, 58+lsheadingheight/2, V_YELLOWMAP, "TIME:");
- V_DrawRightAlignedString(104+72, 58+lsheadingheight/2, V_ALLOWLOWERCASE, beststr);
+ V_DrawString(104-72, 53+lsheadingheight/2, V_YELLOWMAP, "TIME:");
+ V_DrawRightAlignedString(104+64, 53+lsheadingheight/2, V_ALLOWLOWERCASE, beststr);
+ V_DrawRightAlignedString(104+72, 63+lsheadingheight/2, V_ALLOWLOWERCASE, reqtime);
if (!mainrecords[cv_nextmap.value-1] || !mainrecords[cv_nextmap.value-1]->rings)
sprintf(beststr, "(none)");
else
sprintf(beststr, "%hu", mainrecords[cv_nextmap.value-1]->rings);
- V_DrawString(104-72, 68+lsheadingheight/2, V_YELLOWMAP, "RINGS:");
- V_DrawRightAlignedString(104+72, 68+lsheadingheight/2, V_ALLOWLOWERCASE, beststr);
+ V_DrawString(104-72, 73+lsheadingheight/2, V_YELLOWMAP, "RINGS:");
- // Draw record emblems.
- em = M_GetLevelEmblems(cv_nextmap.value);
- while (em)
- {
- switch (em->type)
- {
- case ET_SCORE: yHeight = 48; break;
- case ET_TIME: yHeight = 58; break;
- case ET_RINGS: yHeight = 68; break;
- default:
- goto skipThisOne;
- }
-
- if (em->collected)
- V_DrawSmallMappedPatch(104+76, yHeight+lsheadingheight/2, 0, W_CachePatchName(M_GetEmblemPatch(em), PU_CACHE),
- R_GetTranslationColormap(TC_DEFAULT, M_GetEmblemColor(em), GTC_CACHE));
- else
- V_DrawSmallScaledPatch(104+76, yHeight+lsheadingheight/2, 0, W_CachePatchName("NEEDIT", PU_CACHE));
+ if (!mainrecords[cv_nextmap.value-1] || !mainrecords[cv_nextmap.value-1]->gotperfect)
+ V_DrawRightAlignedString(104+64, 73+lsheadingheight/2, V_ALLOWLOWERCASE, beststr);
+ else
+ V_DrawRightAlignedString(104+64, 73+lsheadingheight/2, V_ALLOWLOWERCASE|V_YELLOWMAP, beststr);
- skipThisOne:
- em = M_GetLevelEmblems(-1);
- }
+ V_DrawRightAlignedString(104+72, 83+lsheadingheight/2, V_ALLOWLOWERCASE, reqrings);
}
// ALWAYS DRAW level and skin even when not on this menu!
@@ -8418,6 +8918,39 @@ void M_DrawTimeAttackMenu(void)
}
}
+static void M_HandleTimeAttackLevelSelect(INT32 choice)
+{
+ switch (choice)
+ {
+ case KEY_DOWNARROW:
+ M_NextOpt();
+ break;
+ case KEY_UPARROW:
+ M_PrevOpt();
+ break;
+
+ case KEY_LEFTARROW:
+ CV_AddValue(&cv_nextmap, -1);
+ break;
+ case KEY_RIGHTARROW:
+ CV_AddValue(&cv_nextmap, 1);
+ break;
+
+ case KEY_ENTER:
+ M_TimeAttackLevelSelect(0);
+ break;
+
+ case KEY_ESCAPE:
+ noFurtherInput = true;
+ M_GoBack(0);
+ return;
+
+ default:
+ return;
+ }
+ S_StartSound(NULL, sfx_menu1);
+}
+
static void M_TimeAttackLevelSelect(INT32 choice)
{
(void)choice;
@@ -8458,12 +8991,11 @@ void M_DrawNightsAttackMenu(void)
INT32 i, x, y, cursory = 0;
UINT16 dispstatus;
- M_ChangeMenuMusic("_inter", true); // Eww, but needed for when user hits escape during demo playback
+ M_SetMenuCurBackground("NTSATKBG");
- if (curbgcolor >= 0)
- V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, curbgcolor);
- else if (!curbghide || !titlemapinaction)
- F_SkyScroll(curbgxspeed, curbgyspeed, curbgname);
+ M_ChangeMenuMusic("_nitat", true); // Eww, but needed for when user hits escape during demo playback
+
+ M_DrawNightsAttackBackground();
if (curfadevalue)
V_DrawFadeScreen(0xFF00, curfadevalue);
@@ -8521,7 +9053,7 @@ void M_DrawNightsAttackMenu(void)
lumpnum_t lumpnum;
char beststr[40];
- UINT8 bestoverall = G_GetBestNightsGrade(cv_nextmap.value, 0);
+ //UINT8 bestoverall = G_GetBestNightsGrade(cv_nextmap.value, 0);
UINT8 bestgrade = G_GetBestNightsGrade(cv_nextmap.value, cv_dummymares.value);
UINT32 bestscore = G_GetBestNightsScore(cv_nextmap.value, cv_dummymares.value);
tic_t besttime = G_GetBestNightsTime(cv_nextmap.value, cv_dummymares.value);
@@ -8538,10 +9070,10 @@ void M_DrawNightsAttackMenu(void)
V_DrawSmallScaledPatch(208, 32+lsheadingheight, 0, PictureOfLevel);
- V_DrawString(104 - 72, 32+lsheadingheight/2, 0, "* LEVEL RECORDS *");
-
- if (P_HasGrades(cv_nextmap.value, 0))
- V_DrawScaledPatch(235, 135, 0, ngradeletters[bestoverall]);
+ // Super Sonic
+ M_DrawNightsAttackSuperSonic();
+ //if (P_HasGrades(cv_nextmap.value, 0))
+ // V_DrawScaledPatch(235 - (SHORT((ngradeletters[bestoverall])->width)*3)/2, 135, 0, ngradeletters[bestoverall]);
if (P_HasGrades(cv_nextmap.value, cv_dummymares.value))
{//make bigger again
@@ -8583,10 +9115,10 @@ void M_DrawNightsAttackMenu(void)
}
if (em->collected)
- V_DrawSmallMappedPatch(104+76, yHeight+lsheadingheight/2, 0, W_CachePatchName(M_GetEmblemPatch(em), PU_CACHE),
+ V_DrawSmallMappedPatch(104+38, yHeight+lsheadingheight/2, 0, W_CachePatchName(M_GetEmblemPatch(em, false), PU_CACHE),
R_GetTranslationColormap(TC_DEFAULT, M_GetEmblemColor(em), GTC_CACHE));
else
- V_DrawSmallScaledPatch(104+76, yHeight+lsheadingheight/2, 0, W_CachePatchName("NEEDIT", PU_CACHE));
+ V_DrawSmallScaledPatch(104+38, yHeight+lsheadingheight/2, 0, W_CachePatchName("NEEDIT", PU_CACHE));
skipThisOne:
em = M_GetLevelEmblems(-1);
@@ -8594,6 +9126,10 @@ void M_DrawNightsAttackMenu(void)
}
}
+ // Draw press ESC to exit string on main nights attack menu
+ if (currentMenu == &SP_NightsAttackDef)
+ V_DrawString(104-72, 180, V_TRANSLUCENT, M_GetText("Press ESC to exit"));
+
// ALWAYS DRAW level even when not on this menu!
if (currentMenu != &SP_NightsAttackDef)
V_DrawString(SP_NightsAttackDef.x, SP_NightsAttackDef.y + SP_TimeAttackMenu[nalevel].alphaKey, V_TRANSLUCENT, SP_NightsAttackMenu[nalevel].text);
@@ -8622,6 +9158,9 @@ static void M_NightsAttack(INT32 choice)
// This is really just to make sure Sonic is the played character, just in case
M_PatchSkinNameTable();
+ ntssupersonic[0] = W_CachePatchName("NTSSONC1", PU_CACHE);
+ ntssupersonic[1] = W_CachePatchName("NTSSONC2", PU_CACHE);
+
G_SetGamestate(GS_TIMEATTACK); // do this before M_SetupNextMenu so that menu meta state knows that we're switching
titlemapinaction = TITLEMAP_OFF; // Nope don't give us HOMs please
M_SetupNextMenu(&SP_NightsAttackDef);
@@ -9404,6 +9943,12 @@ static void M_ServerOptions(INT32 choice)
}
#endif
+ /* Disable fading because of different menu head. */
+ if (currentMenu == &OP_MainDef)/* from Options menu */
+ OP_ServerOptionsDef.menuid = MN_OP_MAIN + ( MN_OP_SERVER << 6 );
+ else/* from Multiplayer menu */
+ OP_ServerOptionsDef.menuid = MN_MP_MAIN + ( MN_MP_SERVER_OPTIONS << 6 );
+
OP_ServerOptionsDef.prevMenu = currentMenu;
M_SetupNextMenu(&OP_ServerOptionsDef);
}
@@ -9468,6 +10013,8 @@ static void M_ConnectIP(INT32 choice)
return;
}
+ M_ClearMenus(true);
+
COM_BufAddText(va("connect \"%s\"\n", setupm_ip));
// A little "please wait" message.
@@ -9499,7 +10046,6 @@ static void M_HandleConnectIP(INT32 choice)
case KEY_ENTER:
S_StartSound(NULL,sfx_menu1); // Tails
- M_ClearMenus(true);
M_ConnectIP(1);
break;
@@ -9549,6 +10095,7 @@ static void M_HandleConnectIP(INT32 choice)
if (exitmenu)
{
+ currentMenu->lastOn = itemOn;
if (currentMenu->prevMenu)
M_SetupNextMenu (currentMenu->prevMenu);
else
@@ -10053,7 +10600,7 @@ static void M_DrawJoystick(void)
compareval = cv_usejoystick.value;
#else
compareval2 = cv_usejoystick2.value;
- compareval = cv_usejoystick.value
+ compareval = cv_usejoystick.value;
#endif
if ((setupcontrols_secondaryplayer && (i == compareval2))
diff --git a/src/m_menu.h b/src/m_menu.h
index 05962d2b19072eda900642223db6f042f7790c8e..51c734a43c8a6199c37857a622c69c2a567113f7 100644
--- a/src/m_menu.h
+++ b/src/m_menu.h
@@ -18,6 +18,7 @@
#include "d_event.h"
#include "command.h"
#include "r_things.h" // for SKINNAMESIZE
+#include "f_finale.h" // for ttmode_enum
//
// MENUS
@@ -63,6 +64,7 @@ typedef enum
MN_MP_CONNECT,
MN_MP_ROOM,
MN_MP_PLAYERSETUP, // MP_PlayerSetupDef shared with SPLITSCREEN if #defined NONET
+ MN_MP_SERVER_OPTIONS,
// Options
MN_OP_MAIN,
@@ -103,6 +105,7 @@ typedef enum
MN_SR_LEVELSELECT,
MN_SR_UNLOCKCHECKLIST,
MN_SR_EMBLEMHINT,
+ MN_SR_PLAYER,
// Addons (Part of MISC, but let's make it our own)
MN_AD_MAIN,
@@ -126,19 +129,27 @@ typedef enum
typedef struct
{
char bgname[8]; // name for background gfx lump; lays over titlemap if this is set
- SINT8 hidetitlepics; // hide title gfx per menu; -1 means undefined, inherits global setting
+ SINT8 fadestrength; // darken background when displaying this menu, strength 0-31 or -1 for undefined
+ INT32 bgcolor; // fill color, overrides bg name. -1 means follow bg name rules.
INT32 titlescrollxspeed; // background gfx scroll per menu; inherits global setting
INT32 titlescrollyspeed; // y scroll
- INT32 bgcolor; // fill color, overrides bg name. -1 means follow bg name rules.
boolean bghide; // for titlemaps, hide the background.
+ SINT8 hidetitlepics; // hide title gfx per menu; -1 means undefined, inherits global setting
+ ttmode_enum ttmode; // title wing animation mode; default TTMODE_OLD
+ UINT8 ttscale; // scale of title wing gfx (FRACUNIT / ttscale); -1 means undefined, inherits global setting
+ char ttname[9]; // lump name of title wing gfx. If name length is <= 6, engine will attempt to load numbered frames (TTNAMExx)
+ INT16 ttx; // X position of title wing
+ INT16 tty; // Y position of title wing
+ INT16 ttloop; // # frame to loop; -1 means dont loop
+ UINT16 tttics; // # of tics per frame
+
char musname[7]; ///< Music track to play. "" for no music.
UINT16 mustrack; ///< Subsong to play. Only really relevant for music modules and specific formats supported by GME. 0 to ignore.
boolean muslooping; ///< Loop the music
boolean musstop; ///< Don't play any music
boolean musignore; ///< Let the current music keep playing
- SINT8 fadestrength; // darken background when displaying this menu, strength 0-31 or -1 for undefined
boolean enterbubble; // run all entrance line execs after common ancestor and up to child. If false, only run the child's exec
boolean exitbubble; // run all exit line execs from child and up to before common ancestor. If false, only run the child's exec
INT32 entertag; // line exec to run on menu enter, if titlemap
@@ -156,7 +167,7 @@ UINT8 M_GetYoungestChildMenu(void);
void M_ChangeMenuMusic(const char *defaultmusname, boolean defaultmuslooping);
void M_SetMenuCurBackground(const char *defaultname);
void M_SetMenuCurFadeValue(UINT8 defaultvalue);
-void M_SetMenuCurHideTitlePics(void);
+void M_SetMenuCurTitlePics(void);
// Called by main loop,
// saves config file and calls I_Quit when user exits.
@@ -323,9 +334,18 @@ typedef struct
char notes[441];
char picname[8];
char skinname[SKINNAMESIZE*2+2]; // skin&skin\0
- patch_t *pic;
+ patch_t *charpic;
UINT8 prev;
UINT8 next;
+
+ // new character select
+ char displayname[SKINNAMESIZE+1];
+ SINT8 skinnum[2];
+ UINT8 oppositecolor;
+ char nametag[8];
+ patch_t *namepic;
+ UINT8 tagtextcolor;
+ UINT8 tagoutlinecolor;
} description_t;
// level select platter
@@ -374,6 +394,7 @@ typedef struct
extern description_t description[MAXSKINS];
+extern consvar_t cv_showfocuslost;
extern consvar_t cv_newgametype, cv_nextmap, cv_chooseskin, cv_serversort;
extern CV_PossibleValue_t gametype_cons_t[];
diff --git a/src/m_misc.c b/src/m_misc.c
index aaaf30d67ff4263967f693f8126ff6b72b1b6f8c..f7d5cf9613b17ff00e5390f4a50710193470707f 100644
--- a/src/m_misc.c
+++ b/src/m_misc.c
@@ -197,7 +197,7 @@ INT32 M_MapNumber(char first, char second)
// ==========================================================================
// some libcs has no access function, make our own
-#if defined (_WIN32_WCE)
+#if 0
int access(const char *path, int amode)
{
int accesshandle = -1;
diff --git a/src/p_enemy.c b/src/p_enemy.c
index 000b5cbfb009b5a9e4beaecc308bb882d1a56f83..4c256e9edf7024ada09650f5d97a6fc52f3b84d3 100644
--- a/src/p_enemy.c
+++ b/src/p_enemy.c
@@ -129,6 +129,7 @@ void A_FishJump(mobj_t *actor);
void A_ThrownRing(mobj_t *actor);
void A_SetSolidSteam(mobj_t *actor);
void A_UnsetSolidSteam(mobj_t *actor);
+void A_SignSpin(mobj_t *actor);
void A_SignPlayer(mobj_t *actor);
void A_OverlayThink(mobj_t *actor);
void A_JetChase(mobj_t *actor);
@@ -298,6 +299,14 @@ void A_SnapperThinker(mobj_t *actor);
void A_SaloonDoorSpawn(mobj_t *actor);
void A_MinecartSparkThink(mobj_t *actor);
void A_ModuloToState(mobj_t *actor);
+void A_LavafallRocks(mobj_t *actor);
+void A_LavafallLava(mobj_t *actor);
+void A_FallingLavaCheck(mobj_t *actor);
+void A_FireShrink(mobj_t *actor);
+void A_SpawnPterabytes(mobj_t *actor);
+void A_PterabyteHover(mobj_t *actor);
+void A_RolloutSpawn(mobj_t *actor);
+void A_RolloutRock(mobj_t *actor);
//for p_enemy.c
@@ -2019,6 +2028,7 @@ void A_CrushstaceanWalk(mobj_t *actor)
|| (actor->reactiontime-- <= 0))
{
actor->flags2 ^= MF2_AMBUSH;
+ P_SetTarget(&actor->target, NULL);
P_SetMobjState(actor, locvar2);
actor->reactiontime = actor->info->reactiontime;
}
@@ -2079,7 +2089,7 @@ void A_CrushclawAim(mobj_t *actor)
return; // there is only one step and it is crab
}
- if (crab->target || P_LookForPlayers(crab, true, false, 600*crab->scale))
+ if (crab->target || P_LookForPlayers(crab, true, false, actor->info->speed*crab->scale))
ang = R_PointToAngle2(crab->x, crab->y, crab->target->x, crab->target->y);
else
ang = crab->angle + ((crab->flags2 & MF2_AMBUSH) ? ANGLE_90 : ANGLE_270);
@@ -2162,7 +2172,7 @@ void A_CrushclawLaunch(mobj_t *actor)
UINT8 i = 0;
for (i = 0; (i < CSEGS); i++)
{
- mobj_t *newchain = P_SpawnMobjFromMobj(actor, 0, 0, 0, actor->info->raisestate);
+ mobj_t *newchain = P_SpawnMobjFromMobj(actor, 0, 0, 0, (mobjtype_t)actor->info->raisestate);
P_SetTarget(&prevchain->target, newchain);
prevchain = newchain;
}
@@ -3921,11 +3931,15 @@ void A_BossDeath(mobj_t *mo)
{
// Touching the egg trap button calls P_DoPlayerExit, which calls P_RestoreMusic.
// So just park ourselves in the mapmus variables.
- boolean changed = strnicmp(mapheaderinfo[gamemap-1]->musname, mapmusname, 7);
- strncpy(mapmusname, mapheaderinfo[gamemap-1]->muspostbossname, 7);
- mapmusname[6] = 0;
- mapmusflags = (mapheaderinfo[gamemap-1]->muspostbosstrack & MUSIC_TRACKMASK) | MUSIC_RELOADRESET;
- mapmusposition = mapheaderinfo[gamemap-1]->muspostbosspos;
+ // But don't change the mapmus variables if they were modified from their level header values (e.g., TUNES).
+ boolean changed = strnicmp(mapheaderinfo[gamemap-1]->musname, S_MusicName(), 7);
+ if (!strnicmp(mapheaderinfo[gamemap-1]->musname, mapmusname, 7))
+ {
+ strncpy(mapmusname, mapheaderinfo[gamemap-1]->muspostbossname, 7);
+ mapmusname[6] = 0;
+ mapmusflags = (mapheaderinfo[gamemap-1]->muspostbosstrack & MUSIC_TRACKMASK) | MUSIC_RELOADRESET;
+ mapmusposition = mapheaderinfo[gamemap-1]->muspostbosspos;
+ }
// don't change if we're in another tune
// but in case we're in jingle, use our parked mapmus variables so the correct track restores
@@ -4750,7 +4764,7 @@ void A_DropMine(mobj_t *actor)
// Description: Makes the stupid harmless fish in Greenflower Zone jump.
//
// var1 = Jump strength (in FRACBITS), if specified. Otherwise, uses the angle value.
-// var2 = unused
+// var2 = Trail object to spawn, if desired.
//
void A_FishJump(mobj_t *actor)
{
@@ -4763,8 +4777,17 @@ void A_FishJump(mobj_t *actor)
if (locvar2)
{
- fixed_t rad = actor->radius>>FRACBITS;
- P_SpawnMobjFromMobj(actor, P_RandomRange(rad, -rad)<<FRACBITS, P_RandomRange(rad, -rad)<<FRACBITS, 0, (mobjtype_t)locvar2);
+ UINT8 i;
+ // Don't spawn trail unless a player is nearby.
+ for (i = 0; i < MAXPLAYERS; ++i)
+ if (playeringame[i] && players[i].mo
+ && P_AproxDistance(actor->x - players[i].mo->x, actor->y - players[i].mo->y) < (actor->info->speed))
+ break; // Stop looking.
+ if (i < MAXPLAYERS)
+ {
+ fixed_t rad = actor->radius>>FRACBITS;
+ P_SpawnMobjFromMobj(actor, P_RandomRange(rad, -rad)<<FRACBITS, P_RandomRange(rad, -rad)<<FRACBITS, 0, (mobjtype_t)locvar2);
+ }
}
if ((actor->z <= actor->floorz) || (actor->z <= actor->watertop - FixedMul((64 << FRACBITS), actor->scale)))
@@ -4997,59 +5020,186 @@ void A_UnsetSolidSteam(mobj_t *actor)
actor->flags |= MF_NOCLIP;
}
+// Function: A_SignSpin
+//
+// Description: Spins a signpost until it hits the ground and reaches its mapthing's angle.
+//
+// var1 = degrees to rotate object (must be positive, because I'm lazy)
+// var2 = unused
+//
+void A_SignSpin(mobj_t *actor)
+{
+ INT32 locvar1 = var1;
+ INT32 locvar2 = var2;
+ INT16 i;
+ angle_t rotateangle = FixedAngle(locvar1 << FRACBITS);
+
+#ifdef HAVE_BLUA
+ if (LUA_CallAction("A_SignSpin", actor))
+ return;
+#endif
+
+ if (P_IsObjectOnGround(actor) && P_MobjFlip(actor) * actor->momz <= 0)
+ {
+ if (actor->spawnpoint)
+ {
+ angle_t mapangle = FixedAngle(actor->spawnpoint->angle << FRACBITS);
+ angle_t diff = mapangle - actor->angle;
+ if (diff < ANG2)
+ {
+ actor->angle = mapangle;
+ P_SetMobjState(actor, actor->info->deathstate);
+ return;
+ }
+ if ((statenum_t)(actor->state-states) != actor->info->painstate)
+ P_SetMobjState(actor, actor->info->painstate);
+ actor->movedir = min((mapangle - actor->angle) >> 2, actor->movedir);
+ }
+ else // no mapthing? just finish in your current angle
+ {
+ P_SetMobjState(actor, locvar2);
+ return;
+ }
+ }
+ else
+ {
+ actor->movedir = rotateangle;
+ }
+ actor->angle += actor->movedir;
+ if (actor->tracer == NULL || P_MobjWasRemoved(actor->tracer)) return;
+ for (i = -1; i < 2; i += 2)
+ {
+ P_SpawnMobjFromMobj(actor,
+ P_ReturnThrustX(actor, actor->tracer->angle, i * actor->radius),
+ P_ReturnThrustY(actor, actor->tracer->angle, i * actor->radius),
+ (actor->eflags & MFE_VERTICALFLIP) ? 0 : actor->height,
+ actor->info->painchance)->destscale >>= 1;
+ }
+}
+
// Function: A_SignPlayer
//
// Description: Changes the state of a level end sign to reflect the player that hit it.
+// Also used to display Eggman or the skin roulette whilst spinning.
//
-// var1 = unused
-// var2 = unused
+// var1 = number of skin to display (e.g. 2 = Knuckles; special cases: -1 = target's skin, -2 = skin roulette, -3 = Eggman)
+// var2 = custom sign color, if desired.
//
void A_SignPlayer(mobj_t *actor)
{
+ INT32 locvar1 = var1;
+ INT32 locvar2 = var2;
+ skin_t *skin = NULL;
mobj_t *ov;
- skin_t *skin;
+ UINT8 facecolor, signcolor = (UINT8)locvar2;
+ UINT32 signframe = states[actor->info->raisestate].frame;
+
#ifdef HAVE_BLUA
if (LUA_CallAction("A_SignPlayer", actor))
return;
#endif
- if (!actor->target)
- return;
- if (!actor->target->player)
+ if (actor->tracer == NULL || locvar1 < -3 || locvar1 >= numskins)
return;
- skin = &skins[actor->target->player->skin];
+ // if no face overlay, spawn one
+ if (actor->tracer->tracer == NULL || P_MobjWasRemoved(actor->tracer->tracer))
+ {
+ ov = P_SpawnMobj(actor->x, actor->y, actor->z, MT_OVERLAY);
+ P_SetTarget(&ov->target, actor->tracer);
+ P_SetTarget(&actor->tracer->tracer, ov);
+ }
+ else
+ ov = actor->tracer->tracer;
- if ((actor->target->player->skincolor == skin->prefcolor) && (skin->prefoppositecolor)) // Set it as the skin's preferred oppositecolor?
+ if (locvar1 == -1) // set to target's skin
{
- actor->color = skin->prefoppositecolor;
- /*
- If you're here from the comment above Color_Opposite,
- the following line is the one which is dependent on the
- array being symmetrical. It gets the opposite of the
- opposite of your desired colour just so it can get the
- brightness frame for the End Sign. It's not a great
- design choice, but it's constant time array access and
- the idea that the colours should be OPPOSITES is kind
- of in the name. If you have a better idea, feel free
- to let me know. ~toast 2016/07/20
- */
- actor->frame += (15 - Color_Opposite[Color_Opposite[skin->prefoppositecolor - 1][0] - 1][1]);
+ if (!actor->target)
+ return;
+
+ if (!actor->target->player)
+ return;
+
+ skin = &skins[actor->target->player->skin];
+ facecolor = actor->target->player->skincolor;
+
+ if (signcolor)
+ ;
+ else if ((actor->target->player->skincolor == skin->prefcolor) && (skin->prefoppositecolor)) // Set it as the skin's preferred oppositecolor?
+ {
+ signcolor = skin->prefoppositecolor;
+ /*
+ If you're here from the comment above Color_Opposite,
+ the following line is the one which is dependent on the
+ array being symmetrical. It gets the opposite of the
+ opposite of your desired colour just so it can get the
+ brightness frame for the End Sign. It's not a great
+ design choice, but it's constant time array access and
+ the idea that the colours should be OPPOSITES is kind
+ of in the name. If you have a better idea, feel free
+ to let me know. ~toast 2016/07/20
+ */
+ signframe += (15 - Color_Opposite[Color_Opposite[skin->prefoppositecolor - 1][0] - 1][1]);
+ }
+ else if (actor->target->player->skincolor) // Set the sign to be an appropriate background color for this player's skincolor.
+ {
+ signcolor = Color_Opposite[actor->target->player->skincolor - 1][0];
+ signframe += (15 - Color_Opposite[actor->target->player->skincolor - 1][1]);
+ }
+ else
+ signcolor = SKINCOLOR_NONE;
}
- else if (actor->target->player->skincolor) // Set the sign to be an appropriate background color for this player's skincolor.
+ else if (locvar1 != -3) // set to a defined skin
{
- actor->color = Color_Opposite[actor->target->player->skincolor - 1][0];
- actor->frame += (15 - Color_Opposite[actor->target->player->skincolor - 1][1]);
+ // I turned this function into a fucking mess. I'm so sorry. -Lach
+ if (locvar1 == -2) // next skin
+ {
+ if (ov->skin == NULL) // pick a random skin to start with!
+ skin = &skins[P_RandomKey(numskins)];
+ else // otherwise, advance 1 skin
+ {
+ UINT8 skinnum = (skin_t*)ov->skin-skins;
+ player_t *player = actor->target ? actor->target->player : NULL;
+ while ((skinnum = (skinnum + 1) % numskins) && (player ? !R_SkinUsable(player-players, skinnum) : skins[skinnum].availability > 0));
+ skin = &skins[skinnum];
+ }
+ }
+ else // specific skin
+ {
+ skin = &skins[locvar1];
+ }
+
+ facecolor = skin->prefcolor;
+ if (signcolor)
+ ;
+ else if (skin->prefoppositecolor)
+ {
+ signcolor = skin->prefoppositecolor;
+ }
+ else
+ {
+ signcolor = Color_Opposite[facecolor - 1][0];
+ }
+ signframe += (15 - Color_Opposite[Color_Opposite[signcolor - 1][0] - 1][1]);
}
- if (skin->sprites[SPR2_SIGN].numframes)
+ if (skin != NULL && skin->sprites[SPR2_SIGN].numframes) // player face
{
- // spawn an overlay of the player's face.
- ov = P_SpawnMobj(actor->x, actor->y, actor->z, MT_OVERLAY);
- P_SetTarget(&ov->target, actor);
- ov->color = actor->target->player->skincolor;
+ ov->color = facecolor;
ov->skin = skin;
P_SetMobjState(ov, actor->info->seestate); // S_PLAY_SIGN
+ actor->tracer->color = signcolor;
+ actor->tracer->frame = signframe;
+ }
+ else // Eggman face
+ {
+ ov->color = SKINCOLOR_NONE;
+ P_SetMobjState(ov, actor->info->meleestate); // S_EGGMANSIGN
+ if (signcolor)
+ actor->tracer->color = signcolor;
+ else
+ actor->tracer->color = signcolor = SKINCOLOR_CARBON;
+ actor->tracer->frame = signframe += (15 - Color_Opposite[Color_Opposite[signcolor - 1][0] - 1][1]);
}
}
@@ -5097,7 +5247,7 @@ void A_OverlayThink(mobj_t *actor)
actor->z = actor->target->z + actor->target->height - mobjinfo[actor->type].height - ((var2>>16) ? -1 : 1)*(var2&0xFFFF)*FRACUNIT;
else
actor->z = actor->target->z + ((var2>>16) ? -1 : 1)*(var2&0xFFFF)*FRACUNIT;
- actor->angle = actor->target->angle;
+ actor->angle = actor->target->angle + actor->movedir;
actor->eflags = actor->target->eflags;
actor->momx = actor->target->momx;
@@ -5343,20 +5493,22 @@ static mobj_t *minus;
static boolean PIT_MinusCarry(mobj_t *thing)
{
+ if (minus->tracer)
+ return true;
+
if (minus->type == thing->type)
return true;
- if (!(thing->flags & MF_SHOOTABLE) || !(thing->flags & MF_ENEMY))
+ if (!(thing->flags & (MF_PUSHABLE|MF_ENEMY)))
return true;
- if (P_AproxDistance(minus->x - thing->x, minus->y - thing->y) >= minus->radius * 3)
+ if (P_AproxDistance(minus->x - thing->x, minus->y - thing->y) >= minus->radius*3)
return true;
if (abs(thing->z - minus->z) > minus->height)
return true;
P_SetTarget(&minus->tracer, thing);
- minus->tracer->flags &= ~MF_PUSHABLE;
return true;
}
@@ -5420,6 +5572,9 @@ void A_MinusDigging(mobj_t *actor)
A_Chase(actor);
// Carry over shit, maybe
+ if (P_MobjWasRemoved(actor->tracer) || !actor->tracer->health)
+ P_SetTarget(&actor->tracer, NULL);
+
if (!actor->tracer)
{
fixed_t radius = 3*actor->radius;
@@ -5469,7 +5624,6 @@ void A_MinusPopup(mobj_t *actor)
else
actor->momz = 10*FRACUNIT;
- actor->flags |= MF_SPECIAL|MF_SHOOTABLE;
S_StartSound(actor, sfx_s3k82);
for (i = 1; i <= num; i++)
{
@@ -5482,6 +5636,7 @@ void A_MinusPopup(mobj_t *actor)
if (actor->tracer)
P_DamageMobj(actor->tracer, actor, actor, 1, 0);
+ actor->flags = (actor->flags & ~MF_NOCLIPTHING)|MF_SPECIAL|MF_SHOOTABLE;
}
// Function: A_MinusCheck
@@ -8408,8 +8563,8 @@ void A_ChangeAngleAbsolute(mobj_t *actor)
//
// var1 = sound # to play
// var2:
-// 0 = Play sound without an origin
-// 1 = Play sound using calling object as origin
+// lower 16 bits = If 1, play sound using calling object as origin. If 0, play sound without an origin
+// upper 16 bits = If 1, do not play sound during preticker.
//
void A_PlaySound(mobj_t *actor)
{
@@ -8420,7 +8575,10 @@ void A_PlaySound(mobj_t *actor)
return;
#endif
- S_StartSound(locvar2 ? actor : NULL, locvar1);
+ if (leveltime < 2 && (locvar2 >> 16))
+ return;
+
+ S_StartSound((locvar2 & 65535) ? actor : NULL, locvar1);
}
// Function: A_FindTarget
@@ -8949,10 +9107,11 @@ void A_BossJetFume(mobj_t *actor)
P_SetTarget(&filler->target, actor);
filler->fuse = 59;
P_SetTarget(&actor->tracer, filler);
- filler->destscale = actor->scale/3;
- P_SetScale(filler, filler->destscale);
+ P_SetScale(filler, (filler->destscale = actor->scale/3));
if (actor->eflags & MFE_VERTICALFLIP)
filler->flags2 |= MF2_OBJECTFLIP;
+ filler->color = SKINCOLOR_ICY;
+ filler->colorized = true;
}
else if (locvar1 == 3) // Boss 4 jet flame
{
@@ -12197,7 +12356,7 @@ void A_MineExplode(mobj_t *actor)
#undef dist
if (actor->watertop != INT32_MAX)
- P_SpawnMobj(actor->x, actor->y, actor->watertop, MT_SPLISH);
+ P_SpawnMobj(actor->x, actor->y, actor->watertop, (actor->eflags & MFE_TOUCHLAVA) ? MT_LAVASPLISH : MT_SPLISH);
}
}
@@ -12237,7 +12396,6 @@ void A_ConnectToGround(mobj_t *actor)
mobj_t *work;
fixed_t workz;
fixed_t workh;
- SINT8 dir;
angle_t ang;
INT32 locvar1 = var1;
INT32 locvar2 = var2;
@@ -12251,23 +12409,17 @@ void A_ConnectToGround(mobj_t *actor)
P_AdjustMobjFloorZ_FFloors(actor, actor->subsector->sector, 2);
if (actor->flags2 & MF2_OBJECTFLIP)
- {
- workz = actor->ceilingz - (actor->z + actor->height);
- dir = -1;
- }
+ workz = (actor->z + actor->height) - actor->ceilingz;
else
- {
workz = actor->floorz - actor->z;
- dir = 1;
- }
if (locvar2)
{
workh = FixedMul(mobjinfo[locvar2].height, actor->scale);
if (actor->flags2 & MF2_OBJECTFLIP)
- workz -= workh;
+ workz += workh;
work = P_SpawnMobjFromMobj(actor, 0, 0, workz, locvar2);
- workz += dir*workh;
+ workz += workh;
}
if (!locvar1)
@@ -12276,21 +12428,18 @@ void A_ConnectToGround(mobj_t *actor)
if (!(workh = FixedMul(mobjinfo[locvar1].height, actor->scale)))
return;
- if (actor->flags2 & MF2_OBJECTFLIP)
- workz -= workh;
-
ang = actor->angle + ANGLE_45;
- while (dir*workz < 0)
+ while (workz < 0)
{
work = P_SpawnMobjFromMobj(actor, 0, 0, workz, locvar1);
if (work)
work->angle = ang;
ang += ANGLE_90;
- workz += dir*workh;
+ workz += workh;
}
if (workz != 0)
- actor->z += workz;
+ actor->z += P_MobjFlip(actor)*workz;
}
// Function: A_SpawnParticleRelative
@@ -13455,6 +13604,13 @@ void A_TNTExplode(mobj_t *actor)
if (LUA_CallAction("A_TNTExplode", actor))
return;
#endif
+
+ if (actor->tracer)
+ {
+ P_SetTarget(&actor->tracer->tracer, NULL);
+ P_SetTarget(&actor->tracer, NULL);
+ }
+
P_UnsetThingPosition(actor);
if (sector_list)
{
@@ -13668,8 +13824,6 @@ void A_KillSegments(mobj_t *actor)
static void P_SnapperLegPlace(mobj_t *mo)
{
mobj_t *seg = mo->tracer;
- fixed_t x0 = mo->x;
- fixed_t y0 = mo->y;
angle_t a = mo->angle;
angle_t fa = (a >> ANGLETOFINESHIFT) & FINEMASK;
fixed_t c = FINECOSINE(fa);
@@ -13684,7 +13838,8 @@ static void P_SnapperLegPlace(mobj_t *mo)
fixed_t rad = mo->radius;
INT32 necklen = (32*(mo->info->reactiontime - mo->reactiontime))/mo->info->reactiontime; // Not in FU
- P_TeleportMove(seg, mo->x + FixedMul(c, rad) + necklen*c, mo->y + FixedMul(s, rad) + necklen*s, mo->z + mo->height/3);
+ seg->z = mo->z + ((mo->eflags & MFE_VERTICALFLIP) ? (((mo->height<<1)/3) - seg->height) : mo->height/3);
+ P_TryMove(seg, mo->x + FixedMul(c, rad) + necklen*c, mo->y + FixedMul(s, rad) + necklen*s, true);
seg->angle = a;
// Move as many legs as available.
@@ -13704,13 +13859,14 @@ static void P_SnapperLegPlace(mobj_t *mo)
{
x = c*o2 + s*o1;
y = s*o2 - c*o1;
- P_TryMove(seg, x0 + x, y0 + y, true);
+ seg->z = mo->z + (((mo->eflags & MFE_VERTICALFLIP) ? (mo->height - seg->height) : 0));
+ P_TryMove(seg, mo->x + x, mo->y + y, true);
P_SetMobjState(seg, seg->info->raisestate);
}
else
P_SetMobjState(seg, seg->info->spawnstate);
- seg->angle = R_PointToAngle2(x0, y0, seg->x, seg->y);
+ seg->angle = R_PointToAngle2(mo->x, mo->y, seg->x, seg->y);
seg = seg->tracer;
} while (seg);
@@ -13738,14 +13894,14 @@ void A_SnapperSpawn(mobj_t *actor)
#endif
// It spawns 1 head.
- seg = P_SpawnMobj(actor->x, actor->y, actor->z, headtype);
+ seg = P_SpawnMobjFromMobj(actor, 0, 0, 0, headtype);
P_SetTarget(&ptr->tracer, seg);
ptr = seg;
// It spawns 4 legs which will be handled in the thinker function.
for (i = 1; i <= 4; i++)
{
- seg = P_SpawnMobj(actor->x, actor->y, actor->z, legtype);
+ seg = P_SpawnMobjFromMobj(actor, 0, 0, 0, legtype);
P_SetTarget(&ptr->tracer, seg);
ptr = seg;
@@ -13893,51 +14049,43 @@ void A_SnapperThinker(mobj_t *actor)
//
// Description: Spawns a saloon door.
//
-// var1 = unused
-// var2 = unused
+// var1 = mobjtype for sides
+// var2 = distance sides should be placed apart
//
void A_SaloonDoorSpawn(mobj_t *actor)
{
+ INT32 locvar1 = var1;
+ INT32 locvar2 = var2;
angle_t ang = actor->angle;
angle_t fa = (ang >> ANGLETOFINESHIFT) & FINEMASK;
- fixed_t c = FINECOSINE(fa);
- fixed_t s = FINESINE(fa);
- INT32 d = 48;
- fixed_t x = actor->x;
- fixed_t y = actor->y;
- fixed_t z = actor->z;
+ fixed_t c = FINECOSINE(fa)*locvar2;
+ fixed_t s = FINESINE(fa)*locvar2;
mobj_t *door;
+ mobjflag2_t ambush = (actor->flags & MF2_AMBUSH);
#ifdef HAVE_BLUA
if (LUA_CallAction("A_SaloonDoorSpawn", actor))
return;
#endif
- //Front
- door = P_SpawnMobj(x + c*d, y + s*d, z, MT_SALOONDOOR);
- door->angle = ang + ANGLE_180;
-
- // Origin angle
- door->extravalue1 = AngleFixed(door->angle);
-
- // Angular speed
- door->extravalue2 = 0;
+ if (!locvar1)
+ return;
- // Origin door
- P_SetTarget(&door->tracer, actor);
+ // One door...
+ if (!(door = P_SpawnMobjFromMobj(actor, c, s, 0, locvar1))) return;
+ door->angle = ang + ANGLE_180;
+ door->extravalue1 = AngleFixed(door->angle); // Origin angle
+ door->extravalue2 = 0; // Angular speed
+ P_SetTarget(&door->tracer, actor); // Origin door
+ door->flags2 |= ambush; // Can be opened by normal players?
- //Back
- door = P_SpawnMobj(x - c*d, y - s*d, z, MT_SALOONDOOR);
+ // ...two door!
+ if (!(door = P_SpawnMobjFromMobj(actor, -c, -s, 0, locvar1))) return;
door->angle = ang;
-
- // Origin angle
- door->extravalue1 = AngleFixed(door->angle);
-
- // Angular speed
- door->extravalue2 = 0;
-
- // Origin door
- P_SetTarget(&door->tracer, actor);
+ door->extravalue1 = AngleFixed(door->angle); // Origin angle
+ door->extravalue2 = 0; // Angular speed
+ P_SetTarget(&door->tracer, actor); // Origin door
+ door->flags2 |= ambush; // Can be opened by normal players?
}
// Function: A_MinecartSparkThink
@@ -13998,3 +14146,299 @@ void A_ModuloToState(mobj_t *actor)
P_SetMobjState(actor, (locvar2));
modulothing++;
}
+
+// Function: A_LavafallRocks
+//
+// Description: Spawn random rock particles.
+//
+// var1 = unused
+// var2 = unused
+//
+void A_LavafallRocks(mobj_t *actor)
+{
+ UINT8 i;
+
+#ifdef HAVE_BLUA
+ if (LUA_CallAction("A_LavafallRocks", actor))
+ return;
+#endif
+
+ // Don't spawn rocks unless a player is relatively close by.
+ for (i = 0; i < MAXPLAYERS; ++i)
+ if (playeringame[i] && players[i].mo
+ && P_AproxDistance(actor->x - players[i].mo->x, actor->y - players[i].mo->y) < (actor->info->speed >> 1))
+ break; // Stop looking.
+
+ if (i < MAXPLAYERS)
+ {
+ angle_t fa = (FixedAngle(P_RandomKey(360) << FRACBITS) >> ANGLETOFINESHIFT) & FINEMASK;
+ fixed_t offset = P_RandomRange(4, 12) << FRACBITS;
+ fixed_t xoffs = FixedMul(FINECOSINE(fa), actor->radius + offset);
+ fixed_t yoffs = FixedMul(FINESINE(fa), actor->radius + offset);
+ P_SpawnMobjFromMobj(actor, xoffs, yoffs, 0, MT_LAVAFALLROCK);
+ }
+}
+
+// Function: A_LavafallLava
+//
+// Description: Spawn lava from lavafall.
+//
+// var1 = unused
+// var2 = unused
+//
+void A_LavafallLava(mobj_t *actor)
+{
+ mobj_t *lavafall;
+ UINT8 i;
+
+#ifdef HAVE_BLUA
+ if (LUA_CallAction("A_LavafallLava", actor))
+ return;
+#endif
+
+ if ((40 - actor->fuse) % (2*(actor->scale >> FRACBITS)))
+ return;
+
+ // Don't spawn lava unless a player is nearby.
+ for (i = 0; i < MAXPLAYERS; ++i)
+ if (playeringame[i] && players[i].mo
+ && P_AproxDistance(actor->x - players[i].mo->x, actor->y - players[i].mo->y) < (actor->info->speed))
+ break; // Stop looking.
+
+ if (i >= MAXPLAYERS)
+ return;
+
+ lavafall = P_SpawnMobjFromMobj(actor, 0, 0, -8*FRACUNIT, MT_LAVAFALL_LAVA);
+ lavafall->momz = -P_MobjFlip(actor)*25*FRACUNIT;
+}
+
+// Function: A_FallingLavaCheck
+//
+// Description: If actor hits the ground or a water surface, enter the death animation.
+//
+// var1 = unused
+// var2 = unused
+//
+void A_FallingLavaCheck(mobj_t *actor)
+{
+#ifdef HAVE_BLUA
+ if (LUA_CallAction("A_FallingLavaCheck", actor))
+ return;
+#endif
+
+ if (actor->eflags & MFE_TOUCHWATER || P_IsObjectOnGround(actor))
+ {
+ actor->flags = MF_NOGRAVITY|MF_NOCLIPTHING;
+ actor->momz = 0;
+ if (actor->eflags & MFE_TOUCHWATER)
+ actor->z = (actor->eflags & MFE_VERTICALFLIP) ? actor->waterbottom : actor->watertop;
+ P_SetMobjState(actor, actor->info->deathstate);
+ }
+}
+
+// Function: A_FireShrink
+//
+// Description: Shrink the actor down to the specified scale at the specified speed.
+//
+// var1 = Scale to shrink to
+// var2 = Shrinking speed
+//
+void A_FireShrink(mobj_t *actor)
+{
+ INT32 locvar1 = var1;
+ INT32 locvar2 = var2;
+
+#ifdef HAVE_BLUA
+ if (LUA_CallAction("A_FireShrink", actor))
+ return;
+#endif
+
+ actor->destscale = locvar1;
+ actor->scalespeed = FRACUNIT/locvar2;
+}
+
+// Function: A_SpawnPterabytes
+//
+// Description: Spawn Pterabytes around the actor in a circle.
+//
+// var1 = unused
+// var2 = unused
+//
+void A_SpawnPterabytes(mobj_t *actor)
+{
+ mobj_t *waypoint, *ptera;
+ fixed_t c, s;
+ fixed_t rad = 280*FRACUNIT;
+ angle_t ang = 0;
+ angle_t interval, fa;
+ UINT8 amount = 1;
+ UINT8 i;
+
+#ifdef HAVE_BLUA
+ if (LUA_CallAction("A_SpawnPterabytes", actor))
+ return;
+#endif
+
+ if (actor->spawnpoint)
+ amount = actor->spawnpoint->extrainfo + 1;
+
+ interval = FixedAngle(FRACUNIT*360/amount);
+
+ for (i = 0; i < amount; i++)
+ {
+ fa = (ang >> ANGLETOFINESHIFT) & FINEMASK;
+ c = FINECOSINE(fa);
+ s = FINESINE(fa);
+ waypoint = P_SpawnMobjFromMobj(actor, FixedMul(c, rad), FixedMul(s, rad), 0, MT_PTERABYTEWAYPOINT);
+ waypoint->angle = ang + ANGLE_90;
+ P_SetTarget(&waypoint->tracer, actor);
+ ptera = P_SpawnMobjFromMobj(waypoint, 0, 0, 0, MT_PTERABYTE);
+ ptera->angle = waypoint->angle;
+ P_SetTarget(&ptera->tracer, waypoint);
+ ptera->extravalue1 = 0;
+ ang += interval;
+ }
+}
+
+// Function: A_PterabyteHover
+//
+// Description: Hover in a circular fashion, bobbing up and down slightly.
+//
+// var1 = unused
+// var2 = unused
+//
+void A_PterabyteHover(mobj_t *actor)
+{
+ angle_t ang, fa;
+
+#ifdef HAVE_BLUA
+ if (LUA_CallAction("A_PterabyteHover", actor))
+ return;
+#endif
+
+ P_InstaThrust(actor, actor->angle, actor->info->speed);
+ actor->angle += ANG1;
+ actor->extravalue1 = (actor->extravalue1 + 3) % 360;
+ ang = actor->extravalue1*ANG1;
+ fa = (ang >> ANGLETOFINESHIFT) & FINEMASK;
+ actor->z += FINESINE(fa);
+}
+// Function: A_RolloutSpawn
+//
+// Description: Spawns a new Rollout Rock when the currently spawned rock is destroyed or moves far enough away.
+//
+// var1 = Distance currently spawned rock should travel before spawning a new one
+// var2 = Object type to spawn
+//
+void A_RolloutSpawn(mobj_t *actor)
+{
+ INT32 locvar1 = var1;
+ INT32 locvar2 = var2;
+
+#ifdef HAVE_BLUA
+ if (LUA_CallAction("A_RolloutSpawn", actor))
+ return;
+#endif
+
+ if (!(actor->target)
+ || P_MobjWasRemoved(actor->target)
+ || P_AproxDistance(actor->x - actor->target->x, actor->y - actor->target->y) > locvar1)
+ {
+ actor->target = P_SpawnMobj(actor->x, actor->y, actor->z, locvar2);
+ actor->target->flags2 |= (actor->flags2 & (MF2_AMBUSH | MF2_OBJECTFLIP)) | MF2_SLIDEPUSH;
+ actor->target->eflags |= (actor->eflags & MFE_VERTICALFLIP);
+
+ if (actor->target->flags2 & MF2_AMBUSH)
+ {
+ actor->target->color = SKINCOLOR_SUPERRUST3;
+ actor->target->colorized = true;
+ }
+ }
+}
+
+// Function: A_RolloutRock
+//
+// Description: Thinker for Rollout Rock.
+//
+// var1 = Drag
+// var2 = Vertical bobbing speed factor
+//
+void A_RolloutRock(mobj_t *actor)
+{
+ INT32 locvar1 = var1;
+ INT32 locvar2 = var2;
+ UINT8 maxframes = actor->info->reactiontime; // number of frames the mobj cycles through
+ fixed_t pi = (22*FRACUNIT/7);
+ fixed_t circumference = FixedMul(2 * pi, actor->radius); // used to calculate when to change frame
+ fixed_t speed = P_AproxDistance(actor->momx, actor->momy), topspeed = FixedMul(actor->info->speed, actor->scale);
+ boolean inwater = actor->eflags & (MFE_TOUCHWATER|MFE_UNDERWATER);
+
+#ifdef HAVE_BLUA
+ if (LUA_CallAction("A_RolloutRock", actor))
+ return;
+#endif
+
+ actor->friction = FRACUNIT; // turns out riding on solids sucks, so let's just make it easier on ourselves
+
+ if (actor->threshold)
+ actor->threshold--;
+
+ if (inwater && !(actor->flags2 & MF2_AMBUSH)) // buoyancy in water (or lava)
+ {
+ UINT8 flip = P_MobjFlip(actor);
+ fixed_t prevmomz = actor->momz;
+ actor->momz = FixedMul(actor->momz, locvar2);
+ actor->momz += flip * FixedMul(locvar2, actor->scale);
+ if (flip*prevmomz < 0 && flip*actor->momz >= 0 && !actor->threshold)
+ {
+ if (actor->eflags & MFE_UNDERWATER)
+ S_StartSound(actor, sfx_splash);
+ else if (!actor->threshold)
+ S_StartSound(actor, sfx_splish);
+ actor->threshold = max((topspeed - speed) >> FRACBITS, 8);
+ }
+ }
+
+ if (speed > topspeed) // cap speed
+ {
+ actor->momx = FixedMul(FixedDiv(actor->momx, speed), topspeed);
+ actor->momy = FixedMul(FixedDiv(actor->momy, speed), topspeed);
+ }
+
+ if (P_IsObjectOnGround(actor) || inwater) // apply drag to speed (compensates for lack of friction but also works in liquids)
+ {
+ actor->momx = FixedMul(actor->momx, locvar1);
+ actor->momy = FixedMul(actor->momy, locvar1);
+ }
+
+ speed = P_AproxDistance(actor->momx, actor->momy); // recalculate speed for visual rolling
+
+ if (speed < actor->scale >> 1) // stop moving if speed is insignificant
+ {
+ actor->momx = 0;
+ actor->momy = 0;
+ }
+ else if (speed > actor->scale)
+ {
+ actor->movecount = 1; // rock has moved; fuse should be set so we don't have a trillion rocks lying around
+ actor->angle = R_PointToAngle2(0, 0, actor->momx, actor->momy); // set rock's angle to movement direction
+ actor->movefactor += speed;
+ if (actor->movefactor > circumference / maxframes) // if distance moved is enough to change frame, change it!
+ {
+ actor->reactiontime++;
+ actor->reactiontime %= maxframes;
+ actor->movefactor = 0;
+ }
+ }
+
+ actor->frame = actor->reactiontime % maxframes; // set frame
+
+ if (!(actor->flags & MF_PUSHABLE)) // if being ridden, don't disappear
+ actor->fuse = 0;
+ else if (!actor->fuse && actor->movecount == 1) // otherwise if rock has moved, set its fuse
+ actor->fuse = actor->info->painchance;
+
+ if (actor->fuse && actor->fuse < 2*TICRATE)
+ actor->flags2 ^= MF2_DONTDRAW;
+
+}
diff --git a/src/p_floor.c b/src/p_floor.c
index 7887dc530a6291adb50adb1304baee52197fe440..423fc1b70a8e7da8fd63f5a98ca65a54c509d3f3 100644
--- a/src/p_floor.c
+++ b/src/p_floor.c
@@ -1778,6 +1778,7 @@ static mobj_t *SearchMarioNode(msecnode_t *node)
case MT_RAIN:
case MT_SNOWFLAKE:
case MT_SPLISH:
+ case MT_LAVASPLISH:
case MT_SMOKE:
case MT_SMALLBUBBLE:
case MT_MEDIUMBUBBLE:
@@ -2424,7 +2425,7 @@ void T_RaiseSector(levelspecthink_t *raise)
mobj_t *thing;
sector_t *sector;
INT32 i;
- boolean playeronme = false;
+ boolean playeronme = false, active = false;
fixed_t ceilingdestination, floordestination;
result_e res = 0;
@@ -2459,7 +2460,52 @@ void T_RaiseSector(levelspecthink_t *raise)
}
}
- if (playeronme)
+ if (raise->vars[9]) // Dynamically Sinking Platform^tm
+ {
+#define shaketime 10
+ if (raise->vars[11] > shaketime) // State: moving
+ {
+ if (playeronme) // If player is standing on the platform, accelerate
+ {
+ raise->vars[10] += (FRACUNIT >> 5);
+ }
+ else // otherwise, decelerate until inflection
+ {
+ raise->vars[10] -= FRACUNIT >> 3;
+ if (raise->vars[10] <= 0) // inflection!
+ {
+ raise->vars[10] = 0;
+ raise->vars[11] = 0; // allow the shake to occur again (fucks over players attempting to jump-cheese)
+ }
+ }
+ active = raise->vars[10] > 0;
+ }
+ else // State: shaking
+ {
+ if (playeronme || raise->vars[11])
+ {
+ active = true;
+ if (++raise->vars[11] > shaketime)
+ {
+ if (playeronme)
+ raise->vars[10] = FRACUNIT >> 5;
+ else
+ raise->vars[10] = FRACUNIT << 1;
+ }
+ else
+ {
+ raise->vars[10] = ((shaketime/2) - raise->vars[11]) << FRACBITS;
+ if (raise->vars[10] < -raise->vars[2]/2)
+ raise->vars[10] = -raise->vars[2]/2;
+ }
+ }
+ }
+#undef shaketime
+ }
+ else // Air bobbing platform (not a Dynamically Sinking Platform^tm)
+ active = playeronme;
+
+ if (active)
{
raise->vars[3] = raise->vars[2];
@@ -2553,6 +2599,8 @@ void T_RaiseSector(levelspecthink_t *raise)
raise->vars[3] = origspeed;
}
+ raise->vars[3] += raise->vars[10];
+
res = T_MovePlane
(
raise->sector, // sector
diff --git a/src/p_inter.c b/src/p_inter.c
index 403f36b53943b411f2bc78782a4378920211db5f..c65e6cc3604e4347ed18bbeca2d5e56ae8ac8497 100644
--- a/src/p_inter.c
+++ b/src/p_inter.c
@@ -428,7 +428,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
|| special->state == &states[S_FANG_BOUNCE4]
|| special->state == &states[S_FANG_PINCHBOUNCE3]
|| special->state == &states[S_FANG_PINCHBOUNCE4])
- && P_MobjFlip(special)*((special->z + special->height/2) - (toucher->z - toucher->height/2)) > -(special->height/4))
+ && P_MobjFlip(special)*((special->z + special->height/2) - (toucher->z - toucher->height/2)) > (special->height/4))
{
P_DamageMobj(toucher, special, special, 1, 0);
P_SetTarget(&special->tracer, toucher);
@@ -450,12 +450,18 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
}
}
break;
+ case MT_PYREFLY:
+ if (special->extravalue2 == 2 && P_DamageMobj(player->mo, special, special, 1, DMG_FIRE))
+ return;
default:
break;
}
if (P_PlayerCanDamage(player, special)) // Do you possess the ability to subdue the object?
{
+ if (special->type == MT_PTERABYTE && special->target == player->mo && special->extravalue1 == 1)
+ return; // Can't hurt a Pterabyte if it's trying to pick you up
+
if ((P_MobjFlip(toucher)*toucher->momz < 0) && (elementalpierce != 1))
{
if (elementalpierce == 2)
@@ -471,13 +477,29 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
toucher->momy = -toucher->momy;
if (player->charability == CA_FLY && player->panim == PA_ABILITY)
toucher->momz = -toucher->momz/2;
+ else if (player->pflags & PF_GLIDING && !P_IsObjectOnGround(toucher))
+ {
+ player->pflags &= ~(PF_GLIDING|PF_JUMPED|PF_NOJUMPDAMAGE);
+ P_SetPlayerMobjState(toucher, S_PLAY_FALL);
+ toucher->momz += P_MobjFlip(toucher) * (player->speed >> 3);
+ toucher->momx = 7*toucher->momx>>3;
+ toucher->momy = 7*toucher->momy>>3;
+ }
+ else if (player->dashmode >= DASHMODE_THRESHOLD && (player->charflags & (SF_DASHMODE|SF_MACHINE)) == (SF_DASHMODE|SF_MACHINE)
+ && player->panim == PA_DASH)
+ P_DoPlayerPain(player, special, special);
}
P_DamageMobj(special, toucher, toucher, 1, 0);
if (player->charability == CA_TWINSPIN && player->panim == PA_ABILITY)
P_TwinSpinRejuvenate(player, player->thokitem);
}
else
+ {
+ if (special->type == MT_PTERABYTE && special->target == player->mo)
+ return; // Don't hurt the player you're trying to grab
+
P_DamageMobj(toucher, special, special, 1, 0);
+ }
return;
}
@@ -611,7 +633,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
if (!(netgame || multiplayer))
{
player->continues += 1;
- players->gotcontinue = true;
+ player->gotcontinue = true;
if (P_IsLocalPlayer(player))
S_StartSound(NULL, sfx_s3kac);
else
@@ -1074,7 +1096,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
if (player->exiting)
return;
- if (player->bumpertime < TICRATE/4)
+ if (player->bumpertime <= (TICRATE/2)-5)
{
S_StartSound(toucher, special->info->seesound);
if (player->powers[pw_carry] == CR_NIGHTSMODE)
@@ -1482,8 +1504,6 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
P_SetMobjState(mo2, mo2->info->painstate);
}
}
-
- S_StartSound(toucher, special->info->painsound);
return;
case MT_FAKEMOBILE:
@@ -1509,10 +1529,13 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
toucher->momx = P_ReturnThrustX(special, angle, touchspeed);
toucher->momy = P_ReturnThrustY(special, angle, touchspeed);
toucher->momz = -toucher->momz;
- if (player->pflags & PF_GLIDING)
+ if (player->pflags & PF_GLIDING && !P_IsObjectOnGround(toucher))
{
player->pflags &= ~(PF_GLIDING|PF_JUMPED|PF_NOJUMPDAMAGE);
P_SetPlayerMobjState(toucher, S_PLAY_FALL);
+ toucher->momz += P_MobjFlip(toucher) * (player->speed >> 3);
+ toucher->momx = 7*toucher->momx>>3;
+ toucher->momy = 7*toucher->momy>>3;
}
player->homing = 0;
@@ -1557,10 +1580,13 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
toucher->momx = P_ReturnThrustX(special, special->angle, touchspeed);
toucher->momy = P_ReturnThrustY(special, special->angle, touchspeed);
toucher->momz = -toucher->momz;
- if (player->pflags & PF_GLIDING)
+ if (player->pflags & PF_GLIDING && !P_IsObjectOnGround(toucher))
{
player->pflags &= ~(PF_GLIDING|PF_JUMPED|PF_NOJUMPDAMAGE);
P_SetPlayerMobjState(toucher, S_PLAY_FALL);
+ toucher->momz += P_MobjFlip(toucher) * (player->speed >> 3);
+ toucher->momx = 7*toucher->momx>>3;
+ toucher->momy = 7*toucher->momy>>3;
}
player->homing = 0;
@@ -1765,7 +1791,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
return;
case MT_MINECARTSPAWNER:
- if (!special->fuse || player->powers[pw_carry] != CR_MINECART)
+ if (!player->bot && (special->fuse < TICRATE || player->powers[pw_carry] != CR_MINECART))
{
mobj_t *mcart = P_SpawnMobj(special->x, special->y, special->z, MT_MINECART);
P_SetTarget(&mcart->target, toucher);
@@ -1775,7 +1801,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
P_ResetPlayer(player);
player->pflags |= PF_JUMPDOWN;
player->powers[pw_carry] = CR_MINECART;
- toucher->player->pflags &= ~PF_APPLYAUTOBRAKE;
+ player->pflags &= ~PF_APPLYAUTOBRAKE;
P_SetTarget(&toucher->tracer, mcart);
toucher->momx = toucher->momy = toucher->momz = 0;
@@ -2346,7 +2372,7 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
if (target->player && !target->player->spectator)
{
if (metalrecording) // Ack! Metal Sonic shouldn't die! Cut the tape, end recording!
- G_StopMetalRecording();
+ G_StopMetalRecording(true);
if (gametype == GT_MATCH // note, no team match suicide penalty
&& ((target == source) || (source == NULL && inflictor == NULL) || (source && !source->player)))
{ // Suicide penalty
@@ -2456,6 +2482,30 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
P_UnsetThingPosition(target);
target->flags |= MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY;
P_SetThingPosition(target);
+ target->standingslope = NULL;
+ target->pmomz = 0;
+
+ if (target->player->powers[pw_super])
+ {
+ target->player->powers[pw_super] = 0;
+ if (P_IsLocalPlayer(target->player))
+ {
+ music_stack_noposition = true; // HACK: Do not reposition next music
+ music_stack_fadeout = MUSICRATE/2; // HACK: Fade out current music
+ }
+ P_RestoreMusic(target->player);
+
+ if (gametype != GT_COOP)
+ {
+ HU_SetCEchoFlags(0);
+ HU_SetCEchoDuration(5);
+ HU_DoCEcho(va("%s\\is no longer super.\\\\\\\\", player_names[target->player-players]));
+ }
+ }
+
+ target->color = target->player->skincolor;
+ target->colorized = false;
+ G_GhostAddColor(GHC_NORMAL);
if ((target->player->lives <= 1) && (netgame || multiplayer) && (gametype == GT_COOP) && (cv_cooplives.value == 0))
;
@@ -2567,7 +2617,7 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
target->fuse = target->info->damage;
break;
- case MT_BUBBLEBUZZ:
+ case MT_BUGGLE:
if (inflictor && inflictor->player // did a player kill you? Spawn relative to the player so they're bound to get it
&& P_AproxDistance(inflictor->x - target->x, inflictor->y - target->y) <= inflictor->radius + target->radius + FixedMul(8*FRACUNIT, inflictor->scale) // close enough?
&& inflictor->z <= target->z + target->height + FixedMul(8*FRACUNIT, inflictor->scale)
@@ -2602,6 +2652,14 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
}
break;
+ case MT_BANPYURA:
+ if (target->tracer)
+ {
+ S_StopSound(target->tracer);
+ P_KillMobj(target->tracer, inflictor, source, damagetype);
+ }
+ break;
+
case MT_EGGSHIELD:
P_SetObjectMomZ(target, 4*target->scale, false);
P_InstaThrust(target, target->angle, 3*target->scale);
@@ -2705,6 +2763,12 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
}
}
break;
+ case MT_METALSONIC_RACE:
+ target->fuse = TICRATE*3;
+ target->momx = target->momy = target->momz = 0;
+ P_SetObjectMomZ(target, 14*FRACUNIT, false);
+ target->flags = (target->flags & ~MF_NOGRAVITY)|(MF_NOCLIP|MF_NOCLIPTHING);
+ break;
default:
break;
}
@@ -3559,11 +3623,12 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
}
else if (inflictor && inflictor->flags & MF_MISSILE)
return false; // Metal Sonic walk through flame !!
- else
+ else if (!player->powers[pw_flashing])
{ // Oh no! Metal Sonic is hit !!
P_ShieldDamage(player, inflictor, source, damage, damagetype);
return true;
}
+ return false;
}
else if (player->powers[pw_invulnerability] || player->powers[pw_flashing] || player->powers[pw_super]) // ignore bouncing & such in invulnerability
{
diff --git a/src/p_local.h b/src/p_local.h
index 4a58650272b7c8ba20c69ef3db283872c958fa57..02f497850d23b02d0331501ab80908e358d64916 100644
--- a/src/p_local.h
+++ b/src/p_local.h
@@ -303,7 +303,7 @@ fixed_t P_CameraCeilingZ(camera_t *mobj, sector_t *sector, sector_t *boundsec, f
boolean P_InsideANonSolidFFloor(mobj_t *mobj, ffloor_t *rover);
boolean P_CheckDeathPitCollide(mobj_t *mo);
-boolean P_CheckSolidLava(mobj_t *mo, ffloor_t *rover);
+boolean P_CheckSolidLava(ffloor_t *rover);
void P_AdjustMobjFloorZ_FFloors(mobj_t *mo, sector_t *sector, UINT8 motype);
mobj_t *P_SpawnMobjFromMobj(mobj_t *mobj, fixed_t xofs, fixed_t yofs, fixed_t zofs, mobjtype_t type);
diff --git a/src/p_map.c b/src/p_map.c
index 8035d64a576386c2b22475f4be1958eecf62906a..bb56a50b16932ae818f2a8e62f13a9e940cd3688 100644
--- a/src/p_map.c
+++ b/src/p_map.c
@@ -124,6 +124,7 @@ boolean P_TeleportMove(mobj_t *thing, fixed_t x, fixed_t y, fixed_t z)
// Positive spring modes are minor variants of vanilla spring behaviour.
// 1 = launch players in jump
// 2 = don't modify player at all, just add momentum
+// 3 = speed-booster mode (force onto ground, MF_AMBUSH causes auto-spin)
// Negative spring modes are mildly-related gimmicks with customisation.
// -1 = pinball bumper
// Any other spring mode defaults to standard vanilla spring behaviour,
@@ -151,7 +152,9 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
if (object->player)
{
- if (object->player->charability == CA_TWINSPIN && object->player->panim == PA_ABILITY)
+ if (spring->info->painchance == 3)
+ ;
+ else if (object->player->charability == CA_TWINSPIN && object->player->panim == PA_ABILITY)
strong = 1;
else if (object->player->charability2 == CA2_MELEE && object->player->panim == PA_ABILITY2)
strong = 2;
@@ -208,7 +211,7 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
{
angle_t nightsangle = 0;
- if (object->player->bumpertime >= TICRATE/4)
+ if (object->player->bumpertime > (TICRATE/2)-5)
return false;
if ((object->player->pflags & PF_TRANSFERTOCLOSEST) && object->player->axis1 && object->player->axis2)
@@ -286,7 +289,27 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
if (spring->info->painchance != 2)
{
if (object->player)
+ {
object->player->pflags &= ~PF_APPLYAUTOBRAKE;
+#ifndef SPRINGSPIN
+ object->player->powers[pw_justsprung] = 5;
+ if (horizspeed)
+ object->player->powers[pw_noautobrake] = ((horizspeed*TICRATE)>>(FRACBITS+3))/9; // TICRATE at 72*FRACUNIT
+ else if (P_MobjFlip(object) == P_MobjFlip(spring))
+ object->player->powers[pw_justsprung] |= (1<<15);
+#else
+ object->player->powers[pw_justsprung] = 15;
+ if (horizspeed)
+ object->player->powers[pw_noautobrake] = ((horizspeed*TICRATE)>>(FRACBITS+3))/9; // TICRATE at 72*FRACUNIT
+ else
+ {
+ if (abs(object->player->rmomx) > object->scale || abs(object->player->rmomy) > object->scale)
+ object->player->drawangle = R_PointToAngle2(0, 0, object->player->rmomx, object->player->rmomy);
+ if (P_MobjFlip(object) == P_MobjFlip(spring))
+ object->player->powers[pw_justsprung] |= (1<<15);
+ }
+#endif
+ }
if ((horizspeed && vertispeed) || (object->player && object->player->homing)) // Mimic SA
{
@@ -321,6 +344,14 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
// Set position!
P_TryMove(object, spring->x + offx, spring->y + offy, true);
+
+ if ((spring->info->painchance == 3))
+ {
+ object->z = spring->z;
+ if (spring->eflags & MFE_VERTICALFLIP)
+ object->z -= object->height;
+ object->momz = 0;
+ }
}
}
@@ -344,8 +375,7 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
if (horizspeed)
{
- object->player->drawangle = spring->angle;
- object->angle = spring->angle;
+ object->angle = object->player->drawangle = spring->angle;
if (!demoplayback || P_AnalogMove(object->player))
{
@@ -356,11 +386,25 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
}
}
- pflags = object->player->pflags & (PF_STARTJUMP|PF_JUMPED|PF_NOJUMPDAMAGE|PF_SPINNING|PF_THOKKED|PF_BOUNCING); // I still need these.
- secondjump = object->player->secondjump;
- washoming = object->player->homing;
if (object->player->pflags & PF_GLIDING)
P_SetPlayerMobjState(object, S_PLAY_FALL);
+ if ((spring->info->painchance == 3))
+ {
+ if (!(pflags = (object->player->pflags & PF_SPINNING)) &&
+ (((object->player->charability2 == CA2_SPINDASH) && (object->player->cmd.buttons & BT_USE))
+ || (spring->flags2 & MF2_AMBUSH)))
+ {
+ pflags = PF_SPINNING;
+ P_SetPlayerMobjState(object, S_PLAY_ROLL);
+ S_StartSound(object, sfx_spin);
+ }
+ else
+ P_SetPlayerMobjState(object, S_PLAY_ROLL);
+ }
+ else
+ pflags = object->player->pflags & (PF_STARTJUMP|PF_JUMPED|PF_NOJUMPDAMAGE|PF_SPINNING|PF_THOKKED|PF_BOUNCING); // I still need these.
+ secondjump = object->player->secondjump;
+ washoming = object->player->homing;
P_ResetPlayer(object->player);
if (spring->info->painchance == 1) // For all those ancient, SOC'd abilities.
@@ -368,7 +412,7 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
object->player->pflags |= P_GetJumpFlags(object->player);
P_SetPlayerMobjState(object, S_PLAY_JUMP);
}
- else if ((spring->info->painchance == 2) || (pflags & PF_BOUNCING)) // Adding momentum only.
+ else if ((spring->info->painchance == 2) || ((spring->info->painchance != 3) && (pflags & PF_BOUNCING))) // Adding momentum only.
{
object->player->pflags |= (pflags &~ PF_STARTJUMP);
object->player->secondjump = secondjump;
@@ -382,6 +426,10 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
object->player->pflags |= pflags;
object->player->secondjump = secondjump;
}
+ else if (object->player->dashmode >= 3*TICRATE)
+ P_SetPlayerMobjState(object, S_PLAY_DASH);
+ else if (P_IsObjectOnGround(object) && horizspeed >= FixedMul(object->player->runspeed, object->scale))
+ P_SetPlayerMobjState(object, S_PLAY_RUN);
else
P_SetPlayerMobjState(object, S_PLAY_WALK);
}
@@ -490,6 +538,42 @@ static void P_DoFanAndGasJet(mobj_t *spring, mobj_t *object)
}
}
+static void P_DoPterabyteCarry(player_t *player, mobj_t *ptera)
+{
+ if (player->powers[pw_carry] && player->powers[pw_carry] != CR_ROLLOUT)
+ return;
+ if (ptera->extravalue1 != 1)
+ return; // Not swooping
+ if (ptera->target != player->mo)
+ return; // Not swooping for you!
+
+ if (player->spectator)
+ return;
+
+ if ((player->mo->eflags & MFE_VERTICALFLIP) != (ptera->eflags & MFE_VERTICALFLIP))
+ return; // Both should be in same gravity
+
+ if (ptera->eflags & MFE_VERTICALFLIP)
+ {
+ if (ptera->ceilingz - (ptera->z + ptera->height) < player->mo->height - FixedMul(2*FRACUNIT, player->mo->scale))
+ return;
+ }
+ else if (ptera->z - ptera->floorz < player->mo->height - FixedMul(2*FRACUNIT, player->mo->scale))
+ return; // No room to pick up this guy!
+
+ P_ResetPlayer(player);
+ P_SetTarget(&player->mo->tracer, ptera);
+ player->pflags &= ~PF_APPLYAUTOBRAKE;
+ player->powers[pw_carry] = CR_PTERABYTE;
+ S_StartSound(player->mo, sfx_s3k4a);
+ P_UnsetThingPosition(player->mo);
+ player->mo->x = ptera->x;
+ player->mo->y = ptera->y;
+ P_SetThingPosition(player->mo);
+ ptera->movefactor = 3*TICRATE;
+ ptera->watertop = ptera->waterbottom = ptera->cusval = 0;
+}
+
static void P_DoTailsCarry(player_t *sonic, player_t *tails)
{
INT32 p;
@@ -604,6 +688,34 @@ static void P_SlapStick(mobj_t *fang, mobj_t *pole)
P_SetTarget(&pole->tracer, NULL);
}
+static void P_PlayerBarrelCollide(mobj_t *toucher, mobj_t *barrel)
+{
+ if (toucher->momz < 0)
+ {
+ if (toucher->z + toucher->momz > barrel->z + barrel->height)
+ return;
+ }
+ else
+ {
+ if (toucher->z > barrel->z + barrel->height)
+ return;
+ }
+
+ if (toucher->momz > 0)
+ {
+ if (toucher->z + toucher->height + toucher->momz < barrel->z)
+ return;
+ }
+ else
+ {
+ if (toucher->z + toucher->height < barrel->z)
+ return;
+ }
+
+ if (P_PlayerCanDamage(toucher->player, barrel))
+ P_DamageMobj(barrel, toucher, toucher, 1, 0);
+}
+
//
// PIT_CheckThing
//
@@ -854,6 +966,15 @@ static boolean PIT_CheckThing(mobj_t *thing)
}
#endif
+ if (tmthing->type == MT_LAVAFALL_LAVA && (thing->type == MT_RING || thing->type == MT_REDTEAMRING || thing->type == MT_BLUETEAMRING || thing->type == MT_FLINGRING))
+ {
+ //height check
+ if (tmthing->z > thing->z + thing->height || thing->z > tmthing->z + tmthing->height || !(thing->health))
+ return true;
+
+ P_KillMobj(thing, tmthing, tmthing, DMG_FIRE);
+ }
+
if (tmthing->type == MT_MINECART)
{
//height check
@@ -872,12 +993,11 @@ static boolean PIT_CheckThing(mobj_t *thing)
if (thing->type == MT_SALOONDOOR && tmthing->player)
{
- if (tmthing->player->powers[pw_carry] == CR_MINECART && tmthing->tracer && !P_MobjWasRemoved(tmthing->tracer) && tmthing->tracer->health)
+ mobj_t *ref = (tmthing->player->powers[pw_carry] == CR_MINECART && tmthing->tracer && !P_MobjWasRemoved(tmthing->tracer)) ? tmthing->tracer : tmthing;
+ if ((thing->flags & MF2_AMBUSH) || ref != tmthing)
{
- fixed_t dx = tmthing->tracer->momx;
- fixed_t dy = tmthing->tracer->momy;
- fixed_t dm = min(FixedHypot(dx, dy), 16*FRACUNIT);
- angle_t ang = R_PointToAngle2(0, 0, dx, dy) - thing->angle;
+ fixed_t dm = min(FixedHypot(ref->momx, ref->momy), 16*FRACUNIT);
+ angle_t ang = R_PointToAngle2(0, 0, ref->momx, ref->momy) - thing->angle;
fixed_t s = FINESINE((ang >> ANGLETOFINESHIFT) & FINEMASK);
S_StartSound(tmthing, thing->info->activesound);
thing->extravalue2 += 2*FixedMul(s, dm)/3;
@@ -885,41 +1005,73 @@ static boolean PIT_CheckThing(mobj_t *thing)
}
}
- if (thing->type == MT_TNTBARREL && tmthing->player)
+ if (thing->type == MT_SALOONDOORCENTER && tmthing->player)
+ {
+ if ((thing->flags & MF2_AMBUSH) || (tmthing->player->powers[pw_carry] == CR_MINECART && tmthing->tracer && !P_MobjWasRemoved(tmthing->tracer)))
+ return true;
+ }
+
+ if (thing->type == MT_ROLLOUTROCK && tmthing->player && tmthing->health)
{
- if (tmthing->momz < 0)
+ if (tmthing->player->powers[pw_carry] == CR_ROLLOUT)
{
- if (tmthing->z + tmthing->momz > thing->z + thing->height)
- return true;
+ return true;
}
- else
+ if ((thing->flags & MF_PUSHABLE) // not carrying a player
+ && (tmthing->player->powers[pw_carry] == CR_NONE) // player is not already riding something
+ && ((tmthing->eflags & MFE_VERTICALFLIP) == (thing->eflags & MFE_VERTICALFLIP))
+ && (P_AproxDistance(thing->x - tmthing->x, thing->y - tmthing->y) < (thing->radius))
+ && (P_MobjFlip(tmthing)*tmthing->momz <= 0)
+ && ((!(tmthing->eflags & MFE_VERTICALFLIP) && abs(thing->z + thing->height - tmthing->z) < (thing->height>>2))
+ || (tmthing->eflags & MFE_VERTICALFLIP && abs(tmthing->z + tmthing->height - thing->z) < (thing->height>>2))))
{
- if (tmthing->z > thing->z + thing->height)
- return true;
+ thing->flags &= ~MF_PUSHABLE; // prevent riding player from applying pushable movement logic
+ thing->flags2 &= ~MF2_DONTDRAW; // don't leave the rock invisible if it was flashing prior to boarding
+ P_SetTarget(&thing->tracer, tmthing);
+ P_ResetPlayer(tmthing->player);
+ P_SetPlayerMobjState(tmthing, S_PLAY_WALK);
+ tmthing->player->powers[pw_carry] = CR_ROLLOUT;
+ P_SetTarget(&tmthing->tracer, thing);
+ P_SetObjectMomZ(thing, tmthing->momz, true);
+ return true;
}
+ }
+ else if (tmthing->type == MT_ROLLOUTROCK)
+ {
+ if (tmthing->z > thing->z + thing->height || thing->z > tmthing->z + tmthing->height || !thing->health)
+ return true;
- if (tmthing->momz > 0)
+ if (thing == tmthing->tracer) // don't collide with rider
+ return true;
+
+ if (thing->flags & MF_SPRING) // bounce on springs
{
- if (tmthing->z + tmthing->height + tmthing->momz < thing->z)
- return true;
+ P_DoSpring(thing, tmthing);
+ return true;
}
- else
+ else if ((thing->flags & (MF_MONITOR|MF_SHOOTABLE)) == (MF_MONITOR|MF_SHOOTABLE) && !(tmthing->flags & MF_PUSHABLE)) // pop monitors while carrying a player
{
- if (tmthing->z + tmthing->height < thing->z)
- return true;
+ P_KillMobj(thing, tmthing, tmthing->tracer, 0);
+ return true;
}
- if ((tmthing->player->pflags & (PF_SPINNING | PF_GLIDING))
- || ((tmthing->player->pflags & PF_JUMPED)
- && (!(tmthing->player->pflags & PF_NOJUMPDAMAGE)
- || (tmthing->player->charability == CA_TWINSPIN && tmthing->player->panim == PA_ABILITY)))
- || (tmthing->player->charability2 == CA2_MELEE && tmthing->player->panim == PA_ABILITY2)
- || ((tmthing->player->charflags & SF_STOMPDAMAGE || tmthing->player->pflags & PF_BOUNCING)
- && (P_MobjFlip(tmthing)*(tmthing->z - (thing->z + thing->height / 2)) > 0) && (P_MobjFlip(tmthing)*tmthing->momz < 0))
- || (((tmthing->player->powers[pw_shield] & SH_NOSTACK) == SH_ELEMENTAL || (tmthing->player->powers[pw_shield] & SH_NOSTACK) == SH_BUBBLEWRAP) && (tmthing->player->pflags & PF_SHIELDABILITY)))
- P_DamageMobj(thing, tmthing, tmthing, 1, 0);
+ if (thing->type == tmthing->type // bounce against other rollout rocks
+ && (tmthing->momx || tmthing->momy || thing->momx || thing->momy))
+ {
+ fixed_t tempmomx = thing->momx, tempmomy = thing->momy;
+ thing->momx = tmthing->momx;
+ thing->momy = tmthing->momy;
+ tmthing->momx = tempmomx;
+ tmthing->momy = tempmomy;
+ }
}
+ if (thing->type == MT_PTERABYTE && tmthing->player)
+ P_DoPterabyteCarry(tmthing->player, thing);
+
+ if (thing->type == MT_TNTBARREL && tmthing->player)
+ P_PlayerBarrelCollide(tmthing, thing);
+
if (thing->type == MT_VULTURE && tmthing->type == MT_VULTURE)
{
fixed_t dx = thing->x - tmthing->x;
@@ -1560,8 +1712,8 @@ static boolean PIT_CheckThing(mobj_t *thing)
}
}
- if ((!tmthing->player) && (thing->player))
- ; // no solid thing should ever be able to step up onto a player
+ if ((tmthing->flags & MF_SPRING || tmthing->type == MT_STEAM) && (thing->player))
+ ; // springs and gas jets should never be able to step up onto a player
// z checking at last
// Treat noclip things as non-solid!
else if ((thing->flags & (MF_SOLID|MF_NOCLIP)) == MF_SOLID
@@ -1964,7 +2116,7 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y)
continue;
}
- if (thing->player && (P_CheckSolidLava(thing, rover) || P_CanRunOnWater(thing->player, rover)))
+ if (thing->player && (P_CheckSolidLava(rover) || P_CanRunOnWater(thing->player, rover)))
;
else if (thing->type == MT_SKIM && (rover->flags & FF_SWIMMABLE))
;
@@ -2629,8 +2781,7 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
thing->eflags |= MFE_JUSTSTEPPEDDOWN;
}
#ifdef ESLOPE
- // HACK TO FIX DSZ2: apply only if slopes are involved
- else if (tmceilingslope && tmceilingz < thingtop && thingtop - tmceilingz <= maxstep)
+ else if (tmceilingz < thingtop && thingtop - tmceilingz <= maxstep)
{
thing->z = (thing->ceilingz = thingtop = tmceilingz) - thing->height;
thing->ceilingrover = tmceilingrover;
@@ -2645,8 +2796,7 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
thing->eflags |= MFE_JUSTSTEPPEDDOWN;
}
#ifdef ESLOPE
- // HACK TO FIX DSZ2: apply only if slopes are involved
- else if (tmfloorslope && tmfloorz > thing->z && tmfloorz - thing->z <= maxstep)
+ else if (tmfloorz > thing->z && tmfloorz - thing->z <= maxstep)
{
thing->z = thing->floorz = tmfloorz;
thing->floorrover = tmfloorrover;
@@ -3334,13 +3484,13 @@ isblocking:
&& canclimb)
{
slidemo->angle = climbangle;
- if (!demoplayback || P_AnalogMove(slidemo->player))
+ /*if (!demoplayback || P_AnalogMove(slidemo->player))
{
if (slidemo->player == &players[consoleplayer])
localangle = slidemo->angle;
else if (slidemo->player == &players[secondarydisplayplayer])
localangle2 = slidemo->angle;
- }
+ }*/
if (!slidemo->player->climbing)
{
@@ -3479,6 +3629,64 @@ stairstep:
goto retry;
}
+static void P_CheckLavaWall(mobj_t *mo, sector_t *sec)
+{
+ ffloor_t *rover;
+ fixed_t topheight, bottomheight;
+
+ for (rover = sec->ffloors; rover; rover = rover->next)
+ {
+ if (!(rover->flags & FF_EXISTS))
+ continue;
+
+ if (!(rover->flags & FF_SWIMMABLE))
+ continue;
+
+ if (GETSECSPECIAL(rover->master->frontsector->special, 1) != 3)
+ continue;
+
+ if (rover->master->flags & ML_BLOCKMONSTERS)
+ continue;
+
+ topheight =
+#ifdef ESLOPE
+ *rover->t_slope ? P_GetZAt(*rover->t_slope, mo->x, mo->y) :
+#endif
+ *rover->topheight;
+
+ if (mo->eflags & MFE_VERTICALFLIP)
+ {
+ if (topheight < mo->z - mo->height)
+ continue;
+ }
+ else
+ {
+ if (topheight < mo->z)
+ continue;
+ }
+
+ bottomheight =
+#ifdef ESLOPE
+ *rover->b_slope ? P_GetZAt(*rover->b_slope, mo->x, mo->y) :
+#endif
+ *rover->bottomheight;
+
+ if (mo->eflags & MFE_VERTICALFLIP)
+ {
+ if (bottomheight > mo->z)
+ continue;
+ }
+ else
+ {
+ if (bottomheight > mo->z + mo->height)
+ continue;
+ }
+
+ P_DamageMobj(mo, NULL, NULL, 1, DMG_FIRE);
+ return;
+ }
+}
+
//
// P_SlideMove
// The momx / momy move is bad, so try to slide
@@ -3639,6 +3847,12 @@ retry:
P_PathTraverse(leadx, traily, leadx + mo->momx, traily + mo->momy,
PT_ADDLINES, PTR_SlideTraverse);
+ if (bestslideline && mo->player && bestslideline->sidenum[1] != 0xffff)
+ {
+ sector_t *sec = P_PointOnLineSide(mo->x, mo->y, bestslideline) ? bestslideline->frontsector : bestslideline->backsector;
+ P_CheckLavaWall(mo, sec);
+ }
+
// Some walls are bouncy even if you're not
if (bestslideline && bestslideline->flags & ML_BOUNCY)
{
diff --git a/src/p_maputl.c b/src/p_maputl.c
index 45fc82fbfe2b0b97e9ee27b7491d8de0edebd6fc..111103294c659d38b8286a36597fa9c97d76f951 100644
--- a/src/p_maputl.c
+++ b/src/p_maputl.c
@@ -662,7 +662,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
if (!(rover->flags & FF_EXISTS))
continue;
- if (mobj->player && (P_CheckSolidLava(mobj, rover) || P_CanRunOnWater(mobj->player, rover)))
+ if (mobj->player && (P_CheckSolidLava(rover) || P_CanRunOnWater(mobj->player, rover)))
;
else if (!((rover->flags & FF_BLOCKPLAYER && mobj->player)
|| (rover->flags & FF_BLOCKOTHERS && !mobj->player)))
@@ -674,7 +674,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
delta1 = abs(mobj->z - (bottomheight + ((topheight - bottomheight)/2)));
delta2 = abs(thingtop - (bottomheight + ((topheight - bottomheight)/2)));
- if (delta1 >= delta2 && !(rover->flags & FF_PLATFORM)) // thing is below FOF
+ if (delta1 >= delta2 && (rover->flags & FF_INTANGABLEFLATS) != FF_PLATFORM) // thing is below FOF
{
if (bottomheight < opentop) {
opentop = bottomheight;
@@ -687,7 +687,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
highceiling = bottomheight;
}
- if (delta1 < delta2 && !(rover->flags & FF_REVERSEPLATFORM)) // thing is above FOF
+ if (delta1 < delta2 && (rover->flags & FF_INTANGABLEFLATS) != FF_REVERSEPLATFORM) // thing is above FOF
{
if (topheight > openbottom) {
openbottom = topheight;
@@ -708,7 +708,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
if (!(rover->flags & FF_EXISTS))
continue;
- if (mobj->player && (P_CheckSolidLava(mobj, rover) || P_CanRunOnWater(mobj->player, rover)))
+ if (mobj->player && (P_CheckSolidLava(rover) || P_CanRunOnWater(mobj->player, rover)))
;
else if (!((rover->flags & FF_BLOCKPLAYER && mobj->player)
|| (rover->flags & FF_BLOCKOTHERS && !mobj->player)))
@@ -720,7 +720,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
delta1 = abs(mobj->z - (bottomheight + ((topheight - bottomheight)/2)));
delta2 = abs(thingtop - (bottomheight + ((topheight - bottomheight)/2)));
- if (delta1 >= delta2 && !(rover->flags & FF_PLATFORM)) // thing is below FOF
+ if (delta1 >= delta2 && (rover->flags & FF_INTANGABLEFLATS) != FF_PLATFORM) // thing is below FOF
{
if (bottomheight < opentop) {
opentop = bottomheight;
@@ -733,7 +733,7 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
highceiling = bottomheight;
}
- if (delta1 < delta2 && !(rover->flags & FF_REVERSEPLATFORM)) // thing is above FOF
+ if (delta1 < delta2 && (rover->flags & FF_INTANGABLEFLATS) != FF_REVERSEPLATFORM) // thing is above FOF
{
if (topheight > openbottom) {
openbottom = topheight;
diff --git a/src/p_mobj.c b/src/p_mobj.c
index 5c4609f046907792f771e6fc119fc4772e712b71..498cf897ef1a42a5e2d0c7b22617d2555974612e 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -1578,7 +1578,7 @@ fixed_t P_GetMobjGravity(mobj_t *mo)
// Goop has slower, reversed gravity
if (goopgravity)
- gravityadd = -gravityadd/5;
+ gravityadd = -((gravityadd/5) + (gravityadd/8));
gravityadd = FixedMul(gravityadd, mo->scale);
@@ -1861,6 +1861,9 @@ void P_XYMovement(mobj_t *mo)
oldy = mo->y;
#ifdef ESLOPE
+ if (mo->flags & MF_NOCLIPHEIGHT)
+ mo->standingslope = NULL;
+
// adjust various things based on slope
if (mo->standingslope && abs(mo->standingslope->zdelta) > FRACUNIT>>8) {
if (!P_IsObjectOnGround(mo)) { // We fell off at some point? Do the twisty thing!
@@ -1990,6 +1993,8 @@ void P_XYMovement(mobj_t *mo)
{
mo->momz = transfermomz;
mo->standingslope = NULL;
+ if (player->pflags & PF_SPINNING)
+ player->pflags |= PF_THOKKED;
}
}
#endif
@@ -2049,7 +2054,7 @@ void P_XYMovement(mobj_t *mo)
return;
#ifdef ESLOPE
- if (moved && oldslope) { // Check to see if we ran off
+ if (moved && oldslope && !(mo->flags & MF_NOCLIPHEIGHT)) { // Check to see if we ran off
if (oldslope != mo->standingslope) { // First, compare different slopes
angle_t oldangle, newangle;
@@ -2222,7 +2227,7 @@ void P_AdjustMobjFloorZ_FFloors(mobj_t *mo, sector_t *sector, UINT8 motype)
topheight = P_GetFOFTopZ(mo, sector, rover, mo->x, mo->y, NULL);
bottomheight = P_GetFOFBottomZ(mo, sector, rover, mo->x, mo->y, NULL);
- if (mo->player && (P_CheckSolidLava(mo, rover) || P_CanRunOnWater(mo->player, rover))) // only the player should stand on lava or run on water
+ if (mo->player && (P_CheckSolidLava(rover) || P_CanRunOnWater(mo->player, rover))) // only the player should stand on lava or run on water
;
else if (motype != 0 && rover->flags & FF_SWIMMABLE) // "scenery" only
continue;
@@ -2369,9 +2374,9 @@ boolean P_CheckDeathPitCollide(mobj_t *mo)
return false;
if (((mo->z <= mo->subsector->sector->floorheight
- && !(mo->eflags & MFE_VERTICALFLIP) && (mo->subsector->sector->flags & SF_FLIPSPECIAL_FLOOR))
+ && ((mo->subsector->sector->flags & SF_TRIGGERSPECIAL_HEADBUMP) || !(mo->eflags & MFE_VERTICALFLIP)) && (mo->subsector->sector->flags & SF_FLIPSPECIAL_FLOOR))
|| (mo->z + mo->height >= mo->subsector->sector->ceilingheight
- && (mo->eflags & MFE_VERTICALFLIP) && (mo->subsector->sector->flags & SF_FLIPSPECIAL_CEILING)))
+ && ((mo->subsector->sector->flags & SF_TRIGGERSPECIAL_HEADBUMP) || (mo->eflags & MFE_VERTICALFLIP)) && (mo->subsector->sector->flags & SF_FLIPSPECIAL_CEILING)))
&& (GETSECSPECIAL(mo->subsector->sector->special, 1) == 6
|| GETSECSPECIAL(mo->subsector->sector->special, 1) == 7))
return true;
@@ -2379,43 +2384,11 @@ boolean P_CheckDeathPitCollide(mobj_t *mo)
return false;
}
-boolean P_CheckSolidLava(mobj_t *mo, ffloor_t *rover)
+boolean P_CheckSolidLava(ffloor_t *rover)
{
- fixed_t topheight;
-
- I_Assert(mo != NULL);
- I_Assert(!P_MobjWasRemoved(mo));
-
- // not a lava block with solid planes
- if (!(rover->flags & FF_SWIMMABLE && GETSECSPECIAL(rover->master->frontsector->special, 1) == 3
- && !(rover->master->flags & ML_BLOCKMONSTERS)))
- return false;
-
- // is solid from the sides
- if (rover->master->flags & ML_EFFECT3)
- return true;
-
- if (mo->eflags & MFE_VERTICALFLIP)
- {
- topheight =
- #ifdef ESLOPE
- *rover->b_slope ? P_GetZAt(*rover->b_slope, mo->x, mo->y) :
- #endif
- *rover->bottomheight;
-
- if (mo->z+mo->height-mo->momz < topheight + FixedMul(16*FRACUNIT, mo->scale))
- return true;
- return false;
- }
-
- topheight =
- #ifdef ESLOPE
- *rover->t_slope ? P_GetZAt(*rover->t_slope, mo->x, mo->y) :
- #endif
- *rover->topheight;
-
- if (mo->z-mo->momz > topheight - FixedMul(16*FRACUNIT, mo->scale))
- return true;
+ if (rover->flags & FF_SWIMMABLE && GETSECSPECIAL(rover->master->frontsector->special, 1) == 3
+ && !(rover->master->flags & ML_BLOCKMONSTERS))
+ return true;
return false;
}
@@ -2489,16 +2462,6 @@ static boolean P_ZMovement(mobj_t *mo)
P_RemoveMobj(mo);
return false;
}
- if (mo->momz
- && !(mo->flags & MF_NOGRAVITY)
- && ((!(mo->eflags & MFE_VERTICALFLIP) && mo->z <= mo->floorz)
- || ((mo->eflags & MFE_VERTICALFLIP) && mo->z+mo->height >= mo->ceilingz)))
- {
- mo->flags |= MF_NOGRAVITY;
- mo->momx = 8; // this is a hack which is used to ensure it still behaves as a missile and can damage others
- mo->momy = mo->momz = 0;
- mo->z = ((mo->eflags & MFE_VERTICALFLIP) ? mo->ceilingz-mo->height : mo->floorz);
- }
break;
case MT_GOOP:
if (P_CheckDeathPitCollide(mo))
@@ -2600,19 +2563,30 @@ static boolean P_ZMovement(mobj_t *mo)
if (!mo->player && P_CheckDeathPitCollide(mo))
{
- if (mo->flags & MF_ENEMY || mo->flags & MF_BOSS || mo->type == MT_MINECART)
+ switch (mo->type)
{
- // Kill enemies, bosses and minecarts that fall into death pits.
- if (mo->health)
- {
- P_KillMobj(mo, NULL, NULL, 0);
- return false;
- }
- }
- else
- {
- P_RemoveMobj(mo);
- return false;
+ case MT_GHOST:
+ case MT_METALSONIC_RACE:
+ case MT_EXPLODE:
+ case MT_BOSSEXPLODE:
+ case MT_SONIC3KBOSSEXPLODE:
+ break;
+ default:
+ if (mo->flags & MF_ENEMY || mo->flags & MF_BOSS || mo->type == MT_MINECART)
+ {
+ // Kill enemies, bosses and minecarts that fall into death pits.
+ if (mo->health)
+ {
+ P_KillMobj(mo, NULL, NULL, 0);
+ }
+ return false;
+ }
+ else
+ {
+ P_RemoveMobj(mo);
+ return false;
+ }
+ break;
}
}
@@ -3344,13 +3318,13 @@ void P_MobjCheckWater(mobj_t *mobj)
ffloor_t *rover;
player_t *p = mobj->player; // Will just be null if not a player.
fixed_t height = (p ? P_GetPlayerHeight(p) : mobj->height); // for players, calculation height does not necessarily match actual height for gameplay reasons (spin, etc)
- boolean wasgroundpounding = (p && (mobj->eflags & MFE_GOOWATER) && ((p->powers[pw_shield] & SH_NOSTACK) == SH_ELEMENTAL || (p->powers[pw_shield] & SH_NOSTACK) == SH_BUBBLEWRAP) && (p->pflags & PF_SHIELDABILITY));
+ boolean wasgroundpounding = (p && ((p->powers[pw_shield] & SH_NOSTACK) == SH_ELEMENTAL || (p->powers[pw_shield] & SH_NOSTACK) == SH_BUBBLEWRAP) && (p->pflags & PF_SHIELDABILITY));
// Default if no water exists.
mobj->watertop = mobj->waterbottom = mobj->z - 1000*FRACUNIT;
// Reset water state.
- mobj->eflags &= ~(MFE_UNDERWATER|MFE_TOUCHWATER|MFE_GOOWATER);
+ mobj->eflags &= ~(MFE_UNDERWATER|MFE_TOUCHWATER|MFE_GOOWATER|MFE_TOUCHLAVA);
for (rover = sector->ffloors; rover; rover = rover->next)
{
@@ -3391,16 +3365,18 @@ void P_MobjCheckWater(mobj_t *mobj)
// Just touching the water?
if (((mobj->eflags & MFE_VERTICALFLIP) && thingtop - height < bottomheight)
|| (!(mobj->eflags & MFE_VERTICALFLIP) && mobj->z + height > topheight))
- {
mobj->eflags |= MFE_TOUCHWATER;
- if (rover->flags & FF_GOOWATER && !(mobj->flags & MF_NOGRAVITY))
- mobj->eflags |= MFE_GOOWATER;
- }
+
// Actually in the water?
if (((mobj->eflags & MFE_VERTICALFLIP) && thingtop - (height>>1) > bottomheight)
|| (!(mobj->eflags & MFE_VERTICALFLIP) && mobj->z + (height>>1) < topheight))
- {
mobj->eflags |= MFE_UNDERWATER;
+
+ if (mobj->eflags & (MFE_TOUCHWATER|MFE_UNDERWATER))
+ {
+ if (GETSECSPECIAL(rover->master->frontsector->special, 1) == 3)
+ mobj->eflags |= MFE_TOUCHLAVA;
+
if (rover->flags & FF_GOOWATER && !(mobj->flags & MF_NOGRAVITY))
mobj->eflags |= MFE_GOOWATER;
}
@@ -3442,7 +3418,7 @@ void P_MobjCheckWater(mobj_t *mobj)
p->powers[pw_underwater] = underwatertics + 1;
}
- if (wasgroundpounding)
+ if ((wasgroundpounding = ((mobj->eflags & MFE_GOOWATER) && wasgroundpounding)))
{
p->pflags &= ~PF_SHIELDABILITY;
mobj->momz >>= 1;
@@ -3464,9 +3440,18 @@ void P_MobjCheckWater(mobj_t *mobj)
|| ((mobj->eflags & MFE_VERTICALFLIP) && mobj->ceilingz-mobj->waterbottom <= height>>1))
return;
- if (!wasgroundpounding && (mobj->eflags & MFE_GOOWATER || wasingoo)) { // Decide what happens to your momentum when you enter/leave goopy water.
- if (P_MobjFlip(mobj)*mobj->momz < 0) // You are entering the goo?
- mobj->momz = FixedMul(mobj->momz, FixedDiv(2*FRACUNIT, 5*FRACUNIT)); // kill momentum significantly, to make the goo feel thick.
+ if (mobj->eflags & MFE_GOOWATER || wasingoo) { // Decide what happens to your momentum when you enter/leave goopy water.
+ if (P_MobjFlip(mobj)*mobj->momz > 0)
+ {
+ mobj->momz -= (mobj->momz/8); // cut momentum a little bit to prevent multiple bobs
+ //CONS_Printf("leaving\n");
+ }
+ else
+ {
+ if (!wasgroundpounding)
+ mobj->momz >>= 1; // kill momentum significantly, to make the goo feel thick.
+ //CONS_Printf("entering\n");
+ }
}
else if (wasinwater && P_MobjFlip(mobj)*mobj->momz > 0)
mobj->momz = FixedMul(mobj->momz, FixedDiv(780*FRACUNIT, 457*FRACUNIT)); // Give the mobj a little out-of-water boost.
@@ -3478,14 +3463,15 @@ void P_MobjCheckWater(mobj_t *mobj)
{
// Spawn a splash
mobj_t *splish;
+ mobjtype_t splishtype = (mobj->eflags & MFE_TOUCHLAVA) ? MT_LAVASPLISH : MT_SPLISH;
if (mobj->eflags & MFE_VERTICALFLIP)
{
- splish = P_SpawnMobj(mobj->x, mobj->y, mobj->waterbottom-FixedMul(mobjinfo[MT_SPLISH].height, mobj->scale), MT_SPLISH);
+ splish = P_SpawnMobj(mobj->x, mobj->y, mobj->waterbottom-FixedMul(mobjinfo[splishtype].height, mobj->scale), splishtype);
splish->flags2 |= MF2_OBJECTFLIP;
splish->eflags |= MFE_VERTICALFLIP;
}
else
- splish = P_SpawnMobj(mobj->x, mobj->y, mobj->watertop, MT_SPLISH);
+ splish = P_SpawnMobj(mobj->x, mobj->y, mobj->watertop, splishtype);
splish->destscale = mobj->scale;
P_SetScale(splish, mobj->scale);
}
@@ -3513,14 +3499,15 @@ void P_MobjCheckWater(mobj_t *mobj)
{
// Spawn a splash
mobj_t *splish;
+ mobjtype_t splishtype = (mobj->eflags & MFE_TOUCHLAVA) ? MT_LAVASPLISH : MT_SPLISH;
if (mobj->eflags & MFE_VERTICALFLIP)
{
- splish = P_SpawnMobj(mobj->x, mobj->y, mobj->waterbottom-FixedMul(mobjinfo[MT_SPLISH].height, mobj->scale), MT_SPLISH);
+ splish = P_SpawnMobj(mobj->x, mobj->y, mobj->waterbottom-FixedMul(mobjinfo[splishtype].height, mobj->scale), splishtype);
splish->flags2 |= MF2_OBJECTFLIP;
splish->eflags |= MFE_VERTICALFLIP;
}
else
- splish = P_SpawnMobj(mobj->x, mobj->y, mobj->watertop, MT_SPLISH);
+ splish = P_SpawnMobj(mobj->x, mobj->y, mobj->watertop, splishtype);
splish->destscale = mobj->scale;
P_SetScale(splish, mobj->scale);
}
@@ -3536,6 +3523,8 @@ void P_MobjCheckWater(mobj_t *mobj)
if (mobj->eflags & MFE_GOOWATER || wasingoo)
S_StartSound(mobj, sfx_ghit);
+ else if (mobj->eflags & MFE_TOUCHLAVA)
+ S_StartSound(mobj, sfx_splash);
else
S_StartSound(mobj, sfx_splish); // And make a sound!
@@ -4146,6 +4135,45 @@ void P_RainThinker(precipmobj_t *mobj)
P_SetPrecipMobjState(mobj, S_SPLASH1);
}
+static void P_KillRingsInLava(mobj_t *mo)
+{
+ msecnode_t *node;
+ I_Assert(mo != NULL);
+ I_Assert(!P_MobjWasRemoved(mo));
+
+ // go through all sectors being touched by the ring
+ for (node = mo->touching_sectorlist; node; node = node->m_sectorlist_next)
+ {
+ if (!node->m_sector)
+ break;
+
+ if (node->m_sector->ffloors)
+ {
+ ffloor_t *rover;
+ fixed_t topheight, bottomheight;
+
+ for (rover = node->m_sector->ffloors; rover; rover = rover->next) // go through all fofs in the sector
+ {
+ if (!(rover->flags & FF_EXISTS)) continue; // fof must be real
+
+ if (!(rover->flags & FF_SWIMMABLE // fof must be water
+ && GETSECSPECIAL(rover->master->frontsector->special, 1) == 3)) // fof must be lava water
+ continue;
+
+ // find heights of FOF
+ topheight = P_GetFOFTopZ(mo, node->m_sector, rover, mo->x, mo->y, NULL);
+ bottomheight = P_GetFOFBottomZ(mo, node->m_sector, rover, mo->x, mo->y, NULL);
+
+ if (mo->z <= topheight && mo->z + mo->height >= bottomheight) // if ring touches it, KILL IT
+ {
+ P_KillMobj(mo, NULL, NULL, DMG_FIRE);
+ return;
+ }
+ }
+ }
+ }
+}
+
static void P_RingThinker(mobj_t *mobj)
{
if (mobj->momx || mobj->momy)
@@ -4694,13 +4722,17 @@ static void P_Boss4MoveSpikeballs(mobj_t *mobj, angle_t angle, fixed_t fz)
}
}
+#define CEZ3TILT
+
// Pull them closer.
static void P_Boss4PinchSpikeballs(mobj_t *mobj, angle_t angle, fixed_t dz)
{
INT32 s;
mobj_t *base = mobj, *seg;
- fixed_t originx, originy, workx, worky, dx, dy, bz = mobj->watertop+(8<<FRACBITS);
-
+ fixed_t workx, worky, dx, dy, bz = mobj->watertop+(8<<FRACBITS);
+ fixed_t rad = (9*132)<<FRACBITS;
+#ifdef CEZ3TILT
+ fixed_t originx, originy;
if (mobj->spawnpoint)
{
originx = mobj->spawnpoint->x << FRACBITS;
@@ -4711,13 +4743,25 @@ static void P_Boss4PinchSpikeballs(mobj_t *mobj, angle_t angle, fixed_t dz)
originx = mobj->x;
originy = mobj->y;
}
+#else
+ if (mobj->spawnpoint)
+ {
+ rad -= R_PointToDist2(mobj->x, mobj->y,
+ (mobj->spawnpoint->x<<FRACBITS), (mobj->spawnpoint->y<<FRACBITS));
+ }
+#endif
dz /= 9;
while ((base = base->tracer)) // there are 10 per spoke, remember that
{
- dx = (originx + P_ReturnThrustX(mobj, angle, (9*132)<<FRACBITS) - mobj->x)/9;
- dy = (originy + P_ReturnThrustY(mobj, angle, (9*132)<<FRACBITS) - mobj->y)/9;
+#ifdef CEZ3TILT
+ dx = (originx + P_ReturnThrustX(mobj, angle, rad) - mobj->x)/9;
+ dy = (originy + P_ReturnThrustY(mobj, angle, rad) - mobj->y)/9;
+#else
+ dx = P_ReturnThrustX(mobj, angle, rad)/9;
+ dy = P_ReturnThrustY(mobj, angle, rad)/9;
+#endif
workx = mobj->x + P_ReturnThrustX(mobj, angle, (112)<<FRACBITS);
worky = mobj->y + P_ReturnThrustY(mobj, angle, (112)<<FRACBITS);
for (seg = base, s = 9; seg; seg = seg->hnext, --s)
@@ -4907,6 +4951,7 @@ static void P_Boss4Thinker(mobj_t *mobj)
mobj->movecount += mobj->threshold;
if (mobj->movecount <= 0)
{
+ mobj->flags2 &= ~MF2_INVERTAIMABLE;
mobj->movecount = 0;
mobj->movedir++; // Initialization complete, next phase!
}
@@ -5533,9 +5578,9 @@ static void P_Boss9Thinker(mobj_t *mobj)
P_InstaThrust(mobj, mobj->angle, -4*FRACUNIT);
P_TryMove(mobj, mobj->x+mobj->momx, mobj->y+mobj->momy, true);
mobj->momz -= gravity;
- if (mobj->z < mobj->watertop)
+ if (mobj->z < mobj->watertop || mobj->z < (mobj->floorz + 16*FRACUNIT))
{
- mobj->watertop = mobj->target->floorz + 32*FRACUNIT;
+ mobj->watertop = mobj->floorz + 32*FRACUNIT;
P_SetMobjState(mobj, mobj->info->spawnstate);
}
return;
@@ -5543,16 +5588,22 @@ static void P_Boss9Thinker(mobj_t *mobj)
if ((!mobj->target || !(mobj->target->flags & MF_SHOOTABLE)))
{
- if (mobj->tracer)
- P_RemoveMobj(mobj->tracer);
+ if (mobj->hprev)
+ {
+ P_RemoveMobj(mobj->hprev);
+ P_SetTarget(&mobj->hprev, NULL);
+ }
P_BossTargetPlayer(mobj, false);
if (mobj->target && (!P_IsObjectOnGround(mobj->target) || mobj->target->player->pflags & PF_SPINNING))
P_SetTarget(&mobj->target, NULL); // Wait for them to hit the ground first
if (!mobj->target) // Still no target, aww.
{
// Reset the boss.
- if (mobj->tracer)
- P_RemoveMobj(mobj->tracer);
+ if (mobj->hprev)
+ {
+ P_RemoveMobj(mobj->hprev);
+ P_SetTarget(&mobj->hprev, NULL);
+ }
P_SetMobjState(mobj, mobj->info->spawnstate);
mobj->fuse = 0;
mobj->momx = FixedDiv(mobj->momx, FRACUNIT + (FRACUNIT>>2));
@@ -5566,7 +5617,7 @@ static void P_Boss9Thinker(mobj_t *mobj)
return;
}
else if (!mobj->fuse)
- mobj->fuse = 10*TICRATE;
+ mobj->fuse = 8*TICRATE;
}
// AI goes here.
@@ -5593,16 +5644,18 @@ static void P_Boss9Thinker(mobj_t *mobj)
mobj->angle -= InvAngle(angle)/8;
// Alter your energy bubble's size/position
- if (mobj->health > 3)
+ if (mobj->health > mobj->info->damage)
{
- mobj->tracer->destscale = FRACUNIT + (4*TICRATE - mobj->fuse)*(FRACUNIT/2)/TICRATE + FixedMul(FINECOSINE(angle>>ANGLETOFINESHIFT),FRACUNIT/2);
- P_SetScale(mobj->tracer, mobj->tracer->destscale);
- }
+ if (mobj->hprev)
+ {
+ mobj->hprev->destscale = FRACUNIT + (2*TICRATE - mobj->fuse)*(FRACUNIT/2)/TICRATE + FixedMul(FINECOSINE(angle>>ANGLETOFINESHIFT),FRACUNIT/2);
+ P_SetScale(mobj->hprev, mobj->hprev->destscale);
- P_TeleportMove(mobj->tracer, mobj->x, mobj->y, mobj->z + mobj->height/2 - mobj->tracer->height/2);
- mobj->tracer->momx = mobj->momx;
- mobj->tracer->momy = mobj->momy;
- mobj->tracer->momz = mobj->momz;
+ P_TeleportMove(mobj->hprev, mobj->x, mobj->y, mobj->z + mobj->height/2 - mobj->hprev->height/2);
+ mobj->hprev->momx = mobj->momx;
+ mobj->hprev->momy = mobj->momy;
+ mobj->hprev->momz = mobj->momz;
+ }
// Firin' mah lazors - INDICATOR
if (mobj->fuse > TICRATE/2)
@@ -5690,6 +5743,7 @@ static void P_Boss9Thinker(mobj_t *mobj)
S_StartSound(mobj, sfx_s3kb3);
}
}
+ }
// up...
mobj->z += mobj->height/2;
@@ -5716,12 +5770,12 @@ static void P_Boss9Thinker(mobj_t *mobj)
if (mobj->health > mobj->info->damage)
{
P_SetScale(missile, FRACUNIT/3);
- missile->color = SKINCOLOR_GOLD; // sonic cd electric power
+ missile->color = SKINCOLOR_MAGENTA; // sonic OVA/4 purple power
}
else
{
P_SetScale(missile, FRACUNIT/5);
- missile->color = SKINCOLOR_MAGENTA; // sonic OVA/4 purple power
+ missile->color = SKINCOLOR_SUNSET; // sonic cd electric power
}
missile->destscale = missile->scale*2;
missile->scalespeed = abs(missile->scale - missile->destscale)/missile->fuse;
@@ -5740,8 +5794,10 @@ static void P_Boss9Thinker(mobj_t *mobj)
if (mobj->movedir == 0 || mobj->movedir == 2) { // Pausing between bounces in the pinball phase
if (mobj->target->player->powers[pw_tailsfly]) // Trying to escape, eh?
mobj->watertop = mobj->target->z + mobj->target->momz*6; // Readjust your aim. >:3
- else
+ else if (mobj->target->floorz > mobj->floorz)
mobj->watertop = mobj->target->floorz + 16*FRACUNIT;
+ else
+ mobj->watertop = mobj->floorz + 16*FRACUNIT;
if (!(mobj->threshold%4)) {
mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x + mobj->target->momx*4, mobj->target->y + mobj->target->momy*4);
@@ -5833,8 +5889,6 @@ static void P_Boss9Thinker(mobj_t *mobj)
return;
}
- P_SpawnGhostMobj(mobj);
-
// Pinball attack!
if (mobj->movecount == 3 && (mobj->movedir == 0 || mobj->movedir == 2))
{
@@ -5849,20 +5903,20 @@ static void P_Boss9Thinker(mobj_t *mobj)
if (!P_TryMove(mobj, mobj->x+mobj->momx, mobj->y+mobj->momy, true))
{ // Hit a wall? Find a direction to bounce
mobj->threshold--;
- P_SetMobjState(mobj, mobj->state->nextstate);
if (!mobj->threshold) { // failed bounce!
S_StartSound(mobj, sfx_mspogo);
P_BounceMove(mobj);
mobj->angle = R_PointToAngle2(mobj->momx, mobj->momy,0,0);
mobj->momz = 4*FRACUNIT;
mobj->flags &= ~MF_PAIN;
- mobj->fuse = 10*TICRATE;
+ mobj->fuse = 8*TICRATE;
mobj->movecount = 0;
P_SpawnMobjFromMobj(mobj, 0, 0, 0, MT_CYBRAKDEMON_VILE_EXPLOSION);
P_SetMobjState(mobj, mobj->info->meleestate);
}
else if (!(mobj->threshold%4))
{ // We've decided to lock onto the player this bounce.
+ P_SetMobjState(mobj, mobj->state->nextstate);
S_StartSound(mobj, sfx_s3k5a);
mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x + mobj->target->momx*4, mobj->target->y + mobj->target->momy*4);
mobj->reactiontime = TICRATE - 5*(mobj->info->damage - mobj->health); // targetting time
@@ -5879,6 +5933,8 @@ static void P_Boss9Thinker(mobj_t *mobj)
return;
}
+ P_SpawnGhostMobj(mobj)->colorized = false;
+
// Vector form dodge!
mobj->angle += mobj->movedir;
P_InstaThrust(mobj, mobj->angle, -speed);
@@ -5975,7 +6031,7 @@ static void P_Boss9Thinker(mobj_t *mobj)
if (mobj->health > mobj->info->damage)
{ // No more bubble if we're broken (pinch phase)
mobj_t *shield = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_MSSHIELD_FRONT);
- P_SetTarget(&mobj->tracer, shield);
+ P_SetTarget(&mobj->hprev, shield);
P_SetTarget(&shield->target, mobj);
// Attack 2: Energy shot!
@@ -6006,14 +6062,15 @@ static void P_Boss9Thinker(mobj_t *mobj)
}
else
{
- mobj_t *shield = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_MSSHIELD_FRONT);
+ /*mobj_t *shield = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_MSSHIELD_FRONT);
P_SetTarget(&mobj->tracer, shield);
P_SetTarget(&shield->target, mobj);
shield->height -= 20*FRACUNIT; // different offset...
- P_SetMobjState(shield, S_MSSHIELD_F2);
+ P_SetMobjState(shield, S_MSSHIELD_F2);*/
+ P_SetMobjState(mobj, S_METALSONIC_BOUNCE);
//P_LinedefExecute(LE_PINCHPHASE, mobj, NULL); -- why does this happen twice? see case 2...
}
- mobj->fuse = 4*TICRATE;
+ mobj->fuse = 3*TICRATE;
mobj->flags |= MF_PAIN;
if (mobj->info->attacksound)
S_StartSound(mobj, mobj->info->attacksound);
@@ -6024,14 +6081,14 @@ static void P_Boss9Thinker(mobj_t *mobj)
case 2:
{
// We're all charged and ready now! Unleash the fury!!
- mobj_t *removemobj = mobj->tracer;
S_StopSound(mobj);
- P_SetTarget(&mobj->tracer, mobj->hnext);
- P_RemoveMobj(removemobj);
+ if (mobj->hprev)
+ {
+ P_RemoveMobj(mobj->hprev);
+ P_SetTarget(&mobj->hprev, NULL);
+ }
if (mobj->health <= mobj->info->damage)
{
- mobj_t *whoosh;
-
// Attack 1: Pinball dash!
if (mobj->health == 1)
mobj->movedir = 0;
@@ -6044,9 +6101,13 @@ static void P_Boss9Thinker(mobj_t *mobj)
mobj->threshold = 12; // bounce 12 times
else
mobj->threshold = 24; // bounce 24 times
- mobj->watertop = mobj->target->floorz + 16*FRACUNIT;
+ if (mobj->floorz >= mobj->target->floorz)
+ mobj->watertop = mobj->floorz + 16*FRACUNIT;
+ else
+ mobj->watertop = mobj->target->floorz + 16*FRACUNIT;
P_LinedefExecute(LE_PINCHPHASE, mobj, NULL);
+#if 0
whoosh = P_SpawnMobjFromMobj(mobj, 0, 0, 0, MT_GHOST); // done here so the offset is correct
whoosh->frame = FF_FULLBRIGHT;
whoosh->sprite = SPR_ARMA;
@@ -6054,9 +6115,13 @@ static void P_Boss9Thinker(mobj_t *mobj)
whoosh->scalespeed = FixedMul(whoosh->scalespeed, whoosh->scale);
whoosh->height = 38*whoosh->scale;
whoosh->fuse = 10;
- whoosh->color = SKINCOLOR_MAGENTA;
+ whoosh->color = SKINCOLOR_SUNSET;
whoosh->colorized = true;
whoosh->flags |= MF_NOCLIPHEIGHT;
+#endif
+
+ P_SetMobjState(mobj->tracer, S_JETFUMEFLASH);
+ P_SetScale(mobj->tracer, mobj->scale << 1);
}
else
{
@@ -6068,10 +6133,13 @@ static void P_Boss9Thinker(mobj_t *mobj)
}
case 3:
// Return to idle.
- mobj->watertop = mobj->target->floorz + 32*FRACUNIT;
+ if (mobj->floorz >= mobj->target->floorz)
+ mobj->watertop = mobj->floorz + 32*FRACUNIT;
+ else
+ mobj->watertop = mobj->target->floorz + 32*FRACUNIT;
P_SetMobjState(mobj, mobj->info->spawnstate);
mobj->flags &= ~MF_PAIN;
- mobj->fuse = 10*TICRATE;
+ mobj->fuse = 8*TICRATE;
break;
}
mobj->movecount++;
@@ -6873,7 +6941,7 @@ void P_RunOverlays(void)
mo->eflags = (mo->eflags & ~MFE_VERTICALFLIP) | (mo->target->eflags & MFE_VERTICALFLIP);
mo->scale = mo->destscale = mo->target->scale;
- mo->angle = mo->target->angle;
+ mo->angle = mo->target->angle + mo->movedir;
if (!(mo->state->frame & FF_ANIMATE))
zoffs = FixedMul(((signed)mo->state->var2)*FRACUNIT, mo->scale);
@@ -7054,6 +7122,16 @@ void P_HandleMinecartSegments(mobj_t *mobj)
P_UpdateMinecartSegments(mobj);
}
+static void P_PyreFlyBurn(mobj_t *mobj, fixed_t hoffs, INT16 vrange, mobjtype_t mobjtype, fixed_t momz)
+{
+ angle_t fa = (FixedAngle(P_RandomKey(360)*FRACUNIT) >> ANGLETOFINESHIFT) & FINEMASK;
+ fixed_t xoffs = FixedMul(FINECOSINE(fa), mobj->radius + hoffs);
+ fixed_t yoffs = FixedMul(FINESINE(fa), mobj->radius + hoffs);
+ fixed_t zoffs = P_RandomRange(-vrange, vrange)*FRACUNIT;
+ mobj_t *particle = P_SpawnMobjFromMobj(mobj, xoffs, yoffs, zoffs, mobjtype);
+ particle->momz = momz;
+}
+
//
// P_MobjThinker
//
@@ -7520,6 +7598,7 @@ void P_MobjThinker(mobj_t *mobj)
mobj->fuse -= 2;
flame = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_FLAMEJETFLAME);
+ P_SetMobjState(flame, S_FLAMEJETFLAME4);
flame->angle = mobj->angle;
@@ -7564,7 +7643,10 @@ void P_MobjThinker(mobj_t *mobj)
flame->momz = -strength;
}
else
+ {
flame->momz = strength;
+ P_SetMobjState(flame, S_FLAMEJETFLAME7);
+ }
P_InstaThrust(flame, mobj->angle, FixedDiv(mobj->fuse*FRACUNIT,3*FRACUNIT));
S_StartSound(flame, sfx_fire);
}
@@ -7619,6 +7701,7 @@ void P_MobjThinker(mobj_t *mobj)
case MT_ROCKCRUMBLE16:
case MT_WOODDEBRIS:
case MT_BRICKDEBRIS:
+ case MT_BROKENROBOT:
if (mobj->z <= P_FloorzAtPos(mobj->x, mobj->y, mobj->z, mobj->height)
&& mobj->state != &states[mobj->info->deathstate])
{
@@ -7683,13 +7766,244 @@ void P_MobjThinker(mobj_t *mobj)
if (mobj->movedir)
mobj->angle += mobj->movedir;
break;
+ case MT_ROSY:
+ {
+ UINT8 i;
+ fixed_t pdist = 1700*mobj->scale, work, actualwork;
+ player_t *player = NULL;
+ statenum_t stat = (mobj->state-states);
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ if (!playeringame[i])
+ continue;
+ if (!players[i].mo)
+ continue;
+ if (players[i].bot)
+ continue;
+ if (!players[i].mo->health)
+ continue;
+ actualwork = work = FixedHypot(mobj->x-players[i].mo->x, mobj->y-players[i].mo->y);
+ if (player)
+ {
+ if (players[i].skin == 0 || players[i].skin == 5)
+ work = (2*work)/3;
+ if (work >= pdist)
+ continue;
+ }
+ pdist = actualwork;
+ player = &players[i];
+ }
+
+ if (stat == S_ROSY_JUMP || stat == S_ROSY_PAIN)
+ {
+ if (P_IsObjectOnGround(mobj))
+ {
+ mobj->momx = mobj->momy = 0;
+ if (player && mobj->cvmem < (-2*TICRATE))
+ stat = S_ROSY_UNHAPPY;
+ else
+ stat = S_ROSY_WALK;
+ P_SetMobjState(mobj, stat);
+ }
+ else if (P_MobjFlip(mobj)*mobj->momz < 0)
+ mobj->frame = mobj->state->frame+mobj->state->var1;
+ }
+
+ if (!player)
+ {
+ if ((stat < S_ROSY_IDLE1 || stat > S_ROSY_IDLE4) && stat != S_ROSY_JUMP)
+ {
+ mobj->momx = mobj->momy = 0;
+ P_SetMobjState(mobj, S_ROSY_IDLE1);
+ }
+ }
+ else
+ {
+ boolean dojump = false, targonground, love, makeheart = false;
+ if (mobj->target != player->mo)
+ P_SetTarget(&mobj->target, player->mo);
+ targonground = (P_IsObjectOnGround(mobj->target) && (player->panim == PA_IDLE || player->panim == PA_WALK || player->panim == PA_RUN));
+ love = (player->skin == 0 || player->skin == 5);
+
+ switch (stat)
+ {
+ case S_ROSY_IDLE1:
+ case S_ROSY_IDLE2:
+ case S_ROSY_IDLE3:
+ case S_ROSY_IDLE4:
+ dojump = true;
+ break;
+ case S_ROSY_JUMP:
+ case S_ROSY_PAIN:
+ // handled above
+ break;
+ case S_ROSY_WALK:
+ {
+ fixed_t x = mobj->x, y = mobj->y, z = mobj->z;
+ angle_t angletoplayer = R_PointToAngle2(x, y, mobj->target->x, mobj->target->y);
+ boolean allowed = P_TryMove(mobj, mobj->target->x, mobj->target->y, false);
+
+ P_UnsetThingPosition(mobj);
+ mobj->x = x;
+ mobj->y = y;
+ mobj->z = z;
+ P_SetThingPosition(mobj);
+
+ if (allowed)
+ {
+ fixed_t mom, max;
+ P_Thrust(mobj, angletoplayer, (3*FRACUNIT)>>1);
+ mom = FixedHypot(mobj->momx, mobj->momy);
+ max = pdist;
+ if ((--mobj->extravalue1) <= 0)
+ {
+ if (++mobj->frame > mobj->state->frame+mobj->state->var1)
+ mobj->frame = mobj->state->frame;
+ if (mom > 12*mobj->scale)
+ mobj->extravalue1 = 2;
+ else if (mom > 6*mobj->scale)
+ mobj->extravalue1 = 3;
+ else
+ mobj->extravalue1 = 4;
+ }
+ if (max < (mobj->radius + mobj->target->radius))
+ {
+ mobj->momx = mobj->target->player->cmomx;
+ mobj->momy = mobj->target->player->cmomy;
+ if ((mobj->cvmem > TICRATE && !player->exiting) || !targonground)
+ P_SetMobjState(mobj, (stat = S_ROSY_STND));
+ else
+ {
+ mobj->target->momx = mobj->momx;
+ mobj->target->momy = mobj->momy;
+ P_SetMobjState(mobj, (stat = S_ROSY_HUG));
+ S_StartSound(mobj, sfx_cdpcm6);
+ mobj->angle = angletoplayer;
+ }
+ }
+ else
+ {
+ max /= 3;
+ if (max > 30*mobj->scale)
+ max = 30*mobj->scale;
+ if (mom > max && max > mobj->scale)
+ {
+ max = FixedDiv(max, mom);
+ mobj->momx = FixedMul(mobj->momx, max);
+ mobj->momy = FixedMul(mobj->momy, max);
+ }
+ if (abs(mobj->momx) > mobj->scale || abs(mobj->momy) > mobj->scale)
+ mobj->angle = R_PointToAngle2(0, 0, mobj->momx, mobj->momy);
+ }
+ }
+ else
+ dojump = true;
+ }
+ break;
+ case S_ROSY_HUG:
+ if (targonground)
+ {
+ player->pflags |= PF_STASIS;
+ if (mobj->cvmem < 5*TICRATE)
+ mobj->cvmem++;
+ if (love && !(leveltime & 7))
+ makeheart = true;
+ }
+ else
+ {
+ if (mobj->cvmem < (love ? 5*TICRATE : 0))
+ {
+ P_SetMobjState(mobj, (stat = S_ROSY_PAIN));
+ S_StartSound(mobj, sfx_cdpcm7);
+ }
+ else
+ P_SetMobjState(mobj, (stat = S_ROSY_JUMP));
+ var1 = var2 = 0;
+ A_DoNPCPain(mobj);
+ mobj->cvmem -= TICRATE;
+ }
+ break;
+ case S_ROSY_STND:
+ if ((pdist > (mobj->radius + mobj->target->radius + 3*(mobj->scale + mobj->target->scale))))
+ P_SetMobjState(mobj, (stat = S_ROSY_WALK));
+ else if (!targonground)
+ ;
+ else
+ {
+ if (love && !(leveltime & 15))
+ makeheart = true;
+ if (player->exiting || --mobj->cvmem < TICRATE)
+ {
+ P_SetMobjState(mobj, (stat = S_ROSY_HUG));
+ S_StartSound(mobj, sfx_cdpcm6);
+ mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
+ mobj->target->momx = mobj->momx;
+ mobj->target->momy = mobj->momy;
+ }
+ }
+ break;
+ case S_ROSY_UNHAPPY:
+ default:
+ break;
+ }
+
+ if (stat == S_ROSY_HUG)
+ {
+ if (player->panim != PA_IDLE)
+ P_SetPlayerMobjState(mobj->target, S_PLAY_STND);
+ player->pflags |= PF_STASIS;
+ }
+
+ if (dojump)
+ {
+ P_SetMobjState(mobj, S_ROSY_JUMP);
+ mobj->z += P_MobjFlip(mobj);
+ mobj->momx = mobj->momy = 0;
+ P_SetObjectMomZ(mobj, 6<<FRACBITS, false);
+ S_StartSound(mobj, sfx_cdfm02);
+ }
+
+ if (makeheart)
+ {
+ mobj_t *cdlhrt = P_SpawnMobjFromMobj(mobj, 0, 0, mobj->height, MT_CDLHRT);
+ cdlhrt->destscale = (5*mobj->scale)>>4;
+ P_SetScale(cdlhrt, cdlhrt->destscale);
+ cdlhrt->fuse = (5*TICRATE)>>1;
+ cdlhrt->momz = mobj->scale;
+ P_SetTarget(&cdlhrt->target, mobj);
+ cdlhrt->extravalue1 = mobj->x;
+ cdlhrt->extravalue2 = mobj->y;
+ }
+ }
+ }
+ break;
+ case MT_CDLHRT:
+ {
+ if (mobj->cvmem < 24)
+ mobj->cvmem++;
+ mobj->movedir += ANG10;
+ P_UnsetThingPosition(mobj);
+ mobj->x = mobj->extravalue1 + P_ReturnThrustX(mobj, mobj->movedir, mobj->cvmem*mobj->scale);
+ mobj->y = mobj->extravalue2 + P_ReturnThrustY(mobj, mobj->movedir, mobj->cvmem*mobj->scale);
+ P_SetThingPosition(mobj);
+ if ((--mobj->fuse) < 6)
+ {
+ if (!mobj->fuse)
+ {
+ P_RemoveMobj(mobj);
+ return;
+ }
+ mobj->frame = (mobj->frame & ~FF_TRANSMASK)|((10-(mobj->fuse*2))<<(FF_TRANSSHIFT));
+ }
+ }
+ break;
case MT_VWREF:
case MT_VWREB:
{
INT32 strength;
++mobj->movedir;
mobj->frame &= ~FF_TRANSMASK;
- strength = min(mobj->fuse, mobj->movedir)*3;
+ strength = min(mobj->fuse, (INT32)mobj->movedir)*3;
if (strength < 10)
mobj->frame |= ((10-strength)<<(FF_TRANSSHIFT));
}
@@ -7984,6 +8298,20 @@ void P_MobjThinker(mobj_t *mobj)
P_SetObjectMomZ(mobj, -2 * FRACUNIT / 3, true);
}
break;
+ case MT_METALSONIC_RACE:
+ {
+ if (!(mobj->fuse % 8))
+ {
+ fixed_t r = mobj->radius >> FRACBITS;
+ mobj_t *explosion = P_SpawnMobj(
+ mobj->x + (P_RandomRange(r, -r) << FRACBITS),
+ mobj->y + (P_RandomRange(r, -r) << FRACBITS),
+ mobj->z + (P_RandomKey(mobj->height >> FRACBITS) << FRACBITS),
+ MT_SONIC3KBOSSEXPLODE);
+ S_StartSound(explosion, sfx_s3kb4);
+ }
+ P_SetObjectMomZ(mobj, -2 * FRACUNIT / 3, true);
+ }
default:
break;
}
@@ -8119,7 +8447,7 @@ void P_MobjThinker(mobj_t *mobj)
}
}
break;
- case MT_BUBBLEBUZZ:
+ case MT_BUGGLE:
mobj->eflags |= MFE_UNDERWATER; //P_MobjCheckWater(mobj); // solely for MFE_UNDERWATER for A_FlickySpawn
{
if (mobj->tracer && mobj->tracer->player && mobj->tracer->health > 0
@@ -8133,6 +8461,9 @@ void P_MobjThinker(mobj_t *mobj)
if (leveltime % mobj->info->painchance == 0)
S_StartSound(mobj, mobj->info->activesound);
+
+ if ((statenum_t)(mobj->state-states) != mobj->info->seestate)
+ P_SetMobjState(mobj, mobj->info->seestate);
}
else
{
@@ -8141,6 +8472,8 @@ void P_MobjThinker(mobj_t *mobj)
mobj->momx >>= 1;
mobj->momy >>= 1;
mobj->momz >>= 1;
+ if ((statenum_t)(mobj->state-states) != mobj->info->spawnstate)
+ P_SetMobjState(mobj, mobj->info->spawnstate);
}
}
break;
@@ -8426,11 +8759,17 @@ void P_MobjThinker(mobj_t *mobj)
}
else if (mobj->fuse == 59)
{
+ boolean dashmod = ((mobj->target->flags & MF_PAIN) && (mobj->target->health <= mobj->target->info->damage));
jetx = mobj->target->x + P_ReturnThrustX(mobj->target, mobj->target->angle, -mobj->target->radius);
jety = mobj->target->y + P_ReturnThrustY(mobj->target, mobj->target->angle, -mobj->target->radius);
P_UnsetThingPosition(mobj);
mobj->x = jetx;
mobj->y = jety;
+ mobj->destscale = mobj->target->scale;
+ if (!(dashmod && mobj->target->state == states+S_METALSONIC_BOUNCE))
+ {
+ mobj->destscale = (mobj->destscale + FixedDiv(R_PointToDist2(0, 0, mobj->target->momx, mobj->target->momy), 36*mobj->target->scale))/3;
+ }
if (mobj->target->eflags & MFE_VERTICALFLIP)
mobj->z = mobj->target->z + mobj->target->height/2 + mobj->height/2;
else
@@ -8438,6 +8777,14 @@ void P_MobjThinker(mobj_t *mobj)
mobj->floorz = mobj->z;
mobj->ceilingz = mobj->z+mobj->height;
P_SetThingPosition(mobj);
+ if (dashmod)
+ {
+ mobj->color = SKINCOLOR_SUNSET;
+ if (mobj->target->movecount == 3 && !mobj->target->reactiontime && (mobj->target->movedir == 0 || mobj->target->movedir == 2))
+ P_SpawnGhostMobj(mobj);
+ }
+ else
+ mobj->color = SKINCOLOR_ICY;
}
mobj->fuse++;
}
@@ -8896,13 +9243,17 @@ void P_MobjThinker(mobj_t *mobj)
}
break;
case MT_RING:
+ case MT_REDTEAMRING:
+ case MT_BLUETEAMRING:
+ P_KillRingsInLava(mobj);
+ if (P_MobjWasRemoved(mobj))
+ return;
+ /* FALLTHRU */
case MT_COIN:
case MT_BLUESPHERE:
case MT_BOMBSPHERE:
case MT_NIGHTSCHIP:
case MT_NIGHTSSTAR:
- case MT_REDTEAMRING:
- case MT_BLUETEAMRING:
// No need to check water. Who cares?
P_RingThinker(mobj);
if (mobj->flags2 & MF2_NIGHTSPULL)
@@ -8912,6 +9263,10 @@ void P_MobjThinker(mobj_t *mobj)
return;
// Flung items
case MT_FLINGRING:
+ P_KillRingsInLava(mobj);
+ if (P_MobjWasRemoved(mobj))
+ return;
+ /* FALLTHRU */
case MT_FLINGCOIN:
case MT_FLINGBLUESPHERE:
case MT_FLINGNIGHTSCHIP:
@@ -9113,6 +9468,161 @@ void P_MobjThinker(mobj_t *mobj)
}
mobj->flags2 ^= MF2_DONTDRAW;
break;
+ case MT_LAVAFALLROCK:
+ if (P_IsObjectOnGround(mobj))
+ P_RemoveMobj(mobj);
+ break;
+ case MT_PYREFLY:
+ {
+ fixed_t hdist;
+
+ mobj->extravalue1 = (mobj->extravalue1 + 3) % 360;
+ mobj->z += FINESINE(((mobj->extravalue1*ANG1) >> ANGLETOFINESHIFT) & FINEMASK);
+
+ if (!(mobj->flags2 & MF2_BOSSNOTRAP))
+ P_LookForPlayers(mobj, true, false, 1500*FRACUNIT);
+
+ if (!mobj->target)
+ break;
+
+ if (mobj->extravalue2 == 1)
+ P_PyreFlyBurn(mobj, 0, 20, MT_SMOKE, 4*FRACUNIT);
+ else if (mobj->extravalue2 == 2)
+ {
+ INT32 fireradius = min(100 - mobj->fuse, 52);
+ P_PyreFlyBurn(mobj, P_RandomRange(0, fireradius)*FRACUNIT, 20, MT_FLAMEPARTICLE, 4*FRACUNIT);
+ P_PyreFlyBurn(mobj, fireradius*FRACUNIT, 40, MT_PYREFLY_FIRE, 0);
+ }
+
+ hdist = R_PointToDist2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
+
+ if (hdist > 1500*FRACUNIT)
+ {
+ mobj->flags2 &= ~MF2_BOSSNOTRAP;
+ P_SetTarget(&mobj->target, NULL);
+ break;
+ }
+
+ if (!(mobj->flags2 & MF2_BOSSNOTRAP) && hdist <= 450*FRACUNIT)
+ mobj->flags2 |= MF2_BOSSNOTRAP;
+
+ if (!(mobj->flags2 & MF2_BOSSNOTRAP))
+ break;
+
+ if (hdist < 1000*FRACUNIT)
+ {
+ //Aim for player z position. If too close to floor/ceiling, aim just above/below them.
+ fixed_t destz = min(max(mobj->target->z, mobj->target->floorz + 70*FRACUNIT), mobj->target->ceilingz - 80*FRACUNIT - mobj->height);
+ fixed_t dist = P_AproxDistance(hdist, destz - mobj->z);
+ P_InstaThrust(mobj, R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y), 2*FRACUNIT);
+ mobj->momz = FixedMul(FixedDiv(destz - mobj->z, dist), 2*FRACUNIT);
+ }
+ else
+ {
+ mobj->momx = 0;
+ mobj->momy = 0;
+ mobj->momz = 0;
+ }
+ break;
+ }
+ case MT_PTERABYTE:
+ {
+ if (mobj->extravalue1 & 4) // Cooldown after grabbing
+ {
+ if (mobj->movefactor)
+ mobj->movefactor--;
+ else
+ {
+ P_SetTarget(&mobj->target, NULL);
+ mobj->extravalue1 &= 3;
+ }
+ }
+
+ if ((mobj->extravalue1 & 3) == 0) // Hovering
+ {
+ fixed_t vdist, hdist, time;
+ fixed_t hspeed = 3*mobj->info->speed;
+ angle_t fa;
+
+ var1 = 1;
+ var2 = 0;
+ A_CapeChase(mobj);
+
+ if (mobj->target)
+ break; // Still carrying a player or in cooldown
+
+ P_LookForPlayers(mobj, true, false, 256*FRACUNIT);
+
+ if (!mobj->target)
+ break;
+
+ if (mobj->target->player->powers[pw_flashing])
+ {
+ P_SetTarget(&mobj->target, NULL);
+ break;
+ }
+
+ vdist = mobj->z - mobj->target->z - mobj->target->height;
+ if (P_MobjFlip(mobj)*vdist <= 0)
+ {
+ P_SetTarget(&mobj->target, NULL);
+ break;
+ }
+
+ hdist = R_PointToDist2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
+ if (hdist > 450*FRACUNIT)
+ {
+ P_SetTarget(&mobj->target, NULL);
+ break;
+ }
+
+ P_SetMobjState(mobj, S_PTERABYTE_SWOOPDOWN);
+ mobj->extravalue1++;
+ S_StartSound(mobj, mobj->info->attacksound);
+ time = FixedDiv(hdist, hspeed);
+ mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
+ fa = (mobj->angle >> ANGLETOFINESHIFT) & FINEMASK;
+ mobj->momx = FixedMul(FINECOSINE(fa), hspeed);
+ mobj->momy = FixedMul(FINESINE(fa), hspeed);
+ mobj->momz = -2*FixedDiv(vdist, time);
+ mobj->extravalue2 = -FixedDiv(mobj->momz, time); //Z accel
+ mobj->movecount = time >> FRACBITS;
+ mobj->reactiontime = mobj->movecount;
+ }
+ else if ((mobj->extravalue1 & 3) == 1) // Swooping
+ {
+ mobj->reactiontime--;
+ mobj->momz += mobj->extravalue2;
+ if (mobj->reactiontime)
+ break;
+
+ if (mobj->state - states == S_PTERABYTE_SWOOPDOWN)
+ {
+ P_SetMobjState(mobj, S_PTERABYTE_SWOOPUP);
+ mobj->reactiontime = mobj->movecount;
+ }
+ else if (mobj->state - states == S_PTERABYTE_SWOOPUP)
+ {
+ P_SetMobjState(mobj, S_PTERABYTE_FLY1);
+ mobj->extravalue1++;
+ if (mobj->target && mobj->target->tracer != mobj)
+ P_SetTarget(&mobj->target, NULL); // Failed to grab the target
+ mobj->momx = mobj->momy = mobj->momz = 0;
+ }
+ }
+ else // Returning
+ {
+ var1 = 2*mobj->info->speed;
+ var2 = 1;
+ A_HomingChase(mobj);
+ if (P_AproxDistance(mobj->x - mobj->tracer->x, mobj->y - mobj->tracer->y) <= mobj->info->speed)
+ {
+ mobj->extravalue1 -= 2;
+ mobj->momx = mobj->momy = mobj->momz = 0;
+ }
+ }
+ break;
+ }
case MT_SPINFIRE:
if (mobj->flags & MF_NOGRAVITY)
{
@@ -9121,6 +9631,14 @@ void P_MobjThinker(mobj_t *mobj)
else
mobj->z = mobj->floorz;
}
+ else if ((!(mobj->eflags & MFE_VERTICALFLIP) && mobj->z <= mobj->floorz)
+ || ((mobj->eflags & MFE_VERTICALFLIP) && mobj->z+mobj->height >= mobj->ceilingz))
+ {
+ mobj->flags |= MF_NOGRAVITY;
+ mobj->momx = 8; // this is a hack which is used to ensure it still behaves as a missile and can damage others
+ mobj->momy = mobj->momz = 0;
+ mobj->z = ((mobj->eflags & MFE_VERTICALFLIP) ? mobj->ceilingz-mobj->height : mobj->floorz);
+ }
/* FALLTHRU */
default:
// check mobj against possible water content, before movement code
@@ -9343,6 +9861,52 @@ for (i = ((mobj->flags2 & MF2_STRONGBOX) ? strongboxamt : weakboxamt); i; --i) s
case MT_NIGHTSCORE:
P_RemoveMobj(mobj);
return;
+ case MT_LAVAFALL:
+ if (mobj->state - states == S_LAVAFALL_DORMANT)
+ {
+ mobj->fuse = 30;
+ P_SetMobjState(mobj, S_LAVAFALL_TELL);
+ S_StartSound(mobj, mobj->info->seesound);
+ }
+ else if (mobj->state - states == S_LAVAFALL_TELL)
+ {
+ mobj->fuse = 40;
+ P_SetMobjState(mobj, S_LAVAFALL_SHOOT);
+ S_StopSound(mobj);
+ S_StartSound(mobj, mobj->info->attacksound);
+ }
+ else
+ {
+ mobj->fuse = 30;
+ P_SetMobjState(mobj, S_LAVAFALL_DORMANT);
+ S_StopSound(mobj);
+ }
+ return;
+ case MT_PYREFLY:
+ if (mobj->health <= 0)
+ break;
+
+ mobj->extravalue2 = (mobj->extravalue2 + 1) % 3;
+ if (mobj->extravalue2 == 0)
+ {
+ P_SetMobjState(mobj, mobj->info->spawnstate);
+ mobj->fuse = 100;
+ S_StopSound(mobj);
+ S_StartSound(mobj, sfx_s3k8c);
+ }
+ else if (mobj->extravalue2 == 1)
+ {
+ mobj->fuse = 50;
+ S_StartSound(mobj, sfx_s3ka3);
+ }
+ else
+ {
+ P_SetMobjState(mobj, mobj->info->meleestate);
+ mobj->fuse = 100;
+ S_StopSound(mobj);
+ S_StartSound(mobj, sfx_s3kc2l);
+ }
+ return;
case MT_PLAYER:
break; // don't remove
default:
@@ -9812,6 +10376,15 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type)
mobj->reactiontime >>= 1;
}
break;
+ case MT_BANPYURA:
+ {
+ mobj_t *bigmeatyclaw = P_SpawnMobjFromMobj(mobj, 0, 0, 0, MT_BANPSPRING);
+ bigmeatyclaw->angle = mobj->angle + ((mobj->flags2 & MF2_AMBUSH) ? ANGLE_90 : ANGLE_270);;
+ P_SetTarget(&mobj->tracer, bigmeatyclaw);
+ P_SetTarget(&bigmeatyclaw->tracer, mobj);
+ mobj->reactiontime >>= 1;
+ }
+ break;
case MT_BIGMINE:
mobj->extravalue1 = FixedHypot(mobj->x, mobj->y)>>FRACBITS;
break;
@@ -9837,6 +10410,9 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type)
mobj->movefactor = -512*FRACUNIT;
mobj->flags2 |= MF2_CLASSICPUSH;
break;
+ case MT_EGGMOBILE4:
+ mobj->flags2 |= MF2_INVERTAIMABLE;
+ break;
case MT_FLICKY_08:
mobj->color = (P_RandomChance(FRACUNIT/2) ? SKINCOLOR_RED : SKINCOLOR_AQUA);
break;
@@ -9893,13 +10469,19 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type)
if (nummaprings >= 0)
nummaprings++;
break;
- case MT_METALSONIC_BATTLE:
case MT_METALSONIC_RACE:
- sc = 3;
+ mobj->skin = &skins[5];
+ /* FALLTHRU */
+ case MT_METALSONIC_BATTLE:
+ mobj->color = skins[5].prefcolor;
+ sc = 5;
break;
case MT_FANG:
sc = 4;
break;
+ case MT_ROSY:
+ sc = 3;
+ break;
case MT_CORK:
mobj->flags2 |= MF2_SUPERFIRE;
break;
@@ -9915,11 +10497,28 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type)
}
case MT_TNTBARREL:
mobj->momx = 1; //stack hack
+ mobj->flags2 |= MF2_INVERTAIMABLE;
break;
case MT_MINECARTEND:
P_SetTarget(&mobj->tracer, P_SpawnMobjFromMobj(mobj, 0, 0, 0, MT_MINECARTENDSOLID));
mobj->tracer->angle = mobj->angle + ANGLE_90;
break;
+ case MT_TORCHFLOWER:
+ {
+ mobj_t *fire = P_SpawnMobjFromMobj(mobj, 0, 0, 46*FRACUNIT, MT_FLAME);
+ P_SetTarget(&mobj->target, fire);
+ break;
+ }
+ case MT_PYREFLY:
+ mobj->extravalue1 = (FixedHypot(mobj->x, mobj->y)/FRACUNIT) % 360;
+ mobj->extravalue2 = 0;
+ mobj->fuse = 100;
+ break;
+ case MT_SIGN:
+ P_SetTarget(&mobj->tracer, P_SpawnMobjFromMobj(mobj, 0, 0, 0, MT_OVERLAY));
+ P_SetTarget(&mobj->tracer->target, mobj);
+ P_SetMobjState(mobj->tracer, S_SIGNBOARD);
+ mobj->tracer->movedir = ANGLE_90;
default:
break;
}
@@ -9945,6 +10544,12 @@ mobj_t *P_SpawnMobj(fixed_t x, fixed_t y, fixed_t z, mobjtype_t type)
if (!(mobj->flags & MF_NOTHINK))
P_AddThinker(THINK_MOBJ, &mobj->thinker);
+ if (mobj->skin) // correct inadequecies above.
+ {
+ mobj->sprite2 = P_GetSkinSprite2(mobj->skin, (mobj->frame & FF_FRAMEMASK), NULL);
+ mobj->frame &= ~FF_FRAMEMASK;
+ }
+
// Call action functions when the state is set
if (st->action.acp1 && (mobj->flags & MF_RUNSPAWNFUNC))
{
@@ -10237,7 +10842,7 @@ void P_SpawnPrecipitation(void)
if (curWeather == PRECIP_SNOW)
{
// Not in a sector with visible sky -- exception for NiGHTS.
- if (!(maptol & TOL_NIGHTS) && precipsector->sector->ceilingpic != skyflatnum)
+ if ((!(maptol & TOL_NIGHTS) && (precipsector->sector->ceilingpic != skyflatnum)) == !(precipsector->sector->flags & SF_INVERTPRECIP))
continue;
rainmo = P_SpawnSnowMobj(x, y, height, MT_SNOWFLAKE);
@@ -10250,7 +10855,7 @@ void P_SpawnPrecipitation(void)
else // everything else.
{
// Not in a sector with visible sky.
- if (precipsector->sector->ceilingpic != skyflatnum)
+ if ((precipsector->sector->ceilingpic != skyflatnum) == !(precipsector->sector->flags & SF_INVERTPRECIP))
continue;
rainmo = P_SpawnRainMobj(x, y, height, MT_RAIN);
@@ -10727,6 +11332,8 @@ void P_MovePlayerToSpawn(INT32 playernum, mapthing_t *mthing)
}
if (mthing->options & MTF_AMBUSH)
P_SetPlayerMobjState(mobj, S_PLAY_FALL);
+ else if (metalrecording)
+ P_SetPlayerMobjState(mobj, S_PLAY_WAIT);
}
else
z = floor;
@@ -11070,6 +11677,16 @@ You should think about modifying the deathmatch starts to take full advantage of
// They're likely facets of the level's design and therefore required to progress.
}
+ if (i == MT_ROSY)
+ {
+ if (!(gametype == GT_COOP || (mthing->options & MTF_EXTRA)))
+ return; // she doesn't hang out here
+ else if (mariomode)
+ i = MT_TOAD; // don't remove on penalty of death
+ else if (!(netgame || multiplayer) && players[consoleplayer].skin == 3)
+ return; // no doubles
+ }
+
if (i == MT_TOKEN && ((gametype != GT_COOP && gametype != GT_COMPETITION) || ultimatemode || tokenbits == 30 || tokenlist & (1 << tokenbits++)))
return; // you already got this token, or there are too many, or the gametype's not right
@@ -11283,9 +11900,10 @@ You should think about modifying the deathmatch starts to take full advantage of
else
mobj->health = FixedMul(ss->sector->ceilingheight-ss->sector->floorheight, 3*(FRACUNIT/4))>>FRACBITS;
break;
- case MT_FANG:
case MT_METALSONIC_RACE:
case MT_METALSONIC_BATTLE:
+ case MT_FANG:
+ case MT_ROSY:
if (mthing->options & MTF_EXTRA)
{
mobj->color = SKINCOLOR_SILVER;
@@ -11904,10 +12522,10 @@ ML_EFFECT5 : Don't stop thinking when too far away
if (mthing->extrainfo)
mobj->extravalue1 = mthing->extrainfo;
break;
- case MT_TRAPGOYLE:
- case MT_TRAPGOYLEUP:
- case MT_TRAPGOYLEDOWN:
- case MT_TRAPGOYLELONG:
+ case MT_GLAREGOYLE:
+ case MT_GLAREGOYLEUP:
+ case MT_GLAREGOYLEDOWN:
+ case MT_GLAREGOYLELONG:
if (mthing->angle >= 360)
mobj->tics += 7*(mthing->angle / 360) + 1; // starting delay
break;
@@ -11957,6 +12575,108 @@ ML_EFFECT5 : Don't stop thinking when too far away
if (mthing->angle > 0)
mobj->tics += mthing->angle;
break;
+ case MT_LAVAFALL:
+ mobj->fuse = 30 + mthing->angle;
+ if (mthing->options & MTF_AMBUSH)
+ {
+ P_SetScale(mobj, 2*mobj->scale);
+ mobj->destscale = mobj->scale;
+ }
+ break;
+ case MT_PYREFLY:
+ //start on fire if Ambush flag is set, otherwise behave normally
+ if (mthing->options & MTF_AMBUSH)
+ {
+ P_SetMobjState(mobj, mobj->info->meleestate);
+ mobj->extravalue2 = 2;
+ S_StartSound(mobj, sfx_s3kc2l);
+ }
+ break;
+ case MT_BIGFERN:
+ {
+ angle_t angle = FixedAngle(mthing->angle << FRACBITS);
+ UINT8 j;
+ for (j = 0; j < 8; j++)
+ {
+ angle_t fa = (angle >> ANGLETOFINESHIFT) & FINEMASK;
+ fixed_t xoffs = FINECOSINE(fa);
+ fixed_t yoffs = FINESINE(fa);
+ mobj_t *leaf = P_SpawnMobjFromMobj(mobj, xoffs, yoffs, 0, MT_BIGFERNLEAF);
+ leaf->angle = angle;
+ angle += ANGLE_45;
+ }
+ break;
+ }
+ case MT_REDBOOSTER:
+ {
+ angle_t angle = FixedAngle(mthing->angle << FRACBITS);
+ fixed_t x1 = FINECOSINE((angle >> ANGLETOFINESHIFT) & FINEMASK);
+ fixed_t y1 = FINESINE((angle >> ANGLETOFINESHIFT) & FINEMASK);
+ fixed_t x2 = FINECOSINE(((angle+ANGLE_90) >> ANGLETOFINESHIFT) & FINEMASK);
+ fixed_t y2 = FINESINE(((angle+ANGLE_90) >> ANGLETOFINESHIFT) & FINEMASK);
+
+ mobj_t *seg = P_SpawnMobjFromMobj(mobj, 26*x1, 26*y1, 0, MT_BOOSTERSEG);
+ seg->angle = angle-ANGLE_90;
+ P_SetMobjState(seg, S_REDBOOSTERSEG_FACE);
+ seg = P_SpawnMobjFromMobj(mobj, -26*x1, -26*y1, 0, MT_BOOSTERSEG);
+ seg->angle = angle+ANGLE_90;
+ P_SetMobjState(seg, S_REDBOOSTERSEG_FACE);
+ seg = P_SpawnMobjFromMobj(mobj, 21*x2, 21*y2, 0, MT_BOOSTERSEG);
+ seg->angle = angle;
+ P_SetMobjState(seg, S_REDBOOSTERSEG_LEFT);
+ seg = P_SpawnMobjFromMobj(mobj, -21*x2, -21*y2, 0, MT_BOOSTERSEG);
+ seg->angle = angle;
+ P_SetMobjState(seg, S_REDBOOSTERSEG_RIGHT);
+
+ seg = P_SpawnMobjFromMobj(mobj, 13*(x1+x2), 13*(y1+y2), 0, MT_BOOSTERROLLER);
+ seg->angle = angle;
+ P_SetMobjState(seg, S_REDBOOSTERROLLER);
+ seg = P_SpawnMobjFromMobj(mobj, 13*(x1-x2), 13*(y1-y2), 0, MT_BOOSTERROLLER);
+ seg->angle = angle;
+ P_SetMobjState(seg, S_REDBOOSTERROLLER);
+ seg = P_SpawnMobjFromMobj(mobj, -13*(x1+x2), -13*(y1+y2), 0, MT_BOOSTERROLLER);
+ seg->angle = angle;
+ P_SetMobjState(seg, S_REDBOOSTERROLLER);
+ seg = P_SpawnMobjFromMobj(mobj, -13*(x1-x2), -13*(y1-y2), 0, MT_BOOSTERROLLER);
+ seg->angle = angle;
+ P_SetMobjState(seg, S_REDBOOSTERROLLER);
+ break;
+ }
+ case MT_YELLOWBOOSTER:
+ {
+ angle_t angle = FixedAngle(mthing->angle << FRACBITS);
+ fixed_t x1 = FINECOSINE((angle >> ANGLETOFINESHIFT) & FINEMASK);
+ fixed_t y1 = FINESINE((angle >> ANGLETOFINESHIFT) & FINEMASK);
+ fixed_t x2 = FINECOSINE(((angle+ANGLE_90) >> ANGLETOFINESHIFT) & FINEMASK);
+ fixed_t y2 = FINESINE(((angle+ANGLE_90) >> ANGLETOFINESHIFT) & FINEMASK);
+
+ mobj_t *seg = P_SpawnMobjFromMobj(mobj, 26*x1, 26*y1, 0, MT_BOOSTERSEG);
+ seg->angle = angle-ANGLE_90;
+ P_SetMobjState(seg, S_YELLOWBOOSTERSEG_FACE);
+ seg = P_SpawnMobjFromMobj(mobj, -26*x1, -26*y1, 0, MT_BOOSTERSEG);
+ seg->angle = angle+ANGLE_90;
+ P_SetMobjState(seg, S_YELLOWBOOSTERSEG_FACE);
+ seg = P_SpawnMobjFromMobj(mobj, 21*x2, 21*y2, 0, MT_BOOSTERSEG);
+ seg->angle = angle;
+ P_SetMobjState(seg, S_YELLOWBOOSTERSEG_LEFT);
+ seg = P_SpawnMobjFromMobj(mobj, -21*x2, -21*y2, 0, MT_BOOSTERSEG);
+ seg->angle = angle;
+ P_SetMobjState(seg, S_YELLOWBOOSTERSEG_RIGHT);
+
+ seg = P_SpawnMobjFromMobj(mobj, 13*(x1+x2), 13*(y1+y2), 0, MT_BOOSTERROLLER);
+ seg->angle = angle;
+ P_SetMobjState(seg, S_YELLOWBOOSTERROLLER);
+ seg = P_SpawnMobjFromMobj(mobj, 13*(x1-x2), 13*(y1-y2), 0, MT_BOOSTERROLLER);
+ seg->angle = angle;
+ P_SetMobjState(seg, S_YELLOWBOOSTERROLLER);
+ seg = P_SpawnMobjFromMobj(mobj, -13*(x1+x2), -13*(y1+y2), 0, MT_BOOSTERROLLER);
+ seg->angle = angle;
+ P_SetMobjState(seg, S_YELLOWBOOSTERROLLER);
+ seg = P_SpawnMobjFromMobj(mobj, -13*(x1-x2), -13*(y1-y2), 0, MT_BOOSTERROLLER);
+ seg->angle = angle;
+ P_SetMobjState(seg, S_YELLOWBOOSTERROLLER);
+ break;
+ }
default:
break;
}
@@ -12155,7 +12875,7 @@ ML_EFFECT5 : Don't stop thinking when too far away
{
if (mthing->options & MTF_AMBUSH)
{
- if (i == MT_YELLOWDIAG || i == MT_REDDIAG)
+ if (i == MT_YELLOWDIAG || i == MT_REDDIAG || i == MT_BLUEDIAG)
mobj->angle += ANGLE_22h;
if (i == MT_YELLOWHORIZ || i == MT_REDHORIZ || i == MT_BLUEHORIZ)
@@ -12194,7 +12914,7 @@ ML_EFFECT5 : Don't stop thinking when too far away
if (mthing->options & MTF_OBJECTSPECIAL)
{
- if (i == MT_YELLOWDIAG || i == MT_REDDIAG)
+ if (i == MT_YELLOWDIAG || i == MT_REDDIAG || i == MT_BLUEDIAG)
mobj->flags |= MF_NOGRAVITY;
if ((mobj->flags & MF_MONITOR) && mobj->info->speed != 0)
diff --git a/src/p_mobj.h b/src/p_mobj.h
index a9d5244b044ad58840238d753e2e70184e2fc585..94fcc29879727f110205e10656bcb97f45a81472 100644
--- a/src/p_mobj.h
+++ b/src/p_mobj.h
@@ -233,15 +233,17 @@ typedef enum
MFE_VERTICALFLIP = 1<<5,
// Goo water
MFE_GOOWATER = 1<<6,
+ // The mobj is touching a lava block
+ MFE_TOUCHLAVA = 1<<7,
// Mobj was already pushed this tic
- MFE_PUSHED = 1<<7,
+ MFE_PUSHED = 1<<8,
// Mobj was already sprung this tic
- MFE_SPRUNG = 1<<8,
+ MFE_SPRUNG = 1<<9,
// Platform movement
- MFE_APPLYPMOMZ = 1<<9,
+ MFE_APPLYPMOMZ = 1<<10,
// Compute and trigger on mobj angle relative to tracer
// See Linedef Exec 457 (Track mobj angle to point)
- MFE_TRACERANGLE = 1<<10,
+ MFE_TRACERANGLE = 1<<11,
// free: to and including 1<<15
} mobjeflag_t;
diff --git a/src/p_saveg.c b/src/p_saveg.c
index 69c942236df283f5825f2ce8a1f8b081daa12d61..fb2365bf0983e3de1cdb44b813ab9c333cc4bc48 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -3618,7 +3618,7 @@ static void P_NetUnArchiveThinkers(void)
{
executor_t *delay = NULL;
UINT32 mobjnum;
- for (currentthinker = thlist[i].next; currentthinker != &thlist[i];
+ for (currentthinker = thlist[THINK_MAIN].next; currentthinker != &thlist[THINK_MAIN];
currentthinker = currentthinker->next)
{
if (currentthinker->function.acp1 != (actionf_p1)T_ExecutorDelay)
diff --git a/src/p_setup.c b/src/p_setup.c
index 2063f93b3dcf59b298d511a440831db47f5ff301..d9ad88a436474cfe3203e9b83f733dd637b5e63c 100644
--- a/src/p_setup.c
+++ b/src/p_setup.c
@@ -75,6 +75,7 @@
#ifdef HWRENDER
#include "hardware/hw_main.h"
#include "hardware/hw_light.h"
+#include "hardware/hw_model.h"
#endif
#ifdef ESLOPE
@@ -546,52 +547,118 @@ size_t P_PrecacheLevelFlats(void)
//SoM: 4/18/2000: New flat code to make use of levelflats.
for (i = 0; i < numlevelflats; i++)
{
- lump = levelflats[i].lumpnum;
- if (devparm)
- flatmemory += W_LumpLength(lump);
- R_GetFlat(lump);
+ if (levelflats[i].type == LEVELFLAT_FLAT)
+ {
+ lump = levelflats[i].u.flat.lumpnum;
+ if (devparm)
+ flatmemory += W_LumpLength(lump);
+ R_GetFlat(lump);
+ }
}
return flatmemory;
}
-// Auxiliary function. Find a flat in the active wad files,
-// allocate an id for it, and set the levelflat (to speedup search)
-INT32 P_AddLevelFlat(const char *flatname, levelflat_t *levelflat)
+/*
+levelflat refers to an array of level flats,
+or NULL if we want to allocate it now.
+*/
+static INT32
+Ploadflat (levelflat_t *levelflat, const char *flatname)
{
- size_t i;
-
- // Scan through the already found flats, break if it matches.
- for (i = 0; i < numlevelflats; i++, levelflat++)
- if (strnicmp(levelflat->name, flatname, 8) == 0)
- break;
+ UINT8 buffer[8];
- // If there is no match, make room for a new flat.
- if (i == numlevelflats)
- {
- // Store the name.
- strlcpy(levelflat->name, flatname, sizeof (levelflat->name));
- strupr(levelflat->name);
+ lumpnum_t flatnum;
+ int texturenum;
- // store the flat lump number
- levelflat->lumpnum = R_GetFlatNumForName(flatname);
- levelflat->texturenum = R_CheckTextureNumForName(flatname);
- levelflat->lasttexturenum = levelflat->texturenum;
+ size_t i;
- levelflat->baselumpnum = LUMPERROR;
- levelflat->basetexturenum = -1;
+ if (levelflat)
+ {
+ // Scan through the already found flats, return if it matches.
+ for (i = 0; i < numlevelflats; i++)
+ {
+ if (strnicmp(levelflat[i].name, flatname, 8) == 0)
+ return i;
+ }
+ }
#ifndef ZDEBUG
- CONS_Debug(DBG_SETUP, "flat #%03d: %s\n", atoi(sizeu1(numlevelflats)), levelflat->name);
+ CONS_Debug(DBG_SETUP, "flat #%03d: %s\n", atoi(sizeu1(numlevelflats)), levelflat->name);
#endif
- numlevelflats++;
+ if (numlevelflats >= MAXLEVELFLATS)
+ I_Error("Too many flats in level\n");
- if (numlevelflats >= MAXLEVELFLATS)
- I_Error("Too many flats in level\n");
+ if (levelflat)
+ levelflat += numlevelflats;
+ else
+ {
+ // allocate new flat memory
+ levelflats = Z_Realloc(levelflats, (numlevelflats + 1) * sizeof(*levelflats), PU_LEVEL, NULL);
+ levelflat = levelflats + numlevelflats;
}
- // level flat id
- return (INT32)i;
+ // Store the name.
+ strlcpy(levelflat->name, flatname, sizeof (levelflat->name));
+ strupr(levelflat->name);
+
+ /* If we can't find a flat, try looking for a texture! */
+ if (( flatnum = R_GetFlatNumForName(flatname) ) == LUMPERROR)
+ {
+ if (( texturenum = R_CheckTextureNumForName(flatname) ) == -1)
+ {
+ // check for REDWALL
+ if (( texturenum = R_CheckTextureNumForName("REDWALL") ) != -1)
+ goto texturefound;
+ // check for REDFLR
+ else if (( flatnum = R_GetFlatNumForName("REDFLR") ) != LUMPERROR)
+ goto flatfound;
+ // nevermind
+ levelflat->type = LEVELFLAT_NONE;
+ }
+ else
+ {
+texturefound:
+ levelflat->type = LEVELFLAT_TEXTURE;
+ levelflat->u.texture. num = texturenum;
+ levelflat->u.texture.lastnum = texturenum;
+ /* start out unanimated */
+ levelflat->u.texture.basenum = -1;
+ }
+ }
+ else
+ {
+flatfound:
+ /* This could be a flat, patch, or PNG. */
+ if (R_CheckIfPatch(flatnum))
+ levelflat->type = LEVELFLAT_PATCH;
+ else
+ {
+#ifndef NO_PNG_LUMPS
+ /*
+ Only need eight bytes for PNG headers.
+ FIXME: Put this elsewhere.
+ */
+ W_ReadLumpHeader(flatnum, buffer, 8, 0);
+ if (R_IsLumpPNG(buffer, W_LumpLength(flatnum)))
+ levelflat->type = LEVELFLAT_PNG;
+ else
+#endif/*NO_PNG_LUMPS*/
+ levelflat->type = LEVELFLAT_FLAT;/* phew */
+ }
+
+ levelflat->u.flat. lumpnum = flatnum;
+ levelflat->u.flat.baselumpnum = LUMPERROR;
+ }
+
+ return ( numlevelflats++ );
+}
+
+// Auxiliary function. Find a flat in the active wad files,
+// allocate an id for it, and set the levelflat (to speedup search)
+INT32 P_AddLevelFlat(const char *flatname, levelflat_t *levelflat)
+{
+ return Ploadflat(levelflat, flatname);
}
// help function for Lua and $$$.sav reading
@@ -600,44 +667,7 @@ INT32 P_AddLevelFlat(const char *flatname, levelflat_t *levelflat)
//
INT32 P_AddLevelFlatRuntime(const char *flatname)
{
- size_t i;
- levelflat_t *levelflat = levelflats;
-
- //
- // first scan through the already found flats
- //
- for (i = 0; i < numlevelflats; i++, levelflat++)
- if (strnicmp(levelflat->name,flatname,8)==0)
- break;
-
- // that flat was already found in the level, return the id
- if (i == numlevelflats)
- {
- // allocate new flat memory
- levelflats = Z_Realloc(levelflats, (numlevelflats + 1) * sizeof(*levelflats), PU_LEVEL, NULL);
- levelflat = levelflats+i;
-
- // store the name
- strlcpy(levelflat->name, flatname, sizeof (levelflat->name));
- strupr(levelflat->name);
-
- // store the flat lump number
- levelflat->lumpnum = R_GetFlatNumForName(flatname);
- levelflat->texturenum = R_CheckTextureNumForName(flatname);
- levelflat->lasttexturenum = levelflat->texturenum;
-
- levelflat->baselumpnum = LUMPERROR;
- levelflat->basetexturenum = -1;
-
-#ifndef ZDEBUG
- CONS_Debug(DBG_SETUP, "flat #%03d: %s\n", atoi(sizeu1(numlevelflats)), levelflat->name);
-#endif
-
- numlevelflats++;
- }
-
- // level flat id
- return (INT32)i;
+ return Ploadflat(0, flatname);
}
// help function for $$$.sav checking
@@ -2606,7 +2636,6 @@ boolean P_SetupLevel(boolean skipprecip)
boolean loadedbm = false;
sector_t *ss;
boolean chase;
-
levelloading = true;
// This is needed. Don't touch.
@@ -3045,8 +3074,11 @@ boolean P_SetupLevel(boolean skipprecip)
CONS_Printf(M_GetText("No player currently available to become IT. Awaiting available players.\n"));
}
- else if (gametype == GT_RACE && server && cv_usemapnumlaps.value)
- CV_StealthSetValue(&cv_numlaps, mapheaderinfo[gamemap - 1]->numlaps);
+ else if (gametype == GT_RACE && server)
+ CV_StealthSetValue(&cv_numlaps,
+ (cv_basenumlaps.value)
+ ? cv_basenumlaps.value
+ : mapheaderinfo[gamemap - 1]->numlaps);
// ===========
// landing point for netgames.
@@ -3481,6 +3513,10 @@ boolean P_AddWadFile(const char *wadfilename)
if (!mapsadded)
CONS_Printf(M_GetText("No maps added\n"));
+#ifdef HWRENDER
+ HWR_ReloadModels();
+#endif // HWRENDER
+
// reload status bar (warning should have valid player!)
if (gamestate == GS_LEVEL)
ST_Start();
diff --git a/src/p_setup.h b/src/p_setup.h
index b03903bec5d366c4acb5fca3ffa0c3a752b3935c..0050a471a2ce44f8dbd424e10a670883ceee614d 100644
--- a/src/p_setup.h
+++ b/src/p_setup.h
@@ -30,20 +30,51 @@ extern boolean levelloading;
extern UINT8 levelfadecol;
extern lumpnum_t lastloadedmaplumpnum; // for comparative savegame
+
+/* for levelflat type */
+enum
+{
+ LEVELFLAT_NONE,/* HOM time my friend */
+ LEVELFLAT_FLAT,
+ LEVELFLAT_PATCH,
+#ifndef NO_PNG_LUMPS
+ LEVELFLAT_PNG,
+#endif
+ LEVELFLAT_TEXTURE,
+};
+
//
// MAP used flats lookup table
//
typedef struct
{
char name[9]; // resource name from wad
- lumpnum_t lumpnum; // lump number of the flat
- INT32 texturenum, lasttexturenum; // texture number of the flat
+
+ UINT8 type;
+ union
+ {
+ struct
+ {
+ lumpnum_t lumpnum; // lump number of the flat
+ // for flat animation
+ lumpnum_t baselumpnum;
+ }
+ flat;
+ struct
+ {
+ INT32 num;
+ INT32 lastnum; // texture number of the flat
+ // for flat animation
+ INT32 basenum;
+ }
+ texture;
+ }
+ u;
+
UINT16 width, height;
fixed_t topoffset, leftoffset;
// for flat animation
- lumpnum_t baselumpnum;
- INT32 basetexturenum;
INT32 animseq; // start pos. in the anim sequence
INT32 numpics;
INT32 speed;
diff --git a/src/p_spec.c b/src/p_spec.c
index 256ca3453f0017311392d0b7d7d3043f7fe576a6..d6a8cb48e4979f2d14ecb29bbbe6b5549ad0e0f0 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -464,11 +464,11 @@ static inline void P_FindAnimatedFlat(INT32 animnum)
for (i = 0; i < numlevelflats; i++, foundflats++)
{
// is that levelflat from the flat anim sequence ?
- if ((anims[animnum].istexture) && (foundflats->texturenum != 0 && foundflats->texturenum != -1)
- && ((UINT16)foundflats->texturenum >= startflatnum && (UINT16)foundflats->texturenum <= endflatnum))
+ if ((anims[animnum].istexture) && (foundflats->type == LEVELFLAT_TEXTURE)
+ && ((UINT16)foundflats->u.texture.num >= startflatnum && (UINT16)foundflats->u.texture.num <= endflatnum))
{
- foundflats->basetexturenum = startflatnum;
- foundflats->animseq = foundflats->texturenum - startflatnum;
+ foundflats->u.texture.basenum = startflatnum;
+ foundflats->animseq = foundflats->u.texture.num - startflatnum;
foundflats->numpics = endflatnum - startflatnum + 1;
foundflats->speed = anims[animnum].speed;
@@ -476,10 +476,10 @@ static inline void P_FindAnimatedFlat(INT32 animnum)
atoi(sizeu1(i)), foundflats->name, foundflats->animseq,
foundflats->numpics,foundflats->speed);
}
- else if (foundflats->lumpnum >= startflatnum && foundflats->lumpnum <= endflatnum)
+ else if (foundflats->u.flat.lumpnum >= startflatnum && foundflats->u.flat.lumpnum <= endflatnum)
{
- foundflats->baselumpnum = startflatnum;
- foundflats->animseq = foundflats->lumpnum - startflatnum;
+ foundflats->u.flat.baselumpnum = startflatnum;
+ foundflats->animseq = foundflats->u.flat.lumpnum - startflatnum;
foundflats->numpics = endflatnum - startflatnum + 1;
foundflats->speed = anims[animnum].speed;
@@ -2718,6 +2718,7 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
CONS_Debug(DBG_GAMELOGIC, "Line type 414 Executor: sfx number %d is invalid!\n", sfxnum);
return;
}
+
if (line->tag != 0) // Do special stuff only if a non-zero linedef tag is set
{
if (line->flags & ML_EFFECT5) // Repeat Midtexture
@@ -2758,30 +2759,32 @@ static void P_ProcessLineSpecial(line_t *line, mobj_t *mo, sector_t *callsec)
return;
}
}
-
- if (line->flags & ML_NOCLIMB)
+ else
{
- // play the sound from nowhere, but only if display player triggered it
- if (mo && mo->player && (mo->player == &players[displayplayer] || mo->player == &players[secondarydisplayplayer]))
+ if (line->flags & ML_NOCLIMB)
+ {
+ // play the sound from nowhere, but only if display player triggered it
+ if (mo && mo->player && (mo->player == &players[displayplayer] || mo->player == &players[secondarydisplayplayer]))
+ S_StartSound(NULL, sfxnum);
+ }
+ else if (line->flags & ML_EFFECT4)
+ {
+ // play the sound from nowhere
S_StartSound(NULL, sfxnum);
- }
- else if (line->flags & ML_EFFECT4)
- {
- // play the sound from nowhere
- S_StartSound(NULL, sfxnum);
- }
- else if (line->flags & ML_BLOCKMONSTERS)
- {
- // play the sound from calling sector's soundorg
- if (callsec)
- S_StartSound(&callsec->soundorg, sfxnum);
+ }
+ else if (line->flags & ML_BLOCKMONSTERS)
+ {
+ // play the sound from calling sector's soundorg
+ if (callsec)
+ S_StartSound(&callsec->soundorg, sfxnum);
+ else if (mo)
+ S_StartSound(&mo->subsector->sector->soundorg, sfxnum);
+ }
else if (mo)
- S_StartSound(&mo->subsector->sector->soundorg, sfxnum);
- }
- else if (mo)
- {
- // play the sound from mobj that triggered it
- S_StartSound(mo, sfxnum);
+ {
+ // play the sound from mobj that triggered it
+ S_StartSound(mo, sfxnum);
+ }
}
}
break;
@@ -4051,11 +4054,15 @@ void P_SetupSignExit(player_t *player)
if (thing->type != MT_SIGN)
continue;
+ if (!player->mo->target || player->mo->target->type != MT_SIGN)
+ P_SetTarget(&player->mo->target, thing);
+
if (thing->state != &states[thing->info->spawnstate])
continue;
P_SetTarget(&thing->target, player->mo);
- P_SetMobjState(thing, S_SIGN1);
+ P_SetObjectMomZ(thing, 12*FRACUNIT, false);
+ P_SetMobjState(thing, S_SIGNSPIN1);
if (thing->info->seesound)
S_StartSound(thing, thing->info->seesound);
@@ -4076,11 +4083,15 @@ void P_SetupSignExit(player_t *player)
if (thing->type != MT_SIGN)
continue;
+ if (!player->mo->target || player->mo->target->type != MT_SIGN)
+ P_SetTarget(&player->mo->target, thing);
+
if (thing->state != &states[thing->info->spawnstate])
continue;
P_SetTarget(&thing->target, player->mo);
- P_SetMobjState(thing, S_SIGN1);
+ P_SetObjectMomZ(thing, 12*FRACUNIT, false);
+ P_SetMobjState(thing, S_SIGNSPIN1);
if (thing->info->seesound)
S_StartSound(thing, thing->info->seesound);
@@ -4174,26 +4185,11 @@ sector_t *P_PlayerTouchingSectorSpecial(player_t *player, INT32 section, INT32 n
// Check the 3D floor's type...
if (rover->flags & FF_BLOCKPLAYER)
{
+ boolean floorallowed = ((rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR) && ((rover->master->frontsector->flags & SF_TRIGGERSPECIAL_HEADBUMP) || !(player->mo->eflags & MFE_VERTICALFLIP)) && (player->mo->z == topheight));
+ boolean ceilingallowed = ((rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING) && ((rover->master->frontsector->flags & SF_TRIGGERSPECIAL_HEADBUMP) || (player->mo->eflags & MFE_VERTICALFLIP)) && (player->mo->z + player->mo->height == bottomheight));
// Thing must be on top of the floor to be affected...
- if ((rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR)
- && !(rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING))
- {
- if ((player->mo->eflags & MFE_VERTICALFLIP) || player->mo->z != topheight)
- continue;
- }
- else if ((rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING)
- && !(rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR))
- {
- if (!(player->mo->eflags & MFE_VERTICALFLIP)
- || player->mo->z + player->mo->height != bottomheight)
- continue;
- }
- else if (rover->master->frontsector->flags & SF_FLIPSPECIAL_BOTH)
- {
- if (!((player->mo->eflags & MFE_VERTICALFLIP && player->mo->z + player->mo->height == bottomheight)
- || (!(player->mo->eflags & MFE_VERTICALFLIP) && player->mo->z == topheight)))
- continue;
- }
+ if (!(floorallowed || ceilingallowed))
+ continue;
}
else
{
@@ -4234,26 +4230,11 @@ sector_t *P_PlayerTouchingSectorSpecial(player_t *player, INT32 section, INT32 n
// Check the 3D floor's type...
if (rover->flags & FF_BLOCKPLAYER)
{
+ boolean floorallowed = ((rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR) && ((rover->master->frontsector->flags & SF_TRIGGERSPECIAL_HEADBUMP) || !(player->mo->eflags & MFE_VERTICALFLIP)) && (player->mo->z == topheight));
+ boolean ceilingallowed = ((rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING) && ((rover->master->frontsector->flags & SF_TRIGGERSPECIAL_HEADBUMP) || (player->mo->eflags & MFE_VERTICALFLIP)) && (player->mo->z + player->mo->height == bottomheight));
// Thing must be on top of the floor to be affected...
- if ((rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR)
- && !(rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING))
- {
- if ((player->mo->eflags & MFE_VERTICALFLIP) || player->mo->z != topheight)
- continue;
- }
- else if ((rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING)
- && !(rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR))
- {
- if (!(player->mo->eflags & MFE_VERTICALFLIP)
- || player->mo->z + player->mo->height != bottomheight)
- continue;
- }
- else if (rover->master->frontsector->flags & SF_FLIPSPECIAL_BOTH)
- {
- if (!((player->mo->eflags & MFE_VERTICALFLIP && player->mo->z + player->mo->height == bottomheight)
- || (!(player->mo->eflags & MFE_VERTICALFLIP) && player->mo->z == topheight)))
- continue;
- }
+ if (!(floorallowed || ceilingallowed))
+ continue;
}
else
{
@@ -4304,26 +4285,11 @@ static boolean P_ThingIsOnThe3DFloor(mobj_t *mo, sector_t *sector, sector_t *tar
// Check the 3D floor's type...
if (rover->flags & FF_BLOCKPLAYER)
{
+ boolean floorallowed = ((rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR) && ((rover->master->frontsector->flags & SF_TRIGGERSPECIAL_HEADBUMP) || !(mo->eflags & MFE_VERTICALFLIP)) && (mo->z == top));
+ boolean ceilingallowed = ((rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING) && ((rover->master->frontsector->flags & SF_TRIGGERSPECIAL_HEADBUMP) || (mo->eflags & MFE_VERTICALFLIP)) && (mo->z + mo->height == bottom));
// Thing must be on top of the floor to be affected...
- if ((rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR)
- && !(rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING))
- {
- if ((mo->eflags & MFE_VERTICALFLIP) || mo->z != top)
- return false;
- }
- else if ((rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING)
- && !(rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR))
- {
- if (!(mo->eflags & MFE_VERTICALFLIP)
- || mo->z + mo->height != bottom)
- return false;
- }
- else if (rover->master->frontsector->flags & SF_FLIPSPECIAL_BOTH)
- {
- if (!((mo->eflags & MFE_VERTICALFLIP && mo->z + mo->height == bottom)
- || (!(mo->eflags & MFE_VERTICALFLIP) && mo->z == top)))
- return false;
- }
+ if (!(floorallowed || ceilingallowed))
+ continue;
}
else
{
@@ -4345,10 +4311,10 @@ static boolean P_ThingIsOnThe3DFloor(mobj_t *mo, sector_t *sector, sector_t *tar
//
static boolean P_MobjReadyToTrigger(mobj_t *mo, sector_t *sec)
{
- if (mo->eflags & MFE_VERTICALFLIP)
- return (mo->z+mo->height == P_GetSpecialTopZ(mo, sec, sec) && sec->flags & SF_FLIPSPECIAL_CEILING);
- else
- return (mo->z == P_GetSpecialBottomZ(mo, sec, sec) && sec->flags & SF_FLIPSPECIAL_FLOOR);
+ boolean floorallowed = ((sec->flags & SF_FLIPSPECIAL_FLOOR) && ((sec->flags & SF_TRIGGERSPECIAL_HEADBUMP) || !(mo->eflags & MFE_VERTICALFLIP)) && (mo->z == P_GetSpecialBottomZ(mo, sec, sec)));
+ boolean ceilingallowed = ((sec->flags & SF_FLIPSPECIAL_CEILING) && ((sec->flags & SF_TRIGGERSPECIAL_HEADBUMP) || (mo->eflags & MFE_VERTICALFLIP)) && (mo->z + mo->height == P_GetSpecialTopZ(mo, sec, sec)));
+ // Thing must be on top of the floor to be affected...
+ return (floorallowed || ceilingallowed);
}
/** Applies a sector special to a player.
@@ -5312,26 +5278,11 @@ sector_t *P_ThingOnSpecial3DFloor(mobj_t *mo)
if (((rover->flags & FF_BLOCKPLAYER) && mo->player)
|| ((rover->flags & FF_BLOCKOTHERS) && !mo->player))
{
+ boolean floorallowed = ((rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR) && ((rover->master->frontsector->flags & SF_TRIGGERSPECIAL_HEADBUMP) || !(mo->eflags & MFE_VERTICALFLIP)) && (mo->z == topheight));
+ boolean ceilingallowed = ((rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING) && ((rover->master->frontsector->flags & SF_TRIGGERSPECIAL_HEADBUMP) || (mo->eflags & MFE_VERTICALFLIP)) && (mo->z + mo->height == bottomheight));
// Thing must be on top of the floor to be affected...
- if ((rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR)
- && !(rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING))
- {
- if ((mo->eflags & MFE_VERTICALFLIP) || mo->z != topheight)
- continue;
- }
- else if ((rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING)
- && !(rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR))
- {
- if (!(mo->eflags & MFE_VERTICALFLIP)
- || mo->z + mo->height != bottomheight)
- continue;
- }
- else if (rover->master->frontsector->flags & SF_FLIPSPECIAL_BOTH)
- {
- if (!((mo->eflags & MFE_VERTICALFLIP && mo->z + mo->height == bottomheight)
- || (!(mo->eflags & MFE_VERTICALFLIP) && mo->z == topheight)))
- continue;
- }
+ if (!(floorallowed || ceilingallowed))
+ continue;
}
else
{
@@ -5374,26 +5325,11 @@ static void P_PlayerOnSpecial3DFloor(player_t *player, sector_t *sector)
// Check the 3D floor's type...
if (rover->flags & FF_BLOCKPLAYER)
{
+ boolean floorallowed = ((rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR) && ((rover->master->frontsector->flags & SF_TRIGGERSPECIAL_HEADBUMP) || !(player->mo->eflags & MFE_VERTICALFLIP)) && (player->mo->z == topheight));
+ boolean ceilingallowed = ((rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING) && ((rover->master->frontsector->flags & SF_TRIGGERSPECIAL_HEADBUMP) || (player->mo->eflags & MFE_VERTICALFLIP)) && (player->mo->z + player->mo->height == bottomheight));
// Thing must be on top of the floor to be affected...
- if ((rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR)
- && !(rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING))
- {
- if ((player->mo->eflags & MFE_VERTICALFLIP) || player->mo->z != topheight)
- continue;
- }
- else if ((rover->master->frontsector->flags & SF_FLIPSPECIAL_CEILING)
- && !(rover->master->frontsector->flags & SF_FLIPSPECIAL_FLOOR))
- {
- if (!(player->mo->eflags & MFE_VERTICALFLIP)
- || player->mo->z + player->mo->height != bottomheight)
- continue;
- }
- else if (rover->master->frontsector->flags & SF_FLIPSPECIAL_BOTH)
- {
- if (!((player->mo->eflags & MFE_VERTICALFLIP && player->mo->z + player->mo->height == bottomheight)
- || (!(player->mo->eflags & MFE_VERTICALFLIP) && player->mo->z == topheight)))
- continue;
- }
+ if (!(floorallowed || ceilingallowed))
+ continue;
}
else
{
@@ -5450,38 +5386,16 @@ static void P_PlayerOnSpecial3DFloor(player_t *player, sector_t *sector)
}
if (!(po->flags & POF_TESTHEIGHT)) // Don't do height checking
- {
- }
+ ;
else if (po->flags & POF_SOLID)
{
+ boolean floorallowed = ((polysec->flags & SF_FLIPSPECIAL_FLOOR) && ((polysec->flags & SF_TRIGGERSPECIAL_HEADBUMP) || !(player->mo->eflags & MFE_VERTICALFLIP)) && (player->mo->z == polysec->ceilingheight));
+ boolean ceilingallowed = ((polysec->flags & SF_FLIPSPECIAL_CEILING) && ((polysec->flags & SF_TRIGGERSPECIAL_HEADBUMP) || (player->mo->eflags & MFE_VERTICALFLIP)) && (player->mo->z + player->mo->height == polysec->floorheight));
// Thing must be on top of the floor to be affected...
- if ((polysec->flags & SF_FLIPSPECIAL_FLOOR)
- && !(polysec->flags & SF_FLIPSPECIAL_CEILING))
+ if (!(floorallowed || ceilingallowed))
{
- if ((player->mo->eflags & MFE_VERTICALFLIP) || player->mo->z != polysec->ceilingheight)
- {
- po = (polyobj_t *)(po->link.next);
- continue;
- }
- }
- else if ((polysec->flags & SF_FLIPSPECIAL_CEILING)
- && !(polysec->flags & SF_FLIPSPECIAL_FLOOR))
- {
- if (!(player->mo->eflags & MFE_VERTICALFLIP)
- || player->mo->z + player->mo->height != polysec->floorheight)
- {
- po = (polyobj_t *)(po->link.next);
- continue;
- }
- }
- else if (polysec->flags & SF_FLIPSPECIAL_BOTH)
- {
- if (!((player->mo->eflags & MFE_VERTICALFLIP && player->mo->z + player->mo->height == polysec->floorheight)
- || (!(player->mo->eflags & MFE_VERTICALFLIP) && player->mo->z == polysec->ceilingheight)))
- {
- po = (polyobj_t *)(po->link.next);
- continue;
- }
+ po = (polyobj_t *)(po->link.next);
+ continue;
}
}
else
@@ -5580,17 +5494,13 @@ static void P_RunSpecialSectorCheck(player_t *player, sector_t *sector)
f_affectpoint = P_GetSpecialBottomZ(player->mo, sector, sector);
c_affectpoint = P_GetSpecialTopZ(player->mo, sector, sector);
- // Only go further if on the ground
- if ((sector->flags & SF_FLIPSPECIAL_FLOOR) && !(sector->flags & SF_FLIPSPECIAL_CEILING) && player->mo->z != f_affectpoint)
- return;
-
- if ((sector->flags & SF_FLIPSPECIAL_CEILING) && !(sector->flags & SF_FLIPSPECIAL_FLOOR) && player->mo->z + player->mo->height != c_affectpoint)
- return;
-
- if ((sector->flags & SF_FLIPSPECIAL_BOTH)
- && player->mo->z != f_affectpoint
- && player->mo->z + player->mo->height != c_affectpoint)
- return;
+ {
+ boolean floorallowed = ((sector->flags & SF_FLIPSPECIAL_FLOOR) && ((sector->flags & SF_TRIGGERSPECIAL_HEADBUMP) || !(player->mo->eflags & MFE_VERTICALFLIP)) && (player->mo->z == f_affectpoint));
+ boolean ceilingallowed = ((sector->flags & SF_FLIPSPECIAL_CEILING) && ((sector->flags & SF_TRIGGERSPECIAL_HEADBUMP) || (player->mo->eflags & MFE_VERTICALFLIP)) && (player->mo->z + player->mo->height == c_affectpoint));
+ // Thing must be on top of the floor to be affected...
+ if (!(floorallowed || ceilingallowed))
+ return;
+ }
P_ProcessSpecialSector(player, sector, NULL);
}
@@ -5679,11 +5589,11 @@ void P_UpdateSpecials(void)
if (foundflats->speed) // it is an animated flat
{
// update the levelflat texture number
- if (foundflats->basetexturenum != -1)
- foundflats->texturenum = foundflats->basetexturenum + ((leveltime/foundflats->speed + foundflats->animseq) % foundflats->numpics);
+ if (foundflats->type == LEVELFLAT_TEXTURE)
+ foundflats->u.texture.num = foundflats->u.texture.basenum + ((leveltime/foundflats->speed + foundflats->animseq) % foundflats->numpics);
// update the levelflat lump number
- else if (foundflats->baselumpnum != LUMPERROR)
- foundflats->lumpnum = foundflats->baselumpnum + ((leveltime/foundflats->speed + foundflats->animseq) % foundflats->numpics);
+ else if ((foundflats->type == LEVELFLAT_FLAT) && (foundflats->u.flat.baselumpnum != LUMPERROR))
+ foundflats->u.flat.lumpnum = foundflats->u.flat.baselumpnum + ((leveltime/foundflats->speed + foundflats->animseq) % foundflats->numpics);
}
}
}
@@ -6085,8 +5995,6 @@ static void P_AddBlockThinker(sector_t *sec, line_t *sourceline)
* to the lowest nearby height if not
* there already.
*
- * Replaces the old "AirBob".
- *
* \param sec Control sector.
* \param actionsector Target sector.
* \param sourceline Control linedef.
@@ -6131,8 +6039,7 @@ static void P_AddRaiseThinker(sector_t *sec, line_t *sourceline)
raise->sourceline = sourceline;
}
-// Function to maintain backwards compatibility
-static void P_AddOldAirbob(sector_t *sec, line_t *sourceline, boolean noadjust)
+static void P_AddAirbob(sector_t *sec, line_t *sourceline, boolean noadjust, boolean dynamic)
{
levelspecthink_t *airbob;
@@ -6170,6 +6077,8 @@ static void P_AddOldAirbob(sector_t *sec, line_t *sourceline, boolean noadjust)
airbob->vars[4] = airbob->vars[5]
- (sec->ceilingheight - sec->floorheight);
+ airbob->vars[9] = dynamic ? 1 : 0;
+
airbob->sourceline = sourceline;
}
@@ -6683,6 +6592,11 @@ void P_SpawnSpecials(INT32 fromnetsave)
if (lines[i].flags & ML_EFFECT3)
sectors[s].flags |= SF_TRIGGERSPECIAL_TOUCH;
+ if (lines[i].flags & ML_EFFECT2)
+ sectors[s].flags |= SF_TRIGGERSPECIAL_HEADBUMP;
+
+ if (lines[i].flags & ML_EFFECT1)
+ sectors[s].flags |= SF_INVERTPRECIP;
if (lines[i].frontsector && GETSECSPECIAL(lines[i].frontsector->special, 4) == 12)
sectors[s].camsec = sides[*lines[i].sidenum].sector-sectors;
@@ -6987,11 +6901,16 @@ void P_SpawnSpecials(INT32 fromnetsave)
case 151: // Adjustable air bobbing platform
P_AddFakeFloorsByLine(i, FF_EXISTS|FF_SOLID|FF_RENDERALL|FF_CUTLEVEL, secthinkers);
lines[i].flags |= ML_BLOCKMONSTERS;
- P_AddOldAirbob(lines[i].frontsector, lines + i, (lines[i].special != 151));
+ P_AddAirbob(lines[i].frontsector, lines + i, (lines[i].special != 151), false);
break;
case 152: // Adjustable air bobbing platform in reverse
P_AddFakeFloorsByLine(i, FF_EXISTS|FF_SOLID|FF_RENDERALL|FF_CUTLEVEL, secthinkers);
- P_AddOldAirbob(lines[i].frontsector, lines + i, true);
+ P_AddAirbob(lines[i].frontsector, lines + i, true, false);
+ break;
+ case 153: // Dynamic Sinking Platform
+ P_AddFakeFloorsByLine(i, FF_EXISTS|FF_SOLID|FF_RENDERALL|FF_CUTLEVEL, secthinkers);
+ lines[i].flags |= ML_BLOCKMONSTERS;
+ P_AddAirbob(lines[i].frontsector, lines + i, false, true);
break;
case 160: // Float/bob platform
@@ -7042,14 +6961,14 @@ void P_SpawnSpecials(INT32 fromnetsave)
case 176: // Air bobbing platform that will crumble and bob on the water when it falls and hits
P_AddFakeFloorsByLine(i, FF_EXISTS|FF_SOLID|FF_RENDERALL|FF_FLOATBOB|FF_CRUMBLE, secthinkers);
lines[i].flags |= ML_BLOCKMONSTERS;
- P_AddOldAirbob(lines[i].frontsector, lines + i, true);
+ P_AddAirbob(lines[i].frontsector, lines + i, true, false);
break;
case 177: // Air bobbing platform that will crumble and bob on
// the water when it falls and hits, then never return
P_AddFakeFloorsByLine(i, FF_EXISTS|FF_SOLID|FF_RENDERALL|FF_CUTLEVEL|FF_FLOATBOB|FF_CRUMBLE|FF_NORETURN, secthinkers);
lines[i].flags |= ML_BLOCKMONSTERS;
- P_AddOldAirbob(lines[i].frontsector, lines + i, true);
+ P_AddAirbob(lines[i].frontsector, lines + i, true, false);
break;
case 178: // Crumbling platform that will float when it hits water
@@ -7063,7 +6982,7 @@ void P_SpawnSpecials(INT32 fromnetsave)
case 180: // Air bobbing platform that will crumble
P_AddFakeFloorsByLine(i, FF_EXISTS|FF_SOLID|FF_RENDERALL|FF_CUTLEVEL|FF_CRUMBLE, secthinkers);
lines[i].flags |= ML_BLOCKMONSTERS;
- P_AddOldAirbob(lines[i].frontsector, lines + i, true);
+ P_AddAirbob(lines[i].frontsector, lines + i, true, false);
break;
case 190: // Rising Platform FOF (solid, opaque, shadows)
@@ -7171,21 +7090,21 @@ void P_SpawnSpecials(INT32 fromnetsave)
break;
case 252: // Shatter block (breaks when touched)
- ffloorflags = FF_EXISTS|FF_RENDERALL|FF_BUSTUP|FF_SHATTER;
+ ffloorflags = FF_EXISTS|FF_BLOCKOTHERS|FF_RENDERALL|FF_BUSTUP|FF_SHATTER;
if (lines[i].flags & ML_NOCLIMB)
- ffloorflags |= FF_SOLID|FF_SHATTERBOTTOM;
+ ffloorflags |= FF_BLOCKPLAYER|FF_SHATTERBOTTOM;
P_AddFakeFloorsByLine(i, ffloorflags, secthinkers);
break;
case 253: // Translucent shatter block (see 76)
- P_AddFakeFloorsByLine(i, FF_EXISTS|FF_RENDERALL|FF_BUSTUP|FF_SHATTER|FF_TRANSLUCENT, secthinkers);
+ P_AddFakeFloorsByLine(i, FF_EXISTS|FF_BLOCKOTHERS|FF_RENDERALL|FF_BUSTUP|FF_SHATTER|FF_TRANSLUCENT, secthinkers);
break;
case 254: // Bustable block
ffloorflags = FF_EXISTS|FF_SOLID|FF_RENDERALL|FF_BUSTUP;
if (lines[i].flags & ML_NOCLIMB)
- ffloorflags |= FF_ONLYKNUX;
+ ffloorflags |= FF_STRONGBUST;
P_AddFakeFloorsByLine(i, ffloorflags, secthinkers);
break;
diff --git a/src/p_tick.c b/src/p_tick.c
index 7606510fef2d8a302809f0d541616babb003e95a..6b5c7980c86d7307a460e66111b70d0bad37a23e 100644
--- a/src/p_tick.c
+++ b/src/p_tick.c
@@ -482,7 +482,7 @@ static inline void P_DoSpecialStageStuff(void)
countspheres += players[i].spheres;
// If in water, deplete timer 6x as fast.
- if (players[i].mo->eflags & (MFE_TOUCHWATER|MFE_UNDERWATER))
+ if (players[i].mo->eflags & (MFE_TOUCHWATER|MFE_UNDERWATER) && !(players[i].powers[pw_shield] & SH_PROTECTWATER))
players[i].nightstime -= 5;
if (--players[i].nightstime > 6)
{
diff --git a/src/p_user.c b/src/p_user.c
index e4792c1071e8ca08fa650de7ced26b569f8aebb2..6a67e329cc09072ec74d5c926ae3c2f6446d8e91 100644
--- a/src/p_user.c
+++ b/src/p_user.c
@@ -191,7 +191,7 @@ boolean P_AutoPause(void)
if (netgame || modeattacking || gamestate == GS_TITLESCREEN)
return false;
- return (menuactive || window_notinfocus);
+ return (menuactive || ( window_notinfocus && cv_pauseifunfocused.value ));
}
//
@@ -898,7 +898,7 @@ void P_NightserizePlayer(player_t *player, INT32 nighttime)
if (player->mo->target)
{
player->angle_pos = R_PointToAngle2(player->mo->target->x, player->mo->target->y, player->mo->x, player->mo->y);
- player->drawangle = player->mo->angle = player->angle_pos
+ player->drawangle = player->angle_pos
+ ((player->mo->target->flags2 & MF2_AMBUSH) ? // if axis is invert, take the opposite right angle
-ANGLE_90 : ANGLE_90); // flyangle is always 0 here, below is kept for posterity
/*(player->flyangle > 90 && player->flyangle < 270 ? ANGLE_90 : -ANGLE_90)
@@ -1031,6 +1031,17 @@ void P_ResetPlayer(player_t *player)
{
player->pflags &= ~(PF_SPINNING|PF_STARTDASH|PF_STARTJUMP|PF_JUMPED|PF_NOJUMPDAMAGE|PF_GLIDING|PF_THOKKED|PF_CANCARRY|PF_SHIELDABILITY|PF_BOUNCING);
+ if (player->powers[pw_carry] == CR_ROLLOUT)
+ {
+ if (player->mo->tracer && !P_MobjWasRemoved(player->mo->tracer))
+ {
+ player->mo->tracer->flags |= MF_PUSHABLE;
+ P_SetTarget(&player->mo->tracer->tracer, NULL);
+ }
+ P_SetTarget(&player->mo->tracer, NULL);
+ player->powers[pw_carry] = CR_NONE;
+ }
+
if (!(player->powers[pw_carry] == CR_NIGHTSMODE || player->powers[pw_carry] == CR_NIGHTSFALL || player->powers[pw_carry] == CR_BRAKGOOP || player->powers[pw_carry] == CR_MINECART))
player->powers[pw_carry] = CR_NONE;
@@ -1086,6 +1097,9 @@ boolean P_PlayerCanDamage(player_t *player, mobj_t *thing)
if (player->pflags & PF_SPINNING)
return true;
+ if (player->dashmode >= DASHMODE_THRESHOLD && (player->charflags & (SF_DASHMODE|SF_MACHINE)) == (SF_DASHMODE|SF_MACHINE))
+ return true;
+
// From the front.
if (((player->pflags & PF_GLIDING) || (player->charability2 == CA2_MELEE && player->panim == PA_ABILITY2))
&& (player->drawangle - R_PointToAngle2(player->mo->x - player->mo->momx, player->mo->y - player->mo->momy, thing->x, thing->y) + + ANGLE_90) < ANGLE_180)
@@ -1226,6 +1240,8 @@ void P_GivePlayerLives(player_t *player, INT32 numlives)
numlives = (numlives + prevlives - player->lives);
}
}
+ else if (player->lives == INFLIVES)
+ return;
player->lives += numlives;
@@ -1979,7 +1995,7 @@ mobj_t *P_SpawnGhostMobj(mobj_t *mobj)
mobj_t *ghost2 = P_SpawnGhostMobj(mobj->player->followmobj);
P_SetTarget(&ghost2->tracer, ghost);
P_SetTarget(&ghost->tracer, ghost2);
- ghost2->flags2 |= MF2_LINKDRAW;
+ ghost2->flags2 |= (mobj->player->followmobj->flags2 & MF2_LINKDRAW);
}
return ghost;
@@ -2034,8 +2050,7 @@ void P_SpawnThokMobj(player_t *player)
mobj->eflags |= (player->mo->eflags & MFE_VERTICALFLIP);
// scale
- P_SetScale(mobj, player->mo->scale);
- mobj->destscale = player->mo->scale;
+ P_SetScale(mobj, (mobj->destscale = player->mo->scale));
if (type == MT_THOK) // spintrail-specific modification for MT_THOK
{
@@ -2045,8 +2060,7 @@ void P_SpawnThokMobj(player_t *player)
}
P_SetTarget(&mobj->target, player->mo); // the one thing P_SpawnGhostMobj doesn't do
- if (demorecording)
- G_GhostAddThok();
+ G_GhostAddThok();
}
//
@@ -2211,8 +2225,8 @@ boolean P_PlayerHitFloor(player_t *player, boolean dorollstuff)
{
if (dorollstuff)
{
- if ((player->charability2 == CA2_SPINDASH) && !(player->pflags & PF_THOKKED) && (player->cmd.buttons & BT_USE) && (FixedHypot(player->mo->momx, player->mo->momy) > (5*player->mo->scale)))
- player->pflags |= PF_SPINNING;
+ if ((player->charability2 == CA2_SPINDASH) && !((player->pflags & (PF_SPINNING|PF_THOKKED)) == PF_THOKKED) && (player->cmd.buttons & BT_USE) && (FixedHypot(player->mo->momx, player->mo->momy) > (5*player->mo->scale)))
+ player->pflags = (player->pflags|PF_SPINNING) & ~PF_THOKKED;
else if (!(player->pflags & PF_STARTDASH))
player->pflags &= ~PF_SPINNING;
}
@@ -2249,7 +2263,20 @@ boolean P_PlayerHitFloor(player_t *player, boolean dorollstuff)
else if (!player->skidtime)
player->pflags &= ~PF_GLIDING;
}
- else if (player->charability2 == CA2_MELEE && player->panim == PA_ABILITY2)
+ else if (player->charability == CA_GLIDEANDCLIMB && player->pflags & PF_THOKKED && !(player->pflags & PF_SHIELDABILITY) && player->mo->state-states == S_PLAY_FALL)
+ {
+ if (player->mo->state-states != S_PLAY_GLIDE_LANDING)
+ {
+ P_ResetPlayer(player);
+ P_SetPlayerMobjState(player->mo, S_PLAY_GLIDE_LANDING);
+ S_StartSound(player->mo, sfx_s3k4c);
+ player->pflags |= PF_STASIS;
+ player->mo->momx = ((player->mo->momx - player->cmomx)/3) + player->cmomx;
+ player->mo->momy = ((player->mo->momy - player->cmomy)/3) + player->cmomy;
+ }
+ }
+ else if (player->charability2 == CA2_MELEE
+ && ((player->panim == PA_ABILITY2) || (player->charability == CA_TWINSPIN && player->panim == PA_ABILITY && player->cmd.buttons & (BT_JUMP|BT_USE))))
{
if (player->mo->state-states != S_PLAY_MELEE_LANDING)
{
@@ -2301,7 +2328,7 @@ boolean P_PlayerHitFloor(player_t *player, boolean dorollstuff)
{
if (player->cmomx || player->cmomy)
{
- if (player->charflags & SF_DASHMODE && player->dashmode >= 3*TICRATE && player->panim != PA_DASH)
+ if (player->charflags & SF_DASHMODE && player->dashmode >= DASHMODE_THRESHOLD && player->panim != PA_DASH)
P_SetPlayerMobjState(player->mo, S_PLAY_DASH);
else if (player->speed >= FixedMul(player->runspeed, player->mo->scale)
&& (player->panim != PA_RUN || player->mo->state-states == S_PLAY_FLOAT_RUN))
@@ -2314,7 +2341,7 @@ boolean P_PlayerHitFloor(player_t *player, boolean dorollstuff)
}
else
{
- if (player->charflags & SF_DASHMODE && player->dashmode >= 3*TICRATE && player->panim != PA_DASH)
+ if (player->charflags & SF_DASHMODE && player->dashmode >= DASHMODE_THRESHOLD && player->panim != PA_DASH)
P_SetPlayerMobjState(player->mo, S_PLAY_DASH);
else if (player->speed >= FixedMul(player->runspeed, player->mo->scale)
&& (player->panim != PA_RUN || player->mo->state-states == S_PLAY_FLOAT_RUN))
@@ -2445,39 +2472,42 @@ static void P_CheckBustableBlocks(player_t *player)
if ((rover->flags & FF_BUSTUP)/* && !rover->master->frontsector->crumblestate*/)
{
- // If it's an FF_SPINBUST, you have to either be jumping, or coming down
- // onto the top from a spin.
- if (rover->flags & FF_SPINBUST && ((!(player->pflags & PF_JUMPED) && !(player->pflags & PF_SPINNING) && !(player->pflags & PF_BOUNCING)) || (player->pflags & PF_STARTDASH)))
+ // If it's an FF_SHATTER, you can break it just by touching it.
+ if (rover->flags & FF_SHATTER)
+ goto bust;
+
+ // If it's an FF_SPINBUST, you can break it if you are in your spinning frames
+ // (either from jumping or spindashing).
+ if (rover->flags & FF_SPINBUST
+ && (((player->pflags & PF_SPINNING) && !(player->pflags & PF_STARTDASH))
+ || (player->pflags & PF_JUMPED && !(player->pflags & PF_NOJUMPDAMAGE))))
+ goto bust;
+
+ // You can always break it if you have CA_GLIDEANDCLIMB
+ // or if you are bouncing on it
+ // or you are using CA_TWINSPIN/CA2_MELEE.
+ if (player->charability == CA_GLIDEANDCLIMB
+ || (player->pflags & PF_BOUNCING)
+ || ((player->charability == CA_TWINSPIN) && (player->panim == PA_ABILITY))
+ || (player->charability2 == CA2_MELEE && player->panim == PA_ABILITY2))
+ goto bust;
+
+ if (rover->flags & FF_STRONGBUST)
continue;
- // if it's not an FF_SHATTER, you must be spinning (and not jumping)
- // or be super
- // or have CA_GLIDEANDCLIMB
- // or be in dashmode with SF_DASHMODE
- // or be using CA_TWINSPIN
- // or be using CA2_MELEE
- // or are drilling in NiGHTS
- // or are recording for Metal Sonic
- if (!(rover->flags & FF_SHATTER) && !(rover->flags & FF_SPINBUST)
- && !((player->pflags & PF_SPINNING) && !(player->pflags & PF_JUMPED))
+ // If it's not an FF_STRONGBUST, you can break if you are spinning (and not jumping)
+ // or you are super
+ // or you are in dashmode with SF_DASHMODE
+ // or you are drilling in NiGHTS
+ // or you are recording for Metal Sonic
+ if (!((player->pflags & PF_SPINNING) && !(player->pflags & PF_JUMPED))
&& !(player->powers[pw_super])
- && !(player->charability == CA_GLIDEANDCLIMB)
- && !(player->pflags & PF_BOUNCING)
- && !((player->charflags & SF_DASHMODE) && (player->dashmode >= 3*TICRATE))
- && !((player->charability == CA_TWINSPIN) && (player->panim == PA_ABILITY))
- && !(player->charability2 == CA2_MELEE && player->panim == PA_ABILITY2)
+ && !(((player->charflags & (SF_DASHMODE|SF_MACHINE)) == (SF_DASHMODE|SF_MACHINE)) && (player->dashmode >= DASHMODE_THRESHOLD))
&& !(player->pflags & PF_DRILLING)
&& !metalrecording)
continue;
- // Only players with CA_GLIDEANDCLIMB, or CA_TWINSPIN/CA2_MELEE users can break this rock...
- if (!(rover->flags & FF_SHATTER) && (rover->flags & FF_ONLYKNUX)
- && !(player->charability == CA_GLIDEANDCLIMB
- || (player->pflags & PF_BOUNCING)
- || ((player->charability == CA_TWINSPIN) && (player->panim == PA_ABILITY))
- || (player->charability2 == CA2_MELEE && player->panim == PA_ABILITY2)))
- continue;
-
+ bust:
topheight = P_GetFOFTopZ(player->mo, node->m_sector, rover, player->mo->x, player->mo->y, NULL);
bottomheight = P_GetFOFBottomZ(player->mo, node->m_sector, rover, player->mo->x, player->mo->y, NULL);
@@ -3062,7 +3092,6 @@ static void P_DoClimbing(player_t *player)
glidesector = R_IsPointInSubsector(player->mo->x + platx, player->mo->y + platy);
- if (!glidesector || glidesector->sector != player->mo->subsector->sector)
{
boolean floorclimb = false;
boolean thrust = false;
@@ -3446,9 +3475,13 @@ static void P_DoClimbing(player_t *player)
if (!floorclimb)
{
if (boostup)
+ {
P_SetObjectMomZ(player->mo, 2*FRACUNIT, true);
+ if (cmd->forwardmove)
+ P_SetObjectMomZ(player->mo, 2*player->mo->momz/3, false);
+ }
if (thrust)
- P_InstaThrust(player->mo, player->mo->angle, FixedMul(4*FRACUNIT, player->mo->scale)); // Lil' boost up.
+ P_Thrust(player->mo, player->mo->angle, FixedMul(4*FRACUNIT, player->mo->scale)); // Lil' boost up.
player->climbing = 0;
player->pflags |= P_GetJumpFlags(player);
@@ -3462,12 +3495,6 @@ static void P_DoClimbing(player_t *player)
P_SetPlayerMobjState(player->mo, S_PLAY_JUMP);
}
}
- else
- {
- player->climbing = 0;
- player->pflags |= P_GetJumpFlags(player);
- P_SetPlayerMobjState(player->mo, S_PLAY_JUMP);
- }
if (cmd->sidemove != 0 || cmd->forwardmove != 0)
climb = true;
@@ -3486,15 +3513,28 @@ static void P_DoClimbing(player_t *player)
player->pflags |= P_GetJumpFlags(player);
P_SetPlayerMobjState(player->mo, S_PLAY_JUMP);
P_SetObjectMomZ(player->mo, 4*FRACUNIT, false);
- P_InstaThrust(player->mo, player->mo->angle, FixedMul(-4*FRACUNIT, player->mo->scale));
+ P_Thrust(player->mo, player->mo->angle, FixedMul(-4*FRACUNIT, player->mo->scale));
}
+#define CLIMBCONEMAX FixedAngle(90*FRACUNIT)
if (!demoplayback || P_AnalogMove(player))
{
if (player == &players[consoleplayer])
- localangle = player->mo->angle;
+ {
+ angle_t angdiff = localangle - player->mo->angle;
+ if (angdiff < ANGLE_180 && angdiff > CLIMBCONEMAX)
+ localangle = player->mo->angle + CLIMBCONEMAX;
+ else if (angdiff > ANGLE_180 && angdiff < InvAngle(CLIMBCONEMAX))
+ localangle = player->mo->angle - CLIMBCONEMAX;
+ }
else if (player == &players[secondarydisplayplayer])
- localangle2 = player->mo->angle;
+ {
+ angle_t angdiff = localangle2 - player->mo->angle;
+ if (angdiff < ANGLE_180 && angdiff > CLIMBCONEMAX)
+ localangle2 = player->mo->angle + CLIMBCONEMAX;
+ else if (angdiff > ANGLE_180 && angdiff < InvAngle(CLIMBCONEMAX))
+ localangle2 = player->mo->angle - CLIMBCONEMAX;
+ }
}
if (player->climbing == 0)
@@ -3689,7 +3729,7 @@ static void P_DoTeeter(player_t *player)
bottomheight = *rover->bottomheight;
#endif
- if (P_CheckSolidLava(player->mo, rover))
+ if (P_CheckSolidLava(rover))
;
else if (!(rover->flags & FF_BLOCKPLAYER || rover->flags & FF_QUICKSAND))
continue; // intangible 3d floor
@@ -4142,8 +4182,11 @@ static void P_DoSuperStuff(player_t *player)
{
player->powers[pw_super] = 0;
P_SetPlayerMobjState(player->mo, S_PLAY_STND);
- music_stack_noposition = true; // HACK: Do not reposition next music
- music_stack_fadeout = MUSICRATE/2; // HACK: Fade out current music
+ if (P_IsLocalPlayer(player))
+ {
+ music_stack_noposition = true; // HACK: Do not reposition next music
+ music_stack_fadeout = MUSICRATE/2; // HACK: Fade out current music
+ }
P_RestoreMusic(player);
P_SpawnShieldOrb(player);
@@ -4212,7 +4255,7 @@ static void P_DoSuperStuff(player_t *player)
if (gametype != GT_COOP)
player->powers[pw_flashing] = flashingtics-1;
- if ((player->mo->health > 0) && (player->mo->sprite2 & FF_SPR2SUPER))
+ if (player->mo->sprite2 & FF_SPR2SUPER)
P_SetPlayerMobjState(player->mo, player->mo->state-states);
// Inform the netgame that the champion has fallen in the heat of battle.
@@ -4225,8 +4268,11 @@ static void P_DoSuperStuff(player_t *player)
}
// Resume normal music if you're the console player
- music_stack_noposition = true; // HACK: Do not reposition next music
- music_stack_fadeout = MUSICRATE/2; // HACK: Fade out current music
+ if (P_IsLocalPlayer(player))
+ {
+ music_stack_noposition = true; // HACK: Do not reposition next music
+ music_stack_fadeout = MUSICRATE/2; // HACK: Fade out current music
+ }
P_RestoreMusic(player);
// If you had a shield, restore its visual significance.
@@ -4311,6 +4357,16 @@ void P_DoJump(player_t *player, boolean soundandstate)
if (player->mo->ceilingz-player->mo->floorz <= player->mo->height-1)
return;
+ if (player->powers[pw_carry] == CR_PTERABYTE)
+ {
+ S_StartSound(player->mo, sfx_s3kd7s);
+ player->mo->tracer->cusval += 10;
+ player->mo->tracer->watertop = P_RandomRange(-player->mo->tracer->cusval, player->mo->tracer->cusval) << (FRACBITS - 1);
+ player->mo->tracer->waterbottom = P_RandomRange(-player->mo->tracer->cusval, player->mo->tracer->cusval) << (FRACBITS - 1);
+ player->mo->tracer->cvmem = P_RandomRange(-player->mo->tracer->cusval, player->mo->tracer->cusval) << (FRACBITS - 1);
+ return;
+ }
+
// Jump this high.
if (player->powers[pw_carry] == CR_PLAYER)
{
@@ -4324,6 +4380,7 @@ void P_DoJump(player_t *player, boolean soundandstate)
{
player->mo->momz = 9*FRACUNIT;
player->powers[pw_carry] = CR_NONE;
+ P_SetTarget(&player->mo->tracer->target, NULL);
P_SetTarget(&player->mo->tracer, NULL);
}
else if (player->powers[pw_carry] == CR_ROPEHANG)
@@ -4332,6 +4389,14 @@ void P_DoJump(player_t *player, boolean soundandstate)
player->powers[pw_carry] = CR_NONE;
P_SetTarget(&player->mo->tracer, NULL);
}
+ else if (player->powers[pw_carry] == CR_ROLLOUT)
+ {
+ player->mo->momz = 9*FRACUNIT + player->mo->tracer->momz;
+ player->powers[pw_carry] = CR_NONE;
+ player->mo->tracer->flags |= MF_PUSHABLE;
+ P_SetTarget(&player->mo->tracer->tracer, NULL);
+ P_SetTarget(&player->mo->tracer, NULL);
+ }
else if (player->mo->eflags & MFE_GOOWATER)
{
player->mo->momz = 7*FRACUNIT;
@@ -4457,7 +4522,8 @@ static void P_DoSpinDashDust(player_t *player)
static void P_DoSpinAbility(player_t *player, ticcmd_t *cmd)
{
boolean canstand = true; // can we stand on the ground? (mostly relevant for slopes)
- if (player->pflags & PF_STASIS)
+ if (player->pflags & PF_STASIS
+ && (player->pflags & PF_JUMPSTASIS || player->mo->state-states != S_PLAY_GLIDE_LANDING))
return;
#ifdef HAVE_BLUA
@@ -4481,7 +4547,7 @@ static void P_DoSpinAbility(player_t *player, ticcmd_t *cmd)
{
case CA2_SPINDASH: // Spinning and Spindashing
// Start revving
- if ((cmd->buttons & BT_USE) && player->speed < FixedMul(5<<FRACBITS, player->mo->scale)
+ if ((cmd->buttons & BT_USE) && (player->speed < FixedMul(5<<FRACBITS, player->mo->scale) || player->mo->state - states == S_PLAY_GLIDE_LANDING)
&& !player->mo->momz && onground && !(player->pflags & (PF_USEDOWN|PF_SPINNING))
&& canstand)
{
@@ -4508,8 +4574,7 @@ static void P_DoSpinAbility(player_t *player, ticcmd_t *cmd)
if (player->revitem && !(leveltime % 5)) // Now spawn the color thok circle.
{
P_SpawnSpinMobj(player, player->revitem);
- if (demorecording)
- G_GhostAddRev();
+ G_GhostAddRev();
}
}
@@ -4643,8 +4708,9 @@ static void P_DoSpinAbility(player_t *player, ticcmd_t *cmd)
if (player->speed < FixedMul(player->maxdash, player->mo->scale))
#endif
{
- player->drawangle = player->mo->angle;
- P_InstaThrust(player->mo, player->mo->angle, FixedMul(player->maxdash, player->mo->scale));
+ if (player->panim == PA_IDLE)
+ player->drawangle = player->mo->angle;
+ P_InstaThrust(player->mo, player->drawangle, FixedMul(player->maxdash, player->mo->scale));
}
player->mo->momx += player->cmomx;
player->mo->momy += player->cmomy;
@@ -5236,13 +5302,23 @@ static void P_DoJumpStuff(player_t *player, ticcmd_t *cmd)
// Now Knuckles-type abilities are checked.
if (!(player->pflags & PF_THOKKED) || player->charflags & SF_MULTIABILITY)
{
- INT32 glidespeed = player->actionspd;
+ fixed_t glidespeed = FixedMul(player->actionspd, player->mo->scale);
+ fixed_t playerspeed = player->speed;
+
+ if (player->mo->eflags & MFE_UNDERWATER)
+ {
+ glidespeed >>= 1;
+ playerspeed >>= 1;
+ player->mo->momx = ((player->mo->momx - player->cmomx) >> 1) + player->cmomx;
+ player->mo->momy = ((player->mo->momy - player->cmomy) >> 1) + player->cmomy;
+ }
player->pflags |= PF_GLIDING|PF_THOKKED;
player->glidetime = 0;
P_SetPlayerMobjState(player->mo, S_PLAY_GLIDE);
- P_InstaThrust(player->mo, player->mo->angle, FixedMul(glidespeed, player->mo->scale));
+ if (playerspeed < glidespeed)
+ P_Thrust(player->mo, player->mo->angle, glidespeed - playerspeed);
player->pflags &= ~(PF_SPINNING|PF_STARTDASH);
}
break;
@@ -5259,7 +5335,7 @@ static void P_DoJumpStuff(player_t *player, ticcmd_t *cmd)
case CA_SLOWFALL: // Slow descent hover
if (!(player->pflags & PF_THOKKED) || player->charflags & SF_MULTIABILITY)
{
- if (player->charflags & SF_DASHMODE && player->dashmode >= 3*TICRATE)
+ if (player->charflags & SF_DASHMODE && player->dashmode >= DASHMODE_THRESHOLD)
P_SetPlayerMobjState(player->mo, S_PLAY_DASH);
else if (player->speed >= FixedMul(player->runspeed, player->mo->scale))
P_SetPlayerMobjState(player->mo, S_PLAY_FLOAT_RUN);
@@ -5685,7 +5761,7 @@ static void P_2dMovement(player_t *player)
if (player->climbing)
{
if (cmd->forwardmove != 0)
- P_SetObjectMomZ(player->mo, FixedDiv(cmd->forwardmove*FRACUNIT,10*FRACUNIT), false);
+ P_SetObjectMomZ(player->mo, FixedDiv(cmd->forwardmove*FRACUNIT, 15*FRACUNIT>>1), false);
player->mo->momx = 0;
}
@@ -5699,7 +5775,7 @@ static void P_2dMovement(player_t *player)
movepushforward >>= 1; // Proper air movement
// Allow a bit of movement while spinning
- if (player->pflags & PF_SPINNING)
+ if ((player->pflags & (PF_SPINNING|PF_THOKKED)) == PF_SPINNING)
{
if (!(player->pflags & PF_STARTDASH))
movepushforward = movepushforward/48;
@@ -5726,7 +5802,7 @@ static void P_3dMovement(player_t *player)
angle_t dangle; // replaces old quadrants bits
fixed_t normalspd = FixedMul(player->normalspeed, player->mo->scale);
boolean analogmove = false;
- boolean spin = ((onground = P_IsObjectOnGround(player->mo)) && player->pflags & PF_SPINNING && (player->rmomx || player->rmomy) && !(player->pflags & PF_STARTDASH));
+ boolean spin = ((onground = P_IsObjectOnGround(player->mo)) && (player->pflags & (PF_SPINNING|PF_THOKKED)) == PF_SPINNING && (player->rmomx || player->rmomy) && !(player->pflags & PF_STARTDASH));
fixed_t oldMagnitude, newMagnitude;
#ifdef ESLOPE
vector3_t totalthrust;
@@ -5842,35 +5918,28 @@ static void P_3dMovement(player_t *player)
else
topspeed = normalspd;
}
- else if (player->powers[pw_super] || player->powers[pw_sneakers])
+ else
{
- thrustfactor = player->thrustfactor*2;
- acceleration = player->accelstart/2 + (FixedDiv(player->speed, player->mo->scale)>>FRACBITS) * player->acceleration/2;
-
- if (player->powers[pw_tailsfly])
- topspeed = normalspd;
- else if (player->mo->eflags & (MFE_UNDERWATER|MFE_GOOWATER))
+ if (player->powers[pw_super] || player->powers[pw_sneakers])
{
- topspeed = normalspd;
- acceleration = 2*acceleration/3;
+ topspeed = 5 * normalspd / 3; // 1.67x
+ thrustfactor = player->thrustfactor*2;
+ acceleration = player->accelstart/2 + (FixedDiv(player->speed, player->mo->scale)>>FRACBITS) * player->acceleration/2;
}
else
- topspeed = normalspd * 2;
- }
- else
- {
- thrustfactor = player->thrustfactor;
- acceleration = player->accelstart + (FixedDiv(player->speed, player->mo->scale)>>FRACBITS) * player->acceleration;
+ {
+ topspeed = normalspd;
+ thrustfactor = player->thrustfactor;
+ acceleration = player->accelstart + (FixedDiv(player->speed, player->mo->scale)>>FRACBITS) * player->acceleration;
+ }
if (player->powers[pw_tailsfly])
- topspeed = normalspd/2;
+ topspeed >>= 1;
else if (player->mo->eflags & (MFE_UNDERWATER|MFE_GOOWATER))
{
- topspeed = normalspd/2;
+ topspeed >>= 1;
acceleration = 2*acceleration/3;
}
- else
- topspeed = normalspd;
}
if (spin) // Prevent gaining speed whilst rolling!
@@ -5909,7 +5978,12 @@ static void P_3dMovement(player_t *player)
if (player->climbing)
{
if (cmd->forwardmove)
- P_SetObjectMomZ(player->mo, FixedDiv(cmd->forwardmove*FRACUNIT, 10*FRACUNIT), false);
+ {
+ if (player->mo->eflags & MFE_UNDERWATER)
+ P_SetObjectMomZ(player->mo, FixedDiv(cmd->forwardmove*FRACUNIT, 10*FRACUNIT), false);
+ else
+ P_SetObjectMomZ(player->mo, FixedDiv(cmd->forwardmove*FRACUNIT, 15*FRACUNIT>>1), false);
+ }
}
else if (!analogmove
&& cmd->forwardmove != 0 && !(player->pflags & PF_GLIDING || player->exiting
@@ -5918,7 +5992,7 @@ static void P_3dMovement(player_t *player)
movepushforward = cmd->forwardmove * (thrustfactor * acceleration);
// Allow a bit of movement while spinning
- if (player->pflags & PF_SPINNING)
+ if ((player->pflags & (PF_SPINNING|PF_THOKKED)) == PF_SPINNING)
{
if ((mforward && cmd->forwardmove > 0) || (mbackward && cmd->forwardmove < 0)
|| (player->pflags & PF_STARTDASH))
@@ -5943,7 +6017,12 @@ static void P_3dMovement(player_t *player)
}
// Sideways movement
if (player->climbing)
- P_InstaThrust(player->mo, player->mo->angle-ANGLE_90, FixedMul(FixedDiv(cmd->sidemove*FRACUNIT, 10*FRACUNIT), player->mo->scale));
+ {
+ if (player->mo->eflags & MFE_UNDERWATER)
+ P_InstaThrust(player->mo, player->mo->angle-ANGLE_90, FixedDiv(cmd->sidemove*player->mo->scale, 10*FRACUNIT));
+ else
+ P_InstaThrust(player->mo, player->mo->angle-ANGLE_90, FixedDiv(cmd->sidemove*player->mo->scale, 15*FRACUNIT>>1));
+ }
// Analog movement control
else if (analogmove)
{
@@ -5959,7 +6038,7 @@ static void P_3dMovement(player_t *player)
movepushforward = max(abs(cmd->sidemove), abs(cmd->forwardmove)) * (thrustfactor * acceleration);
// Allow a bit of movement while spinning
- if (player->pflags & PF_SPINNING)
+ if ((player->pflags & (PF_SPINNING|PF_THOKKED)) == PF_SPINNING)
{
if ((mforward && cmd->forwardmove > 0) || (mbackward && cmd->forwardmove < 0)
|| (player->pflags & PF_STARTDASH))
@@ -5994,11 +6073,11 @@ static void P_3dMovement(player_t *player)
{
movepushside >>= 2; // proper air movement
// Reduce movepushslide even more if over "max" flight speed
- if ((player->pflags & PF_SPINNING) || (player->powers[pw_tailsfly] && player->speed > topspeed))
+ if (((player->pflags & (PF_SPINNING|PF_THOKKED)) == PF_SPINNING) || (player->powers[pw_tailsfly] && player->speed > topspeed))
movepushside >>= 2;
}
// Allow a bit of movement while spinning
- else if (player->pflags & PF_SPINNING)
+ else if ((player->pflags & (PF_SPINNING|PF_THOKKED)) == PF_SPINNING)
{
if (player->pflags & PF_STARTDASH)
movepushside = 0;
@@ -7350,10 +7429,13 @@ static void P_NiGHTSMovement(player_t *player)
&& player->mo->z + player->mo->height - P_GetPlayerHeight(player) <= player->mo->waterbottom && player->mo->z + player->mo->height >= player->mo->waterbottom))
&& player->speed > 9000 && leveltime % (TICRATE/7) == 0 && !player->spectator)
{
+ mobjtype_t splishtype = (player->mo->eflags & MFE_TOUCHLAVA) ? MT_LAVASPLISH : MT_SPLISH;
mobj_t *water = P_SpawnMobj(player->mo->x, player->mo->y,
- ((player->mo->eflags & MFE_VERTICALFLIP) ? player->mo->waterbottom - FixedMul(mobjinfo[MT_SPLISH].height, player->mo->scale) : player->mo->watertop), MT_SPLISH);
+ ((player->mo->eflags & MFE_VERTICALFLIP) ? player->mo->waterbottom - FixedMul(mobjinfo[splishtype].height, player->mo->scale) : player->mo->watertop), splishtype);
if (player->mo->eflags & MFE_GOOWATER)
S_StartSound(water, sfx_ghit);
+ else if (player->mo->eflags & MFE_TOUCHLAVA)
+ S_StartSound(water, sfx_splash);
else
S_StartSound(water, sfx_wslap);
if (player->mo->eflags & MFE_VERTICALFLIP)
@@ -7639,15 +7721,17 @@ static void P_SkidStuff(player_t *player)
{
player->skidtime = 0;
player->pflags &= ~(PF_GLIDING|PF_JUMPED|PF_NOJUMPDAMAGE);
+ player->pflags |= PF_THOKKED; // nice try, speedrunners (but for real this is just behavior from S3K)
P_SetPlayerMobjState(player->mo, S_PLAY_FALL);
}
// Get up and brush yourself off, idiot.
- else if (player->glidetime > 15)
+ else if (player->glidetime > 15 || !(player->cmd.buttons & BT_JUMP))
{
P_ResetPlayer(player);
- P_SetPlayerMobjState(player->mo, S_PLAY_STND);
- player->mo->momx = player->cmomx;
- player->mo->momy = player->cmomy;
+ P_SetPlayerMobjState(player->mo, S_PLAY_GLIDE_LANDING);
+ player->pflags |= PF_STASIS;
+ player->mo->momx = ((player->mo->momx - player->cmomx)/3) + player->cmomx;
+ player->mo->momy = ((player->mo->momy - player->cmomy)/3) + player->cmomy;
}
// Didn't stop yet? Skid FOREVER!
else if (player->skidtime == 1)
@@ -7655,7 +7739,8 @@ static void P_SkidStuff(player_t *player)
// Spawn a particle every 3 tics.
else if (!(player->skidtime % 3))
{
- mobj_t *particle = P_SpawnMobjFromMobj(player->mo, P_RandomRange(-player->mo->radius, player->mo->radius), P_RandomRange(-player->mo->radius, player->mo->radius), 0, MT_SPINDUST);
+ fixed_t radius = player->mo->radius >> FRACBITS;
+ mobj_t *particle = P_SpawnMobjFromMobj(player->mo, P_RandomRange(-radius, radius) << FRACBITS, P_RandomRange(-radius, radius) << FRACBITS, 0, MT_SPINDUST);
particle->tics = 10;
particle->destscale = (2*player->mo->scale)/3;
@@ -7753,6 +7838,12 @@ static void P_MovePlayer(player_t *player)
if (!(player->powers[pw_nocontrol] & (1<<15)))
player->pflags |= PF_JUMPSTASIS;
}
+
+ if (player->charability == CA_GLIDEANDCLIMB && player->mo->state-states == S_PLAY_GLIDE_LANDING)
+ {
+ player->pflags |= PF_STASIS;
+ }
+
// note: don't unset stasis here
if (!player->spectator && G_TagGametype())
@@ -7908,7 +7999,7 @@ static void P_MovePlayer(player_t *player)
if ((cmd->forwardmove != 0 || cmd->sidemove != 0) || (player->powers[pw_super] && !onground))
{
// If the player is in dashmode, here's their peelout.
- if (player->charflags & SF_DASHMODE && player->dashmode >= 3*TICRATE && player->panim == PA_RUN && !player->skidtime && (onground || ((player->charability == CA_FLOAT || player->charability == CA_SLOWFALL) && player->secondjump == 1) || player->powers[pw_super]))
+ if (player->charflags & SF_DASHMODE && player->dashmode >= DASHMODE_THRESHOLD && player->panim == PA_RUN && !player->skidtime && (onground || ((player->charability == CA_FLOAT || player->charability == CA_SLOWFALL) && player->secondjump == 1) || player->powers[pw_super]))
P_SetPlayerMobjState (player->mo, S_PLAY_DASH);
// If the player is moving fast enough,
// break into a run!
@@ -7932,7 +8023,7 @@ static void P_MovePlayer(player_t *player)
// If your peelout animation is playing, and you're
// going too slow, switch back to the run.
- if (player->charflags & SF_DASHMODE && player->panim == PA_DASH && player->dashmode < 3*TICRATE)
+ if (player->charflags & SF_DASHMODE && player->panim == PA_DASH && player->dashmode < DASHMODE_THRESHOLD)
P_SetPlayerMobjState(player->mo, S_PLAY_RUN);
// If your running animation is playing, and you're
@@ -8012,10 +8103,13 @@ static void P_MovePlayer(player_t *player)
// AKA my own gravity. =)
if (player->pflags & PF_GLIDING)
{
+ mobj_t *mo = player->mo; // seriously why isn't this at the top of the function hngngngng
fixed_t leeway;
fixed_t glidespeed = player->actionspd;
+ fixed_t momx = mo->momx - player->cmomx, momy = mo->momy - player->cmomy;
+ angle_t angle, moveangle = R_PointToAngle2(0, 0, momx, momy);
- if (player->powers[pw_super])
+ if (player->powers[pw_super] || player->powers[pw_sneakers])
glidespeed *= 2;
if (player->mo->eflags & MFE_VERTICALFLIP)
@@ -8030,22 +8124,46 @@ static void P_MovePlayer(player_t *player)
}
// Strafing while gliding.
- leeway = FixedAngle(cmd->sidemove*(FRACUNIT/2));
+ leeway = FixedAngle(cmd->sidemove*(FRACUNIT));
+ angle = mo->angle - leeway;
- if (player->skidtime) // ground gliding
+ if (!player->skidtime) // TODO: make sure this works in 2D!
{
- fixed_t speed = FixedMul(glidespeed, FRACUNIT - (FRACUNIT>>2));
- if (player->mo->eflags & MFE_UNDERWATER)
- speed >>= 1;
- speed = FixedMul(speed - player->glidetime*FRACUNIT, player->mo->scale);
- if (speed < 0)
- speed = 0;
- P_InstaThrust(player->mo, player->mo->angle-leeway, speed);
+ fixed_t speed, scale = mo->scale;
+ fixed_t newMagnitude, oldMagnitude = R_PointToDist2(momx, momy, 0, 0);
+ fixed_t accelfactor = 4*FRACUNIT - 3*FINECOSINE(((angle-moveangle) >> ANGLETOFINESHIFT) & FINEMASK); // mamgic number BAD but this feels right
+
+ if (mo->eflags & MFE_UNDERWATER)
+ speed = FixedMul((glidespeed>>1) + player->glidetime*750, scale);
+ else
+ speed = FixedMul(glidespeed + player->glidetime*1500, scale);
+
+ P_Thrust(mo, angle, FixedMul(accelfactor, scale));
+
+ newMagnitude = R_PointToDist2(player->mo->momx - player->cmomx, player->mo->momy - player->cmomy, 0, 0);
+ if (newMagnitude > speed)
+ {
+ fixed_t tempmomx, tempmomy;
+ if (oldMagnitude > speed)
+ {
+ if (newMagnitude > oldMagnitude)
+ {
+ tempmomx = FixedMul(FixedDiv(player->mo->momx - player->cmomx, newMagnitude), oldMagnitude);
+ tempmomy = FixedMul(FixedDiv(player->mo->momy - player->cmomy, newMagnitude), oldMagnitude);
+ player->mo->momx = tempmomx + player->cmomx;
+ player->mo->momy = tempmomy + player->cmomy;
+ }
+ // else do nothing
+ }
+ else
+ {
+ tempmomx = FixedMul(FixedDiv(player->mo->momx - player->cmomx, newMagnitude), speed);
+ tempmomy = FixedMul(FixedDiv(player->mo->momy - player->cmomy, newMagnitude), speed);
+ player->mo->momx = tempmomx + player->cmomx;
+ player->mo->momy = tempmomy + player->cmomy;
+ }
+ }
}
- else if (player->mo->eflags & MFE_UNDERWATER)
- P_InstaThrust(player->mo, player->mo->angle-leeway, FixedMul((glidespeed>>1) + player->glidetime*750, player->mo->scale));
- else
- P_InstaThrust(player->mo, player->mo->angle-leeway, FixedMul(glidespeed + player->glidetime*1500, player->mo->scale));
player->glidetime++;
@@ -8070,18 +8188,9 @@ static void P_MovePlayer(player_t *player)
}
else if (player->climbing) // 'Deceleration' for climbing on walls.
{
- if (player->mo->momz > 0)
- {
- player->mo->momz -= FixedMul(FRACUNIT/2, player->mo->scale);
- if (player->mo->momz < 0)
- player->mo->momz = 0;
- }
- else if (player->mo->momz < 0)
- {
- player->mo->momz += FixedMul(FRACUNIT/2, player->mo->scale);
- if (player->mo->momz > 0)
- player->mo->momz = 0;
- }
+
+ if (!player->cmd.forwardmove)
+ player->mo->momz = 0;
}
else if (player->pflags & PF_BOUNCING)
{
@@ -8115,10 +8224,13 @@ static void P_MovePlayer(player_t *player)
&& (player->speed > runspd || (player->pflags & PF_STARTDASH))
&& leveltime % (TICRATE/7) == 0 && player->mo->momz == 0 && !(player->pflags & PF_SLIDING) && !player->spectator)
{
+ mobjtype_t splishtype = (player->mo->eflags & MFE_TOUCHLAVA) ? MT_LAVASPLISH : MT_SPLISH;
mobj_t *water = P_SpawnMobj(player->mo->x - P_ReturnThrustX(NULL, player->mo->angle, player->mo->radius), player->mo->y - P_ReturnThrustY(NULL, player->mo->angle, player->mo->radius),
- ((player->mo->eflags & MFE_VERTICALFLIP) ? player->mo->waterbottom - FixedMul(mobjinfo[MT_SPLISH].height, player->mo->scale) : player->mo->watertop), MT_SPLISH);
+ ((player->mo->eflags & MFE_VERTICALFLIP) ? player->mo->waterbottom - FixedMul(mobjinfo[splishtype].height, player->mo->scale) : player->mo->watertop), splishtype);
if (player->mo->eflags & MFE_GOOWATER)
S_StartSound(water, sfx_ghit);
+ else if (player->mo->eflags & MFE_TOUCHLAVA)
+ S_StartSound(water, sfx_splash);
else
S_StartSound(water, sfx_wslap);
if (player->mo->eflags & MFE_VERTICALFLIP)
@@ -8231,8 +8343,7 @@ static void P_MovePlayer(player_t *player)
if (player->pflags & PF_SPINNING && P_AproxDistance(player->speed, player->mo->momz) > FixedMul(15<<FRACBITS, player->mo->scale) && !(player->pflags & PF_JUMPED))
{
P_SpawnSpinMobj(player, player->spinitem);
- if (demorecording)
- G_GhostAddSpin();
+ G_GhostAddSpin();
}
@@ -8504,6 +8615,9 @@ static void P_MovePlayer(player_t *player)
// Look for Quicksand!
if (CheckForQuicksand)
P_CheckQuicksand(player);
+
+ if (P_IsObjectOnGround(player->mo))
+ player->mo->pmomz = 0;
}
static void P_DoZoomTube(player_t *player)
@@ -8855,7 +8969,7 @@ void P_NukeEnemies(mobj_t *inflictor, mobj_t *source, fixed_t radius)
continue;
if (mo->type == MT_MINUS && !(mo->flags & (MF_SPECIAL|MF_SHOOTABLE)))
- mo->flags |= MF_SPECIAL|MF_SHOOTABLE;
+ mo->flags = (mo->flags & ~MF_NOCLIPTHING)|MF_SPECIAL|MF_SHOOTABLE;
if (mo->type == MT_EGGGUARD && mo->tracer) //nuke Egg Guard's shield!
P_KillMobj(mo->tracer, inflictor, source, DMG_NUKE);
@@ -9407,7 +9521,7 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
fixed_t x, y, z, dist, distxy, distz, checkdist, viewpointx, viewpointy, camspeed, camdist, camheight, pviewheight, slopez = 0;
INT32 camrotate;
boolean camstill, cameranoclip, camorbit;
- mobj_t *mo;
+ mobj_t *mo, *sign = NULL;
subsector_t *newsubsec;
fixed_t f1, f2;
@@ -9417,6 +9531,9 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
mo = player->mo;
+ if (player->exiting && mo->target && mo->target->type == MT_SIGN)
+ sign = mo->target;
+
cameranoclip = (player->powers[pw_carry] == CR_NIGHTSMODE || player->pflags & PF_NOCLIP) || (mo->flags & (MF_NOCLIP|MF_NOCLIPHEIGHT)); // Noclipping player camera noclips too!!
if (!(player->climbing || (player->powers[pw_carry] == CR_NIGHTSMODE) || player->playerstate == PST_DEAD || tutorialmode))
@@ -9463,6 +9580,11 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
focusangle = mo->angle;
focusaiming = 0;
}
+ else if (sign)
+ {
+ focusangle = FixedAngle(sign->spawnpoint->angle << FRACBITS) + ANGLE_180;
+ focusaiming = 0;
+ }
else if (player == &players[consoleplayer])
{
focusangle = localangle;
@@ -9611,6 +9733,12 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
camheight = FixedMul(camheight, 6*FRACUNIT/5);
}
+ if (sign)
+ {
+ camheight = mo->scale << 7;
+ camspeed = FRACUNIT/12;
+ }
+
if (player->climbing || player->exiting || player->playerstate == PST_DEAD || (player->powers[pw_carry] == CR_ROPEHANG || player->powers[pw_carry] == CR_GENERIC || player->powers[pw_carry] == CR_MACESPIN))
dist <<= 1;
}
@@ -9657,8 +9785,16 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
distz = slopez;
}
- x = mo->x - FixedMul(FINECOSINE((angle>>ANGLETOFINESHIFT) & FINEMASK), distxy);
- y = mo->y - FixedMul(FINESINE((angle>>ANGLETOFINESHIFT) & FINEMASK), distxy);
+ if (sign)
+ {
+ x = sign->x - FixedMul(FINECOSINE((angle>>ANGLETOFINESHIFT) & FINEMASK), distxy);
+ y = sign->y - FixedMul(FINESINE((angle>>ANGLETOFINESHIFT) & FINEMASK), distxy);
+ }
+ else
+ {
+ x = mo->x - FixedMul(FINECOSINE((angle>>ANGLETOFINESHIFT) & FINEMASK), distxy);
+ y = mo->y - FixedMul(FINESINE((angle>>ANGLETOFINESHIFT) & FINEMASK), distxy);
+ }
#if 0
if (twodlevel || (mo->flags2 & MF2_TWOD))
@@ -9903,14 +10039,30 @@ boolean P_MoveChaseCamera(player_t *player, camera_t *thiscam, boolean resetcall
// point viewed by the camera
// this point is just 64 unit forward the player
dist = FixedMul(64 << FRACBITS, mo->scale);
- viewpointx = mo->x + FixedMul(FINECOSINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
- viewpointy = mo->y + FixedMul(FINESINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
+ if (sign)
+ {
+ viewpointx = sign->x + FixedMul(FINECOSINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
+ viewpointy = sign->y + FixedMul(FINESINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
+ }
+ else
+ {
+ viewpointx = mo->x + FixedMul(FINECOSINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
+ viewpointy = mo->y + FixedMul(FINESINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
+ }
if (!camstill && !resetcalled && !paused)
thiscam->angle = R_PointToAngle2(thiscam->x, thiscam->y, viewpointx, viewpointy);
- viewpointx = mo->x + FixedMul(FINECOSINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
- viewpointy = mo->y + FixedMul(FINESINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
+ if (sign)
+ {
+ viewpointx = sign->x + FixedMul(FINECOSINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
+ viewpointy = sign->y + FixedMul(FINESINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
+ }
+ else
+ {
+ viewpointx = mo->x + FixedMul(FINECOSINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
+ viewpointy = mo->y + FixedMul(FINESINE((angle>>ANGLETOFINESHIFT) & FINEMASK), dist);
+ }
/*
if (twodlevel || (mo->flags2 & MF2_TWOD))
@@ -10254,7 +10406,7 @@ static sector_t *P_GetMinecartSector(fixed_t x, fixed_t y, fixed_t z, fixed_t *n
ffloor_t *rover;
for (rover = sec->ffloors; rover; rover = rover->next)
{
- if (!(rover->flags & FF_EXISTS))
+ if (!(rover->flags & (FF_EXISTS|FF_BLOCKOTHERS)))
continue;
*nz = *rover->t_slope ? P_GetZAt(*rover->t_slope, x, y) : *rover->topheight;
@@ -10426,7 +10578,7 @@ static mobj_t *P_LookForRails(mobj_t* mobj, fixed_t c, fixed_t s, angle_t target
//Axes must be directly parallel or antiparallel, give or take 5 degrees.
if (angdiff < ANG10)
{
- mark = P_SpawnMobj(nx, ny, nz, mobj->info->raisestate);
+ mark = P_SpawnMobj(nx, ny, nz, (mobjtype_t)mobj->info->raisestate);
return mark;
}
}
@@ -10641,7 +10793,11 @@ static void P_MinecartThink(player_t *player)
}
}
- P_SetPlayerMobjState(player->mo, S_PLAY_STND);
+ if (player->mo->state-states != S_PLAY_STND)
+ {
+ P_SetPlayerMobjState(player->mo, S_PLAY_STND);
+ player->mo->tics = -1;
+ }
// Move player to minecart.
P_TeleportMove(player->mo, minecart->x - minecart->momx, minecart->y - minecart->momy, minecart->z + max(minecart->momz, 0) + 8*FRACUNIT);
@@ -10852,6 +11008,121 @@ static void P_DoTailsOverlay(player_t *player, mobj_t *tails)
P_SetThingPosition(tails);
}
+// Metal Sonic's jet fume
+static void P_DoMetalJetFume(player_t *player, mobj_t *fume)
+{
+ static const UINT8 FUME_SKINCOLORS[] =
+ {
+ SKINCOLOR_ICY,
+ SKINCOLOR_SKY,
+ SKINCOLOR_CYAN,
+ SKINCOLOR_WAVE,
+ SKINCOLOR_TEAL,
+ SKINCOLOR_AQUA,
+ SKINCOLOR_SEAFOAM,
+ SKINCOLOR_MINT,
+ SKINCOLOR_PERIDOT,
+ SKINCOLOR_LIME,
+ SKINCOLOR_YELLOW,
+ SKINCOLOR_SANDY,
+ SKINCOLOR_GOLD,
+ SKINCOLOR_APRICOT,
+ SKINCOLOR_SUNSET
+ };
+ mobj_t *mo = player->mo;
+ angle_t angle = player->drawangle;
+ fixed_t dist;
+ panim_t panim = player->panim;
+ tic_t dashmode = player->dashmode;
+ boolean underwater = mo->eflags & MFE_UNDERWATER;
+ statenum_t stat = fume->state-states;
+
+ if (panim != PA_WALK && panim != PA_RUN && panim != PA_DASH) // turn invisible when not in a coherent movement state
+ {
+ if (stat != fume->info->spawnstate)
+ P_SetMobjState(fume, fume->info->spawnstate);
+ return;
+ }
+
+ if (underwater) // No fume underwater; spawn bubbles instead!
+ {
+ fume->movedir += FixedAngle(FixedDiv(2 * player->speed, 3 * mo->scale));
+ fume->movefactor += player->speed;
+
+ if (fume->movefactor > FixedDiv(2 * player->normalspeed, 3 * mo->scale))
+ {
+ INT16 i;
+ fixed_t radiusV = 4*FRACUNIT;
+ fixed_t radiusX = P_ReturnThrustX(mo, angle, -mo->radius >> (panim == PA_WALK ? 1 : 0));
+ fixed_t radiusY = P_ReturnThrustY(mo, angle, -mo->radius >> (panim == PA_WALK ? 1 : 0));
+ fixed_t factorX = P_ReturnThrustX(mo, angle + ANGLE_90, mo->scale);
+ fixed_t factorY = P_ReturnThrustY(mo, angle + ANGLE_90, mo->scale);
+ fixed_t offsetH, offsetV, x, y, z;
+
+ for (i = -1; i < 2; i += 2)
+ {
+ offsetH = i*P_ReturnThrustX(fume, fume->movedir, radiusV);
+ offsetV = i*P_ReturnThrustY(fume, fume->movedir, radiusV);
+ x = mo->x + radiusX + FixedMul(offsetH, factorX);
+ y = mo->y + radiusY + FixedMul(offsetH, factorY);
+ z = mo->z + (mo->height >> 1) + offsetV;
+ P_SpawnMobj(x, y, z, MT_SMALLBUBBLE)->scale = mo->scale >> 1;
+ }
+
+ fume->movefactor = 0;
+ }
+
+ if (panim == PA_WALK)
+ {
+ if (stat != fume->info->spawnstate)
+ P_SetMobjState(fume, fume->info->spawnstate);
+ return;
+ }
+ }
+
+ if (stat == fume->info->spawnstate) // If currently inivisble, activate!
+ {
+ P_SetMobjState(fume, (stat = fume->info->seestate));
+ P_SetScale(fume, mo->scale);
+ }
+
+ if (dashmode > DASHMODE_THRESHOLD && stat != fume->info->seestate) // If in dashmode, grow really big and flash
+ {
+ fume->destscale = mo->scale;
+ fume->flags2 ^= MF2_DONTDRAW;
+ fume->flags2 |= mo->flags2 & MF2_DONTDRAW;
+ }
+ else // Otherwise, pick a size and color depending on speed and proximity to dashmode
+ {
+ if (dashmode == DASHMODE_THRESHOLD && dashmode > (tic_t)fume->movecount) // If just about to enter dashmode, play the startup animation again
+ {
+ P_SetMobjState(fume, (stat = fume->info->seestate));
+ P_SetScale(fume, mo->scale << 1);
+ }
+ fume->flags2 = (fume->flags2 & ~MF2_DONTDRAW) | (mo->flags2 & MF2_DONTDRAW);
+ fume->destscale = (mo->scale + FixedDiv(player->speed, player->normalspeed)) / (underwater ? 6 : 3);
+ fume->color = FUME_SKINCOLORS[(dashmode * sizeof(FUME_SKINCOLORS)) / (DASHMODE_MAX + 1)];
+
+ if (underwater)
+ {
+ fume->frame = (fume->frame & FF_FRAMEMASK) | FF_ANIMATE | (P_RandomRange(0, 9) * FF_TRANS10);
+ }
+ }
+
+ fume->movecount = dashmode; // keeps track of previous dashmode value so we know whether Metal is entering or leaving it
+ fume->eflags = (fume->flags2 & ~MF2_OBJECTFLIP) | (mo->flags2 & MF2_OBJECTFLIP); // Make sure to flip in reverse gravity!
+ fume->eflags = (fume->eflags & ~MFE_VERTICALFLIP) | (mo->eflags & MFE_VERTICALFLIP); // Make sure to flip in reverse gravity!
+
+ // Finally, set its position
+ dist = -mo->radius - FixedMul(fume->info->radius, fume->destscale - mo->scale/3);
+
+ P_UnsetThingPosition(fume);
+ fume->x = mo->x + P_ReturnThrustX(fume, angle, dist);
+ fume->y = mo->y + P_ReturnThrustY(fume, angle, dist);
+ fume->z = mo->z + ((mo->height - fume->height) >> 1);
+ P_SetThingPosition(fume);
+}
+
//
// P_PlayerThink
//
@@ -11240,19 +11511,27 @@ void P_PlayerThink(player_t *player)
// deez New User eXperiences.
{
+ angle_t oldang = player->drawangle, diff = 0;
+ UINT8 factor;
// Directionchar!
// Camera angle stuff.
if (player->exiting // no control, no modification
|| player->powers[pw_carry] == CR_NIGHTSMODE)
;
else if (!(player->pflags & PF_DIRECTIONCHAR)
- || (player->climbing // stuff where the direction is forced at all times
- || (player->pflags & PF_GLIDING))
+ || (player->climbing) // stuff where the direction is forced at all times
|| (P_AnalogMove(player) || twodlevel || player->mo->flags2 & MF2_TWOD) // keep things synchronised up there, since the camera IS seperate from player motion when that happens
|| G_RingSlingerGametype()) // no firing rings in directions your player isn't aiming
player->drawangle = player->mo->angle;
else if (P_PlayerInPain(player))
;
+ else if (player->powers[pw_justsprung]) // restricted, potentially by lua
+ {
+#ifdef SPRINGSPIN
+ if (player->powers[pw_justsprung] & (1<<15))
+ player->drawangle += (player->powers[pw_justsprung] & ~(1<<15))*(ANG2+ANG1);
+#endif
+ }
else if (player->powers[pw_carry] && player->mo->tracer) // carry
{
switch (player->powers[pw_carry])
@@ -11266,8 +11545,16 @@ void P_PlayerThink(player_t *player)
/* FALLTHRU */
case CR_MINECART:
case CR_GENERIC:
+ case CR_PTERABYTE:
player->drawangle = player->mo->tracer->angle;
break;
+ case CR_ROLLOUT:
+ if (cmd->forwardmove || cmd->sidemove) // only when you're pressing movement keys
+ { // inverse direction!
+ diff = ((player->mo->angle + R_PointToAngle2(0, 0, -cmd->forwardmove<<FRACBITS, cmd->sidemove<<FRACBITS)) - player->drawangle);
+ factor = 4;
+ }
+ break;
/* -- in case we wanted to have the camera freely movable during zoom tubes
case CR_ZOOMTUBE:*/
case CR_ROPEHANG:
@@ -11288,16 +11575,21 @@ void P_PlayerThink(player_t *player)
;
else
{
- angle_t diff;
- UINT8 factor;
-
- if (player->pflags & PF_SLIDING)
+ if (player->pflags & PF_GLIDING)
+ {
+ if (player->speed < player->mo->scale)
+ diff = player->mo->angle - player->drawangle;
+ else
+ diff = (R_PointToAngle2(0, 0, player->rmomx, player->rmomy) - player->drawangle);
+ factor = 4;
+ }
+ else if (player->pflags & PF_SLIDING)
{
#if 0 // fun hydrocity style horizontal spin
if (player->mo->eflags & MFE_TOUCHWATER || player->powers[pw_flashing] > (flashingtics/4)*3)
{
diff = (player->mo->angle - player->drawangle);
- factor = 4;
+ factor = 16;
}
else
{
@@ -11306,7 +11598,7 @@ void P_PlayerThink(player_t *player)
}
#else
diff = (player->mo->angle - player->drawangle);
- factor = 4;
+ factor = 16;
#endif
}
else if (player->pflags & PF_STARTDASH)
@@ -11326,14 +11618,30 @@ void P_PlayerThink(player_t *player)
diff = (player->mo->angle - player->drawangle);
factor = 8;
}
+ }
- if (diff)
+ if (diff)
+ {
+ if (diff > ANGLE_180)
+ diff = InvAngle(InvAngle(diff)/factor);
+ else
+ diff /= factor;
+ player->drawangle += diff;
+ }
+
+ // reset from waiting to standing when turning on the spot
+ if (player->panim == PA_IDLE)
+ {
+ diff = player->drawangle - oldang;
+ if (diff > ANGLE_180)
+ diff = InvAngle(diff);
+ if (diff > ANG10/2)
{
- if (diff > ANGLE_180)
- diff = InvAngle(InvAngle(diff)/factor);
- else
- diff /= factor;
- player->drawangle += diff;
+ statenum_t stat = player->mo->state-states;
+ if (stat == S_PLAY_WAIT)
+ P_SetPlayerMobjState(player->mo, S_PLAY_STND);
+ else if (stat == S_PLAY_STND && player->mo->tics != -1)
+ player->mo->tics++;
}
}
@@ -11341,7 +11649,9 @@ void P_PlayerThink(player_t *player)
{
boolean currentlyonground = P_IsObjectOnGround(player->mo);
- if (!player->powers[pw_carry] && !player->powers[pw_nocontrol]
+ if (player->powers[pw_noautobrake])
+ ;
+ else if (!player->powers[pw_carry] && !player->powers[pw_nocontrol]
&& ((player->pflags & (PF_AUTOBRAKE|PF_APPLYAUTOBRAKE|PF_STASIS)) == (PF_AUTOBRAKE|PF_APPLYAUTOBRAKE))
&& !(cmd->forwardmove || cmd->sidemove)
&& (player->rmomx || player->rmomy)
@@ -11383,9 +11693,6 @@ void P_PlayerThink(player_t *player)
}
}
- if (player->powers[pw_pushing])
- player->powers[pw_pushing]--;
-
player->mo->movefactor = FRACUNIT; // We're not going to do any more with this, so let's change it back for the next frame.
// Unset statis flags after moving.
@@ -11465,6 +11772,17 @@ void P_PlayerThink(player_t *player)
if (player->powers[pw_tailsfly] && player->powers[pw_tailsfly] < UINT16_MAX && player->charability != CA_SWIM) // tails fly counter
player->powers[pw_tailsfly]--;
+ if (player->powers[pw_pushing] && player->powers[pw_pushing] < UINT16_MAX)
+ player->powers[pw_pushing]--;
+
+ if (player->powers[pw_justsprung] & ((1<<15)-1) && player->powers[pw_justsprung] < UINT16_MAX)
+ player->powers[pw_justsprung]--;
+ else
+ player->powers[pw_justsprung] = 0;
+
+ if (player->powers[pw_noautobrake] && player->powers[pw_noautobrake] < UINT16_MAX)
+ player->powers[pw_noautobrake]--;
+
if (player->powers[pw_underwater] && (player->pflags & PF_GODMODE || (player->powers[pw_shield] & SH_PROTECTWATER)))
{
if (player->powers[pw_underwater] <= 12*TICRATE+1)
@@ -11565,28 +11883,32 @@ void P_PlayerThink(player_t *player)
player->pflags &= ~PF_SLIDING;
#define dashmode player->dashmode
- // Dash mode - thanks be to Iceman404
- if ((player->charflags & SF_DASHMODE) && !(player->gotflag) && !(maptol & TOL_NIGHTS)) // woo, dashmode! no nights tho.
+ // Dash mode - thanks be to VelocitOni
+ if ((player->charflags & SF_DASHMODE) && !player->gotflag && !player->powers[pw_carry] && !player->exiting && !(maptol & TOL_NIGHTS) && !metalrecording) // woo, dashmode! no nights tho.
{
boolean totallyradical = player->speed >= FixedMul(player->runspeed, player->mo->scale);
boolean floating = (player->secondjump == 1);
if ((totallyradical && !floating) || (player->pflags & PF_STARTDASH))
{
- if (dashmode < 3*TICRATE + 3)
+ if (dashmode < DASHMODE_MAX)
dashmode++; // Counter. Adds 1 to dash mode per tic in top speed.
- if (dashmode == 3*TICRATE) // This isn't in the ">=" equation because it'd cause the sound to play infinitely.
- S_StartSound(player->mo, sfx_s3ka2); // If the player enters dashmode, play this sound on the the tic it starts.
+ if (dashmode == DASHMODE_THRESHOLD) // This isn't in the ">=" equation because it'd cause the sound to play infinitely.
+ S_StartSound(player->mo, (player->charflags & SF_MACHINE) ? sfx_kc4d : sfx_cdfm40); // If the player enters dashmode, play this sound on the the tic it starts.
}
else if ((!totallyradical || !floating) && !(player->pflags & PF_SPINNING))
{
if (dashmode > 3)
+ {
dashmode -= 3; // Rather than lose it all, it gently counts back down!
+ if ((dashmode+3) >= DASHMODE_THRESHOLD && dashmode < DASHMODE_THRESHOLD)
+ S_StartSound(player->mo, sfx_kc65);
+ }
else
dashmode = 0;
}
- if (dashmode < 3*TICRATE) // Exits Dash Mode if you drop below speed/dash counter tics. Not in the above block so it doesn't keep disabling in midair.
+ if (dashmode < DASHMODE_THRESHOLD) // Exits Dash Mode if you drop below speed/dash counter tics. Not in the above block so it doesn't keep disabling in midair.
{
player->normalspeed = skins[player->skin].normalspeed; // Reset to default if not capable of entering dash mode.
player->jumpfactor = skins[player->skin].jumpfactor;
@@ -11608,10 +11930,11 @@ void P_PlayerThink(player_t *player)
}
else if (dashmode)
{
- if (dashmode >= 3*TICRATE) // catch getting the flag!
+ if (dashmode >= DASHMODE_THRESHOLD) // catch getting the flag!
{
player->normalspeed = skins[player->skin].normalspeed;
player->jumpfactor = skins[player->skin].jumpfactor;
+ S_StartSound(player->mo, sfx_kc65);
}
dashmode = 0;
}
@@ -11653,6 +11976,36 @@ void P_PlayerThink(player_t *player)
}*/
}
+// Checks if the mobj is above lava. Used by Pterabyte.
+static boolean P_MobjAboveLava(mobj_t *mobj)
+{
+ sector_t *sector = mobj->subsector->sector;
+
+ if (sector->ffloors)
+ {
+ ffloor_t *rover;
+
+ for (rover = sector->ffloors; rover; rover = rover->next)
+ {
+ if (!(rover->flags & FF_EXISTS) || !(rover->flags & FF_SWIMMABLE) || GETSECSPECIAL(rover->master->frontsector->special, 1) != 3)
+ continue;
+
+ if (mobj->eflags & MFE_VERTICALFLIP)
+ {
+ if (*rover->bottomheight <= mobj->ceilingz && *rover->bottomheight >= mobj->z)
+ return true;
+ }
+ else
+ {
+ if (*rover->topheight >= mobj->floorz && *rover->topheight <= mobj->z)
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
//
// P_PlayerAfterThink
//
@@ -11968,6 +12321,114 @@ void P_PlayerAfterThink(player_t *player)
}
break;
}
+ case CR_ROLLOUT:
+ {
+ mobj_t *mo = player->mo, *rock = player->mo->tracer;
+ UINT8 walktics = mo->state->tics - P_GetPlayerControlDirection(player);
+
+ if (!rock || P_MobjWasRemoved(rock))
+ {
+ P_SetTarget(&player->mo->tracer, NULL);
+ player->powers[pw_carry] = CR_NONE;
+ break;
+ }
+
+ if (player->cmd.forwardmove || player->cmd.sidemove)
+ {
+ rock->movedir = (player->cmd.angleturn << FRACBITS) + R_PointToAngle2(0, 0, player->cmd.forwardmove << FRACBITS, -player->cmd.sidemove << FRACBITS);
+ P_Thrust(rock, rock->movedir, rock->scale >> 1);
+ }
+
+ mo->momx = rock->momx;
+ mo->momy = rock->momy;
+ mo->momz = 0;
+
+ if (player->panim == PA_IDLE && (mo->momx || mo->momy))
+ {
+ P_SetPlayerMobjState(player->mo, S_PLAY_WALK);
+ }
+
+ if (player->panim == PA_WALK && mo->tics > walktics)
+ {
+ mo->tics = walktics;
+ }
+
+ P_TeleportMove(player->mo, rock->x, rock->y, rock->z + rock->height);
+ break;
+ }
+ case CR_PTERABYTE: // being carried by a Pterabyte
+ {
+ mobj_t *ptera = player->mo->tracer;
+ mobj_t *spawnpoint = ptera->tracer->tracer;
+ player->mo->height = FixedDiv(P_GetPlayerHeight(player), FixedDiv(14 * FRACUNIT, 10 * FRACUNIT));
+
+ if (ptera->health <= 0)
+ goto dropoff;
+
+ if (P_MobjAboveLava(ptera) && ptera->movefactor <= 3*TICRATE - 10)
+ goto dropoff;
+
+ if (player->mo->eflags & MFE_VERTICALFLIP)
+ {
+ if ((ptera->z + ptera->height + player->mo->height + FixedMul(FRACUNIT, player->mo->scale)) <= ptera->ceilingz
+ && (ptera->eflags & MFE_VERTICALFLIP)) // Reverse gravity check for the carrier - Flame
+ player->mo->z = ptera->z + ptera->height + FixedMul(FRACUNIT, player->mo->scale);
+
+ if (ptera->ceilingz - ptera->z > spawnpoint->ceilingz - spawnpoint->z + 512*FRACUNIT && ptera->movefactor <= 3 * TICRATE - 10)
+ goto dropoff;
+ }
+ else
+ {
+ if ((ptera->z - player->mo->height - FixedMul(FRACUNIT, player->mo->scale)) >= ptera->floorz
+ && !(ptera->eflags & MFE_VERTICALFLIP)) // Correct gravity check for the carrier - Flame
+ player->mo->z = ptera->z - player->mo->height - FixedMul(FRACUNIT, player->mo->scale);
+
+ if (ptera->z - ptera->floorz > spawnpoint->z - spawnpoint->floorz + 512 * FRACUNIT && ptera->movefactor <= 3 * TICRATE - 10)
+ goto dropoff;
+ }
+
+ ptera->movefactor--;
+ if (!ptera->movefactor)
+ goto dropoff;
+
+ if (ptera->cusval >= 50)
+ {
+ player->powers[pw_carry] = CR_NONE;
+ P_SetTarget(&player->mo->tracer, NULL);
+ P_KillMobj(ptera, player->mo, player->mo, 0);
+ player->mo->momz = 9*FRACUNIT;
+ player->pflags |= PF_APPLYAUTOBRAKE|PF_JUMPED|PF_THOKKED;
+ P_SetMobjState(player->mo, S_PLAY_ROLL);
+ break;
+ }
+
+ if (ptera->cusval)
+ ptera->cusval--;
+
+ P_TryMove(player->mo, ptera->x + ptera->watertop, ptera->y + ptera->waterbottom, true);
+ player->mo->z += ptera->cvmem;
+ player->mo->momx = ptera->momx;
+ player->mo->momy = ptera->momy;
+ player->mo->momz = ptera->momz;
+
+ if (P_AproxDistance(player->mo->x - ptera->x - ptera->watertop, player->mo->y - ptera->y - ptera->waterbottom) > player->mo->radius)
+ goto dropoff;
+
+ ptera->watertop >>= 1;
+ ptera->waterbottom >>= 1;
+ ptera->cvmem >>= 1;
+
+ if (player->mo->state-states != S_PLAY_FALL)
+ P_SetPlayerMobjState(player->mo, S_PLAY_FALL);
+ break;
+
+ dropoff:
+ player->powers[pw_carry] = CR_NONE;
+ P_SetTarget(&player->mo->tracer, NULL);
+ ptera->movefactor = TICRATE;
+ ptera->extravalue1 |= 4;
+ break;
+ }
default:
break;
}
@@ -12001,9 +12462,6 @@ void P_PlayerAfterThink(player_t *player)
player->mo->flags |= MF_NOGRAVITY;
}
- if (P_IsObjectOnGround(player->mo))
- player->mo->pmomz = 0;
-
if (player->followmobj && (player->spectator || player->mo->health <= 0 || player->followmobj->type != player->followitem))
{
P_RemoveMobj(player->followmobj);
@@ -12016,7 +12474,15 @@ void P_PlayerAfterThink(player_t *player)
{
P_SetTarget(&player->followmobj, P_SpawnMobjFromMobj(player->mo, 0, 0, 0, player->followitem));
P_SetTarget(&player->followmobj->tracer, player->mo);
- player->followmobj->flags2 |= MF2_LINKDRAW;
+ switch (player->followmobj->type)
+ {
+ case MT_METALJETFUME:
+ player->followmobj->colorized = true;
+ break;
+ default:
+ player->followmobj->flags2 |= MF2_LINKDRAW;
+ break;
+ }
}
if (player->followmobj)
@@ -12032,6 +12498,9 @@ void P_PlayerAfterThink(player_t *player)
case MT_TAILSOVERLAY: // c:
P_DoTailsOverlay(player, player->followmobj);
break;
+ case MT_METALJETFUME:
+ P_DoMetalJetFume(player, player->followmobj);
+ break;
default:
var1 = 1;
var2 = 0;
diff --git a/src/r_data.c b/src/r_data.c
index 511149630886eaa9a9d36292ee3b561d7cd8d1f3..5d4072b2ccfafeb343a10488770aa6ced7539e9b 100644
--- a/src/r_data.c
+++ b/src/r_data.c
@@ -35,7 +35,7 @@
#endif
// Not sure if this is necessary, but it was in w_wad.c, so I'm putting it here too -Shadow Hog
-#ifdef _WIN32_WCE
+#if 0
#define AVOID_ERRNO
#else
#include <errno.h>
@@ -456,10 +456,11 @@ static UINT8 *R_GenerateTexture(size_t texnum)
texture_t *texture;
texpatch_t *patch;
patch_t *realpatch;
+ boolean dealloc = false;
int x, x1, x2, i, width, height;
size_t blocksize;
column_t *patchcol;
- UINT32 *colofs;
+ UINT8 *colofs;
UINT16 wadnum;
lumpnum_t lumpnum;
@@ -483,23 +484,20 @@ static UINT8 *R_GenerateTexture(size_t texnum)
wadnum = patch->wad;
lumpnum = patch->lump;
lumplength = W_LumpLengthPwad(wadnum, lumpnum);
- realpatch = W_CacheLumpNumPwad(wadnum, lumpnum, PU_CACHE);
+ realpatch = W_CacheLumpNumPwad(wadnum, lumpnum, PU_CACHE); // can't use W_CachePatchNumPwad because OpenGL
#ifndef NO_PNG_LUMPS
if (R_IsLumpPNG((UINT8 *)realpatch, lumplength))
- {
- realpatch = R_PNGToPatch((UINT8 *)realpatch, lumplength, NULL, false);
goto multipatch;
- }
#endif
// Check the patch for holes.
if (texture->width > SHORT(realpatch->width) || texture->height > SHORT(realpatch->height))
holey = true;
- colofs = (UINT32 *)realpatch->columnofs;
+ colofs = (UINT8 *)realpatch->columnofs;
for (x = 0; x < texture->width && !holey; x++)
{
- column_t *col = (column_t *)((UINT8 *)realpatch + LONG(colofs[x]));
+ column_t *col = (column_t *)((UINT8 *)realpatch + LONG(*(UINT32 *)&colofs[x<<2]));
INT32 topdelta, prevdelta = -1, y = 0;
while (col->topdelta != 0xff)
{
@@ -528,19 +526,19 @@ static UINT8 *R_GenerateTexture(size_t texnum)
texturememory += blocksize;
// use the patch's column lookup
- colofs = (UINT32 *)(void *)(block + 8);
- texturecolumnofs[texnum] = colofs;
+ colofs = (block + 8);
+ texturecolumnofs[texnum] = (UINT32 *)colofs;
blocktex = block;
if (patch->flip & 1) // flip the patch horizontally
{
- UINT32 *realcolofs = (UINT32 *)realpatch->columnofs;
+ UINT8 *realcolofs = (UINT8 *)realpatch->columnofs;
for (x = 0; x < texture->width; x++)
- colofs[x] = realcolofs[texture->width-1-x]; // swap with the offset of the other side of the texture
+ *(UINT32 *)&colofs[x<<2] = realcolofs[( texture->width-1-x )<<2]; // swap with the offset of the other side of the texture
}
// we can't as easily flip the patch vertically sadly though,
// we have wait until the texture itself is drawn to do that
for (x = 0; x < texture->width; x++)
- colofs[x] = LONG(LONG(colofs[x]) + 3);
+ *(UINT32 *)&colofs[x<<2] = LONG(LONG(*(UINT32 *)&colofs[x<<2]) + 3);
goto done;
}
@@ -557,11 +555,11 @@ static UINT8 *R_GenerateTexture(size_t texnum)
texturememory += blocksize;
block = Z_Malloc(blocksize+1, PU_STATIC, &texturecache[texnum]);
- memset(block, 0xFF, blocksize+1); // Transparency hack
+ memset(block, TRANSPARENTPIXEL, blocksize+1); // Transparency hack
// columns lookup table
- colofs = (UINT32 *)(void *)block;
- texturecolumnofs[texnum] = colofs;
+ colofs = block;
+ texturecolumnofs[texnum] = (UINT32 *)colofs;
// texture data after the lookup table
blocktex = block + (texture->width*4);
@@ -579,9 +577,14 @@ static UINT8 *R_GenerateTexture(size_t texnum)
lumpnum = patch->lump;
lumplength = W_LumpLengthPwad(wadnum, lumpnum);
realpatch = W_CacheLumpNumPwad(wadnum, lumpnum, PU_CACHE);
+ dealloc = false;
+
#ifndef NO_PNG_LUMPS
if (R_IsLumpPNG((UINT8 *)realpatch, lumplength))
+ {
realpatch = R_PNGToPatch((UINT8 *)realpatch, lumplength, NULL, false);
+ dealloc = true;
+ }
#endif
x1 = patch->originx;
@@ -616,9 +619,12 @@ static UINT8 *R_GenerateTexture(size_t texnum)
patchcol = (column_t *)((UINT8 *)realpatch + LONG(realpatch->columnofs[x-x1]));
// generate column ofset lookup
- colofs[x] = LONG((x * texture->height) + (texture->width*4));
- ColumnDrawerPointer(patchcol, block + LONG(colofs[x]), patch, texture->height, height);
+ *(UINT32 *)&colofs[x<<2] = LONG((x * texture->height) + (texture->width*4));
+ ColumnDrawerPointer(patchcol, block + LONG(*(UINT32 *)&colofs[x<<2]), patch, texture->height, height);
}
+
+ if (dealloc)
+ Z_Free(realpatch);
}
done:
@@ -831,7 +837,9 @@ void R_LoadTextures(void)
{
UINT16 wadnum = (UINT16)w;
lumpnum_t lumpnum = texstart + j;
+#ifndef NO_PNG_LUMPS
size_t lumplength;
+#endif
if (wadfiles[w]->type == RET_PK3)
{
@@ -839,8 +847,10 @@ void R_LoadTextures(void)
continue; // If it is then SKIP IT
}
- lumplength = W_LumpLengthPwad(wadnum, lumpnum);
patchlump = W_CacheLumpNumPwad(wadnum, lumpnum, PU_CACHE);
+#ifndef NO_PNG_LUMPS
+ lumplength = W_LumpLengthPwad(wadnum, lumpnum);
+#endif
//CONS_Printf("\n\"%s\" is a single patch, dimensions %d x %d",W_CheckNameForNumPwad((UINT16)w,texstart+j),patchlump->width, patchlump->height);
texture = textures[i] = Z_Calloc(sizeof(texture_t) + sizeof(texpatch_t), PU_STATIC, NULL);
@@ -1446,48 +1456,6 @@ lumpnum_t R_GetFlatNumForName(const char *name)
lump = LUMPERROR;
}
- // Detect textures
- if (lump == LUMPERROR)
- {
- // Scan wad files backwards so patched textures take preference.
- for (i = numwadfiles - 1; i >= 0; i--)
- {
- switch (wadfiles[i]->type)
- {
- case RET_WAD:
- if ((start = W_CheckNumForNamePwad("TX_START", (UINT16)i, 0)) == INT16_MAX)
- continue;
- if ((end = W_CheckNumForNamePwad("TX_END", (UINT16)i, start)) == INT16_MAX)
- continue;
- break;
- case RET_PK3:
- if ((start = W_CheckNumForFolderStartPK3("Textures/", i, 0)) == INT16_MAX)
- continue;
- if ((end = W_CheckNumForFolderEndPK3("Textures/", i, start)) == INT16_MAX)
- continue;
- break;
- default:
- continue;
- }
-
- // Now find lump with specified name in that range.
- lump = W_CheckNumForNamePwad(name, (UINT16)i, start);
- if (lump < end)
- {
- lump += (i<<16); // found it, in our constraints
- break;
- }
- lump = LUMPERROR;
- }
- }
-
- if (lump == LUMPERROR)
- {
- if (strcmp(name, SKYFLATNAME))
- CONS_Debug(DBG_SETUP, "R_GetFlatNumForName: Could not find flat %.8s\n", name);
- lump = W_CheckNumForName("REDFLR");
- }
-
return lump;
}
@@ -2519,7 +2487,11 @@ void R_PrecacheLevel(void)
"spritememory: %s k\n", sizeu1(flatmemory>>10), sizeu2(texturememory>>10), sizeu3(spritememory>>10));
}
-// https://github.com/coelckers/prboom-plus/blob/master/prboom2/src/r_patch.c#L350
+//
+// R_CheckIfPatch
+//
+// Returns true if the lump is a valid patch.
+//
boolean R_CheckIfPatch(lumpnum_t lump)
{
size_t size;
@@ -2564,6 +2536,71 @@ boolean R_CheckIfPatch(lumpnum_t lump)
return result;
}
+//
+// R_TextureToFlat
+//
+// Convert a texture to a flat.
+//
+void R_TextureToFlat(size_t tex, UINT8 *flat)
+{
+ texture_t *texture = textures[tex];
+
+ fixed_t col, ofs;
+ column_t *column;
+ UINT8 *desttop, *dest, *deststop;
+ UINT8 *source;
+
+ // yea
+ R_CheckTextureCache(tex);
+
+ desttop = flat;
+ deststop = desttop + (texture->width * texture->height);
+
+ for (col = 0; col < texture->width; col++, desttop++)
+ {
+ // no post_t info
+ if (!texture->holes)
+ {
+ column = (column_t *)(R_GetColumn(tex, col));
+ source = (UINT8 *)(column);
+ dest = desttop;
+ for (ofs = 0; dest < deststop && ofs < texture->height; ofs++)
+ {
+ if (source[ofs] != TRANSPARENTPIXEL)
+ *dest = source[ofs];
+ dest += texture->width;
+ }
+ }
+ else
+ {
+ INT32 topdelta, prevdelta = -1;
+ column = (column_t *)((UINT8 *)R_GetColumn(tex, col) - 3);
+ while (column->topdelta != 0xff)
+ {
+ topdelta = column->topdelta;
+ if (topdelta <= prevdelta)
+ topdelta += prevdelta;
+ prevdelta = topdelta;
+
+ dest = desttop + (topdelta * texture->width);
+ source = (UINT8 *)column + 3;
+ for (ofs = 0; dest < deststop && ofs < column->length; ofs++)
+ {
+ if (source[ofs] != TRANSPARENTPIXEL)
+ *dest = source[ofs];
+ dest += texture->width;
+ }
+ column = (column_t *)((UINT8 *)column + column->length + 4);
+ }
+ }
+ }
+}
+
+//
+// R_PatchToFlat
+//
+// Convert a patch to a flat.
+//
void R_PatchToFlat(patch_t *patch, UINT8 *flat)
{
fixed_t col, ofs;
@@ -2598,7 +2635,124 @@ void R_PatchToFlat(patch_t *patch, UINT8 *flat)
}
}
+//
+// R_FlatToPatch
+//
+// Convert a flat to a patch.
+//
+static unsigned char imgbuf[1<<26];
+patch_t *R_FlatToPatch(UINT8 *raw, UINT16 width, UINT16 height, UINT16 leftoffset, UINT16 topoffset, size_t *destsize, boolean transparency)
+{
+ UINT32 x, y;
+ UINT8 *img;
+ UINT8 *imgptr = imgbuf;
+ UINT8 *colpointers, *startofspan;
+ size_t size = 0;
+
+ // Write image size and offset
+ WRITEINT16(imgptr, width);
+ WRITEINT16(imgptr, height);
+ WRITEINT16(imgptr, leftoffset);
+ WRITEINT16(imgptr, topoffset);
+
+ // Leave placeholder to column pointers
+ colpointers = imgptr;
+ imgptr += width*4;
+
+ // Write columns
+ for (x = 0; x < width; x++)
+ {
+ int lastStartY = 0;
+ int spanSize = 0;
+ startofspan = NULL;
+
+ // Write column pointer
+ WRITEINT32(colpointers, imgptr - imgbuf);
+
+ // Write pixels
+ for (y = 0; y < height; y++)
+ {
+ UINT8 paletteIndex = raw[((y * width) + x)];
+ boolean opaque = transparency ? (paletteIndex != TRANSPARENTPIXEL) : true;
+
+ // End span if we have a transparent pixel
+ if (!opaque)
+ {
+ if (startofspan)
+ WRITEUINT8(imgptr, 0);
+ startofspan = NULL;
+ continue;
+ }
+
+ // Start new column if we need to
+ if (!startofspan || spanSize == 255)
+ {
+ int writeY = y;
+
+ // If we reached the span size limit, finish the previous span
+ if (startofspan)
+ WRITEUINT8(imgptr, 0);
+
+ if (y > 254)
+ {
+ // Make sure we're aligned to 254
+ if (lastStartY < 254)
+ {
+ WRITEUINT8(imgptr, 254);
+ WRITEUINT8(imgptr, 0);
+ imgptr += 2;
+ lastStartY = 254;
+ }
+
+ // Write stopgap empty spans if needed
+ writeY = y - lastStartY;
+
+ while (writeY > 254)
+ {
+ WRITEUINT8(imgptr, 254);
+ WRITEUINT8(imgptr, 0);
+ imgptr += 2;
+ writeY -= 254;
+ }
+ }
+
+ startofspan = imgptr;
+ WRITEUINT8(imgptr, writeY);
+ imgptr += 2;
+ spanSize = 0;
+
+ lastStartY = y;
+ }
+
+ // Write the pixel
+ WRITEUINT8(imgptr, paletteIndex);
+ spanSize++;
+ startofspan[1] = spanSize;
+ }
+
+ if (startofspan)
+ WRITEUINT8(imgptr, 0);
+
+ WRITEUINT8(imgptr, 0xFF);
+ }
+
+ size = imgptr-imgbuf;
+ img = Z_Malloc(size, PU_STATIC, NULL);
+ memcpy(img, imgbuf, size);
+
+ Z_Free(raw);
+
+ if (destsize != NULL)
+ *destsize = size;
+ return (patch_t *)img;
+}
+
#ifndef NO_PNG_LUMPS
+//
+// R_IsLumpPNG
+//
+// Returns true if the lump is a valid PNG.
+//
boolean R_IsLumpPNG(const UINT8 *d, size_t s)
{
if (s < 67) // http://garethrees.org/2007/11/14/pngcrush/
@@ -2611,22 +2765,23 @@ boolean R_IsLumpPNG(const UINT8 *d, size_t s)
#ifdef HAVE_PNG
-#if PNG_LIBPNG_VER_DLLNUM < 14
+/*#if PNG_LIBPNG_VER_DLLNUM < 14
typedef PNG_CONST png_byte *png_const_bytep;
-#endif
-typedef struct {
- png_const_bytep buffer;
- png_uint_32 bufsize;
- png_uint_32 current_pos;
+#endif*/
+typedef struct
+{
+ const UINT8 *buffer;
+ UINT32 size;
+ UINT32 position;
} png_io_t;
static void PNG_IOReader(png_structp png_ptr, png_bytep data, png_size_t length)
{
png_io_t *f = png_get_io_ptr(png_ptr);
- if (length > (f->bufsize - f->current_pos))
+ if (length > (f->size - f->position))
png_error(png_ptr, "PNG_IOReader: buffer overrun");
- memcpy(data, f->buffer + f->current_pos, length);
- f->current_pos += length;
+ memcpy(data, f->buffer + f->position, length);
+ f->position += length;
}
typedef struct
@@ -2712,10 +2867,10 @@ static png_bytep *PNG_Read(const UINT8 *png, UINT16 *w, UINT16 *h, INT16 *topoff
png_memcpy(png_jmpbuf(png_ptr), jmpbuf, sizeof jmp_buf);
#endif
- // set our own read_function
- png_io.buffer = (png_const_bytep)png;
- png_io.bufsize = size;
- png_io.current_pos = 0;
+ // set our own read function
+ png_io.buffer = png;
+ png_io.size = size;
+ png_io.position = 0;
png_set_read_fn(png_ptr, &png_io, PNG_IOReader);
memset(&chunk, 0x00, sizeof(png_chunk_t));
@@ -2811,125 +2966,31 @@ static UINT8 *PNG_RawConvert(const UINT8 *png, UINT16 *w, UINT16 *h, INT16 *topo
return flat;
}
+//
+// R_PNGToFlat
+//
// Convert a PNG to a flat.
-UINT8 *R_PNGToFlat(levelflat_t *levelflat, UINT8 *png, size_t size)
+//
+UINT8 *R_PNGToFlat(UINT16 *width, UINT16 *height, UINT8 *png, size_t size)
{
- return PNG_RawConvert(png, &levelflat->width, &levelflat->height, NULL, NULL, size);
+ return PNG_RawConvert(png, width, height, NULL, NULL, size);
}
+//
+// R_PNGToPatch
+//
// Convert a PNG to a patch.
-static unsigned char imgbuf[1<<26];
+//
patch_t *R_PNGToPatch(const UINT8 *png, size_t size, size_t *destsize, boolean transparency)
{
UINT16 width, height;
INT16 topoffset = 0, leftoffset = 0;
UINT8 *raw = PNG_RawConvert(png, &width, &height, &topoffset, &leftoffset, size);
- UINT32 x, y;
- UINT8 *img;
- UINT8 *imgptr = imgbuf;
- UINT8 *colpointers, *startofspan;
-
if (!raw)
I_Error("R_PNGToPatch: conversion failed");
- // Write image size and offset
- WRITEINT16(imgptr, width);
- WRITEINT16(imgptr, height);
- WRITEINT16(imgptr, leftoffset);
- WRITEINT16(imgptr, topoffset);
-
- // Leave placeholder to column pointers
- colpointers = imgptr;
- imgptr += width*4;
-
- // Write columns
- for (x = 0; x < width; x++)
- {
- int lastStartY = 0;
- int spanSize = 0;
- startofspan = NULL;
-
- //printf("%d ", x);
- // Write column pointer (@TODO may be wrong)
- WRITEINT32(colpointers, imgptr - imgbuf);
-
- // Write pixels
- for (y = 0; y < height; y++)
- {
- UINT8 paletteIndex = raw[((y * width) + x)];
- boolean opaque = transparency ? (paletteIndex != TRANSPARENTPIXEL) : true;
-
- // End span if we have a transparent pixel
- if (!opaque)
- {
- if (startofspan)
- WRITEUINT8(imgptr, 0);
- startofspan = NULL;
- continue;
- }
-
- // Start new column if we need to
- if (!startofspan || spanSize == 255)
- {
- int writeY = y;
-
- // If we reached the span size limit, finish the previous span
- if (startofspan)
- WRITEUINT8(imgptr, 0);
-
- if (y > 254)
- {
- // Make sure we're aligned to 254
- if (lastStartY < 254)
- {
- WRITEUINT8(imgptr, 254);
- WRITEUINT8(imgptr, 0);
- imgptr += 2;
- lastStartY = 254;
- }
-
- // Write stopgap empty spans if needed
- writeY = y - lastStartY;
-
- while (writeY > 254)
- {
- WRITEUINT8(imgptr, 254);
- WRITEUINT8(imgptr, 0);
- imgptr += 2;
- writeY -= 254;
- }
- }
-
- startofspan = imgptr;
- WRITEUINT8(imgptr, writeY);///@TODO calculate starting y pos
- imgptr += 2;
- spanSize = 0;
-
- lastStartY = y;
- }
-
- // Write the pixel
- WRITEUINT8(imgptr, paletteIndex);
- spanSize++;
- startofspan[1] = spanSize;
- }
-
- if (startofspan)
- WRITEUINT8(imgptr, 0);
-
- WRITEUINT8(imgptr, 0xFF);
- }
-
- size = imgptr-imgbuf;
- img = Z_Malloc(size, PU_STATIC, NULL);
- memcpy(img, imgbuf, size);
-
- Z_Free(raw);
-
- if (destsize != NULL)
- *destsize = size;
- return (patch_t *)img;
+ return R_FlatToPatch(raw, width, height, leftoffset, topoffset, destsize, transparency);
}
boolean R_PNGDimensions(UINT8 *png, INT16 *width, INT16 *height, size_t size)
@@ -2976,10 +3037,10 @@ boolean R_PNGDimensions(UINT8 *png, INT16 *width, INT16 *height, size_t size)
png_memcpy(png_jmpbuf(png_ptr), jmpbuf, sizeof jmp_buf);
#endif
- // set our own read_function
- png_io.buffer = (png_bytep)png;
- png_io.bufsize = size;
- png_io.current_pos = 0;
+ // set our own read function
+ png_io.buffer = png;
+ png_io.size = size;
+ png_io.position = 0;
png_set_read_fn(png_ptr, &png_io, PNG_IOReader);
#ifdef PNG_SET_USER_LIMITS_SUPPORTED
@@ -3000,53 +3061,3 @@ boolean R_PNGDimensions(UINT8 *png, INT16 *width, INT16 *height, size_t size)
}
#endif
#endif
-
-void R_TextureToFlat(size_t tex, UINT8 *flat)
-{
- texture_t *texture = textures[tex];
-
- fixed_t col, ofs;
- column_t *column;
- UINT8 *desttop, *dest, *deststop;
- UINT8 *source;
-
- desttop = flat;
- deststop = desttop + (texture->width * texture->height);
-
- for (col = 0; col < texture->width; col++, desttop++)
- {
- column = (column_t *)R_GetColumn(tex, col);
- if (!texture->holes)
- {
- dest = desttop;
- source = (UINT8 *)(column);
- for (ofs = 0; dest < deststop && ofs < texture->height; ofs++)
- {
- if (source[ofs] != TRANSPARENTPIXEL)
- *dest = source[ofs];
- dest += texture->width;
- }
- }
- else
- {
- INT32 topdelta, prevdelta = -1;
- while (column->topdelta != 0xff)
- {
- topdelta = column->topdelta;
- if (topdelta <= prevdelta)
- topdelta += prevdelta;
- prevdelta = topdelta;
-
- dest = desttop + (topdelta * texture->width);
- source = (UINT8 *)(column) + 3;
- for (ofs = 0; dest < deststop && ofs < column->length; ofs++)
- {
- if (source[ofs] != TRANSPARENTPIXEL)
- *dest = source[ofs];
- dest += texture->width;
- }
- column = (column_t *)((UINT8 *)column + column->length + 4);
- }
- }
- }
-}
diff --git a/src/r_data.h b/src/r_data.h
index c2fd284ff016810d5062ebe6523f5eedcb9df025..e71d457663e1eabe06a10cb7c4c7911379c87b0c 100644
--- a/src/r_data.h
+++ b/src/r_data.h
@@ -159,15 +159,14 @@ const char *R_NameForColormap(extracolormap_t *extra_colormap);
#define R_PutRgbaRGBA(r, g, b, a) (R_PutRgbaRGB(r, g, b) + R_PutRgbaA(a))
boolean R_CheckIfPatch(lumpnum_t lump);
-UINT8 NearestColor(UINT8 r, UINT8 g, UINT8 b);
-
-void R_PatchToFlat(patch_t *patch, UINT8 *flat);
void R_TextureToFlat(size_t tex, UINT8 *flat);
+void R_PatchToFlat(patch_t *patch, UINT8 *flat);
+patch_t *R_FlatToPatch(UINT8 *raw, UINT16 width, UINT16 height, UINT16 leftoffset, UINT16 topoffset, size_t *destsize, boolean transparency);
#ifndef NO_PNG_LUMPS
boolean R_IsLumpPNG(const UINT8 *d, size_t s);
-UINT8 *R_PNGToFlat(levelflat_t *levelflat, UINT8 *png, size_t size);
+UINT8 *R_PNGToFlat(UINT16 *width, UINT16 *height, UINT8 *png, size_t size);
patch_t *R_PNGToPatch(const UINT8 *png, size_t size, size_t *destsize, boolean transparency);
boolean R_PNGDimensions(UINT8 *png, INT16 *width, INT16 *height, size_t size);
#endif
diff --git a/src/r_defs.h b/src/r_defs.h
index 9a87d76dfc529163c2af6d66b145660683b32b44..c8c931df4641850788bc0576c1400404d02747a9 100644
--- a/src/r_defs.h
+++ b/src/r_defs.h
@@ -139,9 +139,9 @@ typedef enum
FF_PLATFORM = 0x2000000, ///< You can jump up through this to the top.
FF_REVERSEPLATFORM = 0x4000000, ///< A fall-through floor in normal gravity, a platform in reverse gravity.
FF_INTANGABLEFLATS = 0x6000000, ///< Both flats are intangable, but the sides are still solid.
- FF_SHATTER = 0x8000000, ///< Used with ::FF_BUSTUP. Thinks everyone's Knuckles.
- FF_SPINBUST = 0x10000000, ///< Used with ::FF_BUSTUP. Jump or fall onto it while curled in a ball.
- FF_ONLYKNUX = 0x20000000, ///< Used with ::FF_BUSTUP. Only Knuckles can break this rock.
+ FF_SHATTER = 0x8000000, ///< Used with ::FF_BUSTUP. Bustable on mere touch.
+ FF_SPINBUST = 0x10000000, ///< Used with ::FF_BUSTUP. Also bustable if you're in your spinning frames.
+ FF_STRONGBUST = 0x20000000, ///< Used with ::FF_BUSTUP. Only bustable by "strong" characters (Knuckles) and abilities (bouncing, twinspin, melee).
FF_RIPPLE = 0x40000000, ///< Ripple the flats
FF_COLORMAPONLY = 0x80000000, ///< Only copy the colormap, not the lightlevel
FF_GOOWATER = FF_SHATTERBOTTOM, ///< Used with ::FF_SWIMMABLE. Makes thick bouncey goop.
@@ -263,10 +263,15 @@ typedef struct pslope_s
typedef enum
{
- SF_FLIPSPECIAL_FLOOR = 1,
- SF_FLIPSPECIAL_CEILING = 2,
- SF_FLIPSPECIAL_BOTH = 3,
- SF_TRIGGERSPECIAL_TOUCH = 4,
+ // flipspecial - planes with effect
+ SF_FLIPSPECIAL_FLOOR = 1,
+ SF_FLIPSPECIAL_CEILING = 1<<1,
+ SF_FLIPSPECIAL_BOTH = (SF_FLIPSPECIAL_FLOOR|SF_FLIPSPECIAL_CEILING),
+ // triggerspecial - conditions under which plane touch causes effect
+ SF_TRIGGERSPECIAL_TOUCH = 1<<2,
+ SF_TRIGGERSPECIAL_HEADBUMP = 1<<3,
+ // invertprecip - inverts presence of precipitation
+ SF_INVERTPRECIP = 1<<4,
} sectorflags_t;
//
diff --git a/src/r_draw.c b/src/r_draw.c
index 1754403c44141a2ca599bddcc28d0ca6ed90ca80..6fc8d65994e311780f76d29cd923c1fead9f44da 100644
--- a/src/r_draw.c
+++ b/src/r_draw.c
@@ -130,10 +130,11 @@ UINT32 nflatxshift, nflatyshift, nflatshiftup, nflatmask;
#define ALLWHITE_TT_CACHE_INDEX (MAXSKINS + 3)
#define RAINBOW_TT_CACHE_INDEX (MAXSKINS + 4)
#define BLINK_TT_CACHE_INDEX (MAXSKINS + 5)
+#define DASHMODE_TT_CACHE_INDEX (MAXSKINS + 6)
#define DEFAULT_STARTTRANSCOLOR 96
#define NUM_PALETTE_ENTRIES 256
-static UINT8** translationtablecache[MAXSKINS + 6] = {NULL};
+static UINT8** translationtablecache[MAXSKINS + 7] = {NULL};
const UINT8 Color_Index[MAXTRANSLATIONS-1][16] = {
// {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, // SKINCOLOR_NONE
@@ -566,8 +567,46 @@ static void R_GenerateTranslationColormap(UINT8 *dest_colormap, INT32 skinnum, U
else if (skinnum == TC_METALSONIC)
{
for (i = 0; i < 6; i++)
+ {
dest_colormap[Color_Index[SKINCOLOR_BLUE-1][12-i]] = Color_Index[SKINCOLOR_BLUE-1][i];
+ }
dest_colormap[159] = dest_colormap[253] = dest_colormap[254] = 0;
+ for (i = 0; i < 16; i++)
+ dest_colormap[96+i] = dest_colormap[Color_Index[SKINCOLOR_COBALT-1][i]];
+ }
+ else if (skinnum == TC_DASHMODE) // This is a long one, because MotorRoach basically hand-picked the indices
+ {
+ // greens -> ketchups
+ dest_colormap[96] = dest_colormap[97] = 48;
+ dest_colormap[98] = 49;
+ dest_colormap[99] = 51;
+ dest_colormap[100] = 52;
+ dest_colormap[101] = dest_colormap[102] = 54;
+ dest_colormap[103] = 34;
+ dest_colormap[104] = 37;
+ dest_colormap[105] = 39;
+ dest_colormap[106] = 41;
+ for (i = 0; i < 5; i++)
+ dest_colormap[107 + i] = 43 + i;
+
+ // reds -> steel blues
+ dest_colormap[32] = 146;
+ dest_colormap[33] = 147;
+ dest_colormap[34] = dest_colormap[35] = 170;
+ dest_colormap[36] = 171;
+ dest_colormap[37] = dest_colormap[38] = 172;
+ dest_colormap[39] = dest_colormap[40] = dest_colormap[41] = 173;
+ dest_colormap[42] = dest_colormap[43] = dest_colormap[44] = 174;
+ dest_colormap[45] = dest_colormap[46] = dest_colormap[47] = 175;
+ dest_colormap[71] = 139;
+
+ // steel blues -> oranges
+ dest_colormap[170] = 52;
+ dest_colormap[171] = 54;
+ dest_colormap[172] = 56;
+ dest_colormap[173] = 42;
+ dest_colormap[174] = 45;
+ dest_colormap[175] = 47;
}
return;
}
@@ -628,6 +667,7 @@ UINT8* R_GetTranslationColormap(INT32 skinnum, skincolors_t color, UINT8 flags)
case TC_ALLWHITE: skintableindex = ALLWHITE_TT_CACHE_INDEX; break;
case TC_RAINBOW: skintableindex = RAINBOW_TT_CACHE_INDEX; break;
case TC_BLINK: skintableindex = BLINK_TT_CACHE_INDEX; break;
+ case TC_DASHMODE: skintableindex = DASHMODE_TT_CACHE_INDEX; break;
default: skintableindex = skinnum; break;
}
diff --git a/src/r_draw.h b/src/r_draw.h
index 3c142972257c446a29e32fd1c36a810e47c63bc0..a0ab748480930d6f06191b6de78adfefdb539ce5 100644
--- a/src/r_draw.h
+++ b/src/r_draw.h
@@ -109,6 +109,7 @@ extern lumpnum_t viewborderlump[8];
#define TC_ALLWHITE -4 // For Cy-Brak-demon
#define TC_RAINBOW -5 // For single colour
#define TC_BLINK -6 // For item blinking, according to kart
+#define TC_DASHMODE -7 // For Metal Sonic's dashmode
// Initialize color translation tables, for player rendering etc.
void R_InitTranslationTables(void);
diff --git a/src/r_main.c b/src/r_main.c
index 38b255089e9cb783083173761bd63879b30642c1..ef3be4b9457d95be55cb509c03ee769896186027 100644
--- a/src/r_main.c
+++ b/src/r_main.c
@@ -1231,7 +1231,6 @@ void R_RegisterEngineStuff(void)
CV_RegisterVar(&cv_grgammared);
CV_RegisterVar(&cv_grfovchange);
CV_RegisterVar(&cv_grfog);
- CV_RegisterVar(&cv_voodoocompatibility);
CV_RegisterVar(&cv_grfogcolor);
CV_RegisterVar(&cv_grsoftwarefog);
#ifdef ALAM_LIGHTING
@@ -1240,8 +1239,10 @@ void R_RegisterEngineStuff(void)
CV_RegisterVar(&cv_grcoronas);
CV_RegisterVar(&cv_grcoronasize);
#endif
- CV_RegisterVar(&cv_grmd2);
+ CV_RegisterVar(&cv_grmodelinterpolation);
+ CV_RegisterVar(&cv_grmodels);
CV_RegisterVar(&cv_grspritebillboarding);
+ CV_RegisterVar(&cv_grskydome);
#endif
#ifdef HWRENDER
diff --git a/src/r_plane.c b/src/r_plane.c
index db5fb0f249d690f70dacabaaca4e87767f7576d4..53b58c274386a242f095e777347163072af9f146 100644
--- a/src/r_plane.c
+++ b/src/r_plane.c
@@ -44,6 +44,9 @@
// Quincunx antialiasing of flats!
//#define QUINCUNX
+// good night sweet prince
+#define SHITPLANESPARENCY
+
//SoM: 3/23/2000: Use Boom visplane hashing.
visplane_t *visplanes[MAXVISPLANES];
@@ -650,6 +653,11 @@ static void R_DrawSkyPlane(visplane_t *pl)
}
}
+//
+// R_CheckPowersOfTwo
+//
+// Self-explanatory?
+//
boolean R_CheckPowersOfTwo(void)
{
boolean wpow2 = (!(ds_flatwidth & (ds_flatwidth - 1)));
@@ -667,6 +675,11 @@ boolean R_CheckPowersOfTwo(void)
return ds_powersoftwo;
}
+//
+// R_CheckFlatLength
+//
+// Determine the flat's dimensions from the lump length.
+//
void R_CheckFlatLength(size_t size)
{
switch (size)
@@ -723,12 +736,29 @@ void R_CheckFlatLength(size_t size)
}
}
-static UINT8 *R_GetPatchFlat(levelflat_t *levelflat, boolean leveltexture, boolean ispng)
+//
+// R_GenerateFlat
+//
+// Generate a flat from specified width and height.
+//
+static UINT8 *R_GenerateFlat(UINT16 width, UINT16 height)
+{
+ UINT8 *flat = Z_Malloc(width * height, PU_LEVEL, NULL);
+ memset(flat, TRANSPARENTPIXEL, width * height);
+ return flat;
+}
+
+//
+// R_GetTextureFlat
+//
+// Convert a texture or patch to a flat.
+//
+static UINT8 *R_GetTextureFlat(levelflat_t *levelflat, boolean leveltexture, boolean ispng)
{
UINT8 *flat;
- textureflat_t *texflat = &texflats[levelflat->texturenum];
+ textureflat_t *texflat = &texflats[levelflat->u.texture.num];
patch_t *patch = NULL;
- boolean texturechanged = (leveltexture ? (levelflat->texturenum != levelflat->lasttexturenum) : false);
+ boolean texturechanged = (leveltexture ? (levelflat->u.texture.num != levelflat->u.texture.lastnum) : false);
// Check if the texture changed.
if (leveltexture && (!texturechanged))
@@ -747,28 +777,29 @@ static UINT8 *R_GetPatchFlat(levelflat_t *levelflat, boolean leveltexture, boole
// If the texture changed, or the patch doesn't exist, convert either of them to a flat.
if (levelflat->flatpatch == NULL || texturechanged)
{
+ // Level texture
if (leveltexture)
{
- texture_t *texture = textures[levelflat->texturenum];
+ texture_t *texture = textures[levelflat->u.texture.num];
texflat->width = ds_flatwidth = texture->width;
texflat->height = ds_flatheight = texture->height;
- texflat->flat = Z_Malloc(ds_flatwidth * ds_flatheight, PU_LEVEL, NULL);
- memset(texflat->flat, TRANSPARENTPIXEL, ds_flatwidth * ds_flatheight);
- R_TextureToFlat(levelflat->texturenum, texflat->flat);
+ texflat->flat = R_GenerateFlat(ds_flatwidth, ds_flatheight);
+ R_TextureToFlat(levelflat->u.texture.num, texflat->flat);
flat = texflat->flat;
levelflat->flatpatch = flat;
levelflat->width = ds_flatwidth;
levelflat->height = ds_flatheight;
}
+ // Patch (never happens yet)
else
{
patch = (patch_t *)ds_source;
#ifndef NO_PNG_LUMPS
if (ispng)
{
- levelflat->flatpatch = R_PNGToFlat(levelflat, ds_source, W_LumpLength(levelflat->lumpnum));
+ levelflat->flatpatch = R_PNGToFlat(&levelflat->width, &levelflat->height, ds_source, W_LumpLength(levelflat->u.flat.lumpnum));
levelflat->topoffset = levelflat->leftoffset = 0;
ds_flatwidth = levelflat->width;
ds_flatheight = levelflat->height;
@@ -782,8 +813,7 @@ static UINT8 *R_GetPatchFlat(levelflat_t *levelflat, boolean leveltexture, boole
levelflat->topoffset = patch->topoffset * FRACUNIT;
levelflat->leftoffset = patch->leftoffset * FRACUNIT;
- levelflat->flatpatch = Z_Malloc(ds_flatwidth * ds_flatheight, PU_LEVEL, NULL);
- memset(levelflat->flatpatch, TRANSPARENTPIXEL, ds_flatwidth * ds_flatheight);
+ levelflat->flatpatch = R_GenerateFlat(ds_flatwidth, ds_flatheight);
R_PatchToFlat(patch, levelflat->flatpatch);
}
flat = levelflat->flatpatch;
@@ -794,12 +824,12 @@ static UINT8 *R_GetPatchFlat(levelflat_t *levelflat, boolean leveltexture, boole
flat = levelflat->flatpatch;
ds_flatwidth = levelflat->width;
ds_flatheight = levelflat->height;
-
- xoffs += levelflat->leftoffset;
- yoffs += levelflat->topoffset;
}
- levelflat->lasttexturenum = levelflat->texturenum;
+ xoffs += levelflat->leftoffset;
+ yoffs += levelflat->topoffset;
+
+ levelflat->u.texture.lastnum = levelflat->u.texture.num;
return flat;
}
@@ -809,10 +839,9 @@ void R_DrawSinglePlane(visplane_t *pl)
INT32 light = 0;
INT32 x;
INT32 stop, angle;
- size_t size;
ffloor_t *rover;
levelflat_t *levelflat;
- boolean rawflat = false;
+ int type;
if (!(pl->minx <= pl->maxx))
return;
@@ -841,7 +870,11 @@ void R_DrawSinglePlane(visplane_t *pl)
else // Opaque, but allow transparent flat pixels
spanfunc = splatfunc;
+#ifdef SHITPLANESPARENCY
+ if ((spanfunc == splatfunc) != (pl->extra_colormap && (pl->extra_colormap->fog & 4)))
+#else
if (!pl->extra_colormap || !(pl->extra_colormap->fog & 2))
+#endif
light = (pl->lightlevel >> LIGHTSEGSHIFT);
else
light = LIGHTLEVELS-1;
@@ -895,7 +928,11 @@ void R_DrawSinglePlane(visplane_t *pl)
else // Opaque, but allow transparent flat pixels
spanfunc = splatfunc;
+#ifdef SHITPLANESPARENCY
+ if ((spanfunc == splatfunc) != (pl->extra_colormap && (pl->extra_colormap->fog & 4)))
+#else
if (!pl->extra_colormap || !(pl->extra_colormap->fog & 2))
+#endif
light = (pl->lightlevel >> LIGHTSEGSHIFT);
else
light = LIGHTLEVELS-1;
@@ -958,43 +995,45 @@ void R_DrawSinglePlane(visplane_t *pl)
currentplane = pl;
levelflat = &levelflats[pl->picnum];
- size = W_LumpLength(levelflat->lumpnum);
- ds_source = (UINT8 *)W_CacheLumpNum(levelflat->lumpnum, PU_STATIC); // Stay here until Z_ChangeTag
- // Check if the flat is actually a wall texture.
- if (levelflat->texturenum != 0 && levelflat->texturenum != -1)
- flat = R_GetPatchFlat(levelflat, true, false);
+ /* :james: */
+ type = levelflat->type;
+ switch (type)
+ {
+ case LEVELFLAT_NONE:
+ return;
+ case LEVELFLAT_FLAT:
+ ds_source = W_CacheLumpNum(levelflat->u.flat.lumpnum, PU_CACHE);
+ R_CheckFlatLength(W_LumpLength(levelflat->u.flat.lumpnum));
+ // Raw flats always have dimensions that are powers-of-two numbers.
+ ds_powersoftwo = true;
+ break;
+ default:
+ switch (type)
+ {
+ case LEVELFLAT_TEXTURE:
+ /* Textures get cached differently and don't need ds_source */
+ ds_source = R_GetTextureFlat(levelflat, true, false);
+ break;
+ default:
+ ds_source = W_CacheLumpNum(levelflat->u.flat.lumpnum, PU_STATIC);
+ flat = R_GetTextureFlat(levelflat, false,
#ifndef NO_PNG_LUMPS
- // Maybe it's a PNG?!
- else if (R_IsLumpPNG(ds_source, size))
- flat = R_GetPatchFlat(levelflat, false, true);
+ ( type == LEVELFLAT_PNG )
+#else
+ false
#endif
- // Maybe it's just a patch, then?
- else if (R_CheckIfPatch(levelflat->lumpnum))
- flat = R_GetPatchFlat(levelflat, false, false);
- // It's a raw flat.
- else
- {
- rawflat = true;
- R_CheckFlatLength(size);
- flat = ds_source;
- }
-
- Z_ChangeTag(ds_source, PU_CACHE);
- ds_source = flat;
-
- if (ds_source == NULL)
- return;
-
- // Raw flats always have dimensions that are powers-of-two numbers.
- if (rawflat)
- ds_powersoftwo = true;
- // Otherwise, check if this texture or patch has such dimensions.
- else if (R_CheckPowersOfTwo())
- {
- R_CheckFlatLength(ds_flatwidth * ds_flatheight);
- if (spanfunc == basespanfunc)
- spanfunc = mmxspanfunc;
+ );
+ Z_ChangeTag(ds_source, PU_CACHE);
+ ds_source = flat;
+ }
+ // Check if this texture or patch has power-of-two dimensions.
+ if (R_CheckPowersOfTwo())
+ {
+ R_CheckFlatLength(ds_flatwidth * ds_flatheight);
+ if (spanfunc == basespanfunc)
+ spanfunc = mmxspanfunc;
+ }
}
if (light >= LIGHTLEVELS)
@@ -1075,7 +1114,7 @@ void R_DrawSinglePlane(visplane_t *pl)
temp = P_GetZAt(pl->slope, pl->viewx, pl->viewy);
zeroheight = FIXED_TO_FLOAT(temp);
-#define ANG2RAD(angle) ((float)((angle)*M_PI)/ANGLE_180)
+#define ANG2RAD(angle) ((float)((angle)*M_PIl)/ANGLE_180)
// p is the texture origin in view space
// Don't add in the offsets at this stage, because doing so can result in
diff --git a/src/r_things.c b/src/r_things.c
index 43e006a30ac6bcaaee6529cbf03690b7404da799..b2818806f2983a2cff221f61b3e9e1e95dbd1d67 100644
--- a/src/r_things.c
+++ b/src/r_things.c
@@ -400,10 +400,6 @@ void R_AddSpriteDefs(UINT16 wadnum)
start = W_CheckNumForNamePwad("S_START", wadnum, 0);
if (start == INT16_MAX)
start = W_CheckNumForNamePwad("SS_START", wadnum, 0); //deutex compatib.
- if (start == INT16_MAX)
- start = 0; //let say S_START is lump 0
- else
- start++; // just after S_START
end = W_CheckNumForNamePwad("S_END",wadnum,start);
if (end == INT16_MAX)
@@ -417,9 +413,16 @@ void R_AddSpriteDefs(UINT16 wadnum)
return;
}
- // ignore skin wads (we don't want skin sprites interfering with vanilla sprites)
- if (start == 0 && W_CheckNumForNamePwad("S_SKIN", wadnum, 0) != UINT16_MAX)
- return;
+ if (start == INT16_MAX)
+ {
+ // ignore skin wads (we don't want skin sprites interfering with vanilla sprites)
+ if (W_CheckNumForNamePwad("S_SKIN", wadnum, 0) != UINT16_MAX)
+ return;
+
+ start = 0; //let say S_START is lump 0
+ }
+ else
+ start++; // just after S_START
if (end == INT16_MAX)
{
@@ -441,7 +444,7 @@ void R_AddSpriteDefs(UINT16 wadnum)
{
#ifdef HWRENDER
if (rendermode == render_opengl)
- HWR_AddSpriteMD2(i);
+ HWR_AddSpriteModel(i);
#endif
// if a new sprite was added (not just replaced)
addsprites++;
@@ -753,6 +756,16 @@ static void R_DrawVisSprite(vissprite_t *vis)
dc_transmap = vis->transmap;
if (!(vis->cut & SC_PRECIP) && vis->mobj->colorized)
dc_translation = R_GetTranslationColormap(TC_RAINBOW, vis->mobj->color, GTC_CACHE);
+ else if (!(vis->cut & SC_PRECIP)
+ && vis->mobj->player && vis->mobj->player->dashmode >= DASHMODE_THRESHOLD
+ && (vis->mobj->player->charflags & SF_DASHMODE)
+ && ((leveltime/2) & 1))
+ {
+ if (vis->mobj->player->charflags & SF_MACHINE)
+ dc_translation = R_GetTranslationColormap(TC_DASHMODE, 0, GTC_CACHE);
+ else
+ dc_translation = R_GetTranslationColormap(TC_RAINBOW, vis->mobj->color, GTC_CACHE);
+ }
else if (!(vis->cut & SC_PRECIP) && vis->mobj->skin && vis->mobj->sprite == SPR_PLAY) // MT_GHOST LOOKS LIKE A PLAYER SO USE THE PLAYER TRANSLATION TABLES. >_>
{
size_t skinnum = (skin_t*)vis->mobj->skin-skins;
@@ -774,6 +787,16 @@ static void R_DrawVisSprite(vissprite_t *vis)
// New colormap stuff for skins Tails 06-07-2002
if (!(vis->cut & SC_PRECIP) && vis->mobj->colorized)
dc_translation = R_GetTranslationColormap(TC_RAINBOW, vis->mobj->color, GTC_CACHE);
+ else if (!(vis->cut & SC_PRECIP)
+ && vis->mobj->player && vis->mobj->player->dashmode >= DASHMODE_THRESHOLD
+ && (vis->mobj->player->charflags & SF_DASHMODE)
+ && ((leveltime/2) & 1))
+ {
+ if (vis->mobj->player->charflags & SF_MACHINE)
+ dc_translation = R_GetTranslationColormap(TC_DASHMODE, 0, GTC_CACHE);
+ else
+ dc_translation = R_GetTranslationColormap(TC_RAINBOW, vis->mobj->color, GTC_CACHE);
+ }
else if (!(vis->cut & SC_PRECIP) && vis->mobj->skin && vis->mobj->sprite == SPR_PLAY) // This thing is a player!
{
size_t skinnum = (skin_t*)vis->mobj->skin-skins;
@@ -1230,7 +1253,7 @@ static void R_ProjectSprite(mobj_t *thing)
else
range = 1;
- scalestep = (yscale2 - yscale)/range;
+ scalestep = (yscale2 - yscale)/range ?: 1;
// The following two are alternate sorting methods which might be more applicable in some circumstances. TODO - maybe enable via MF2?
// sortscale = max(yscale, yscale2);
@@ -1637,7 +1660,7 @@ void R_AddSprites(sector_t *sec, INT32 lightlevel)
mobj_t *thing;
precipmobj_t *precipthing; // Tails 08-25-2002
INT32 lightnum;
- fixed_t approx_dist, limit_dist;
+ fixed_t approx_dist, limit_dist, hoop_limit_dist;
if (rendermode != render_soft)
return;
@@ -1668,7 +1691,9 @@ void R_AddSprites(sector_t *sec, INT32 lightlevel)
// Handle all things in sector.
// If a limit exists, handle things a tiny bit different.
- if ((limit_dist = (fixed_t)((maptol & TOL_NIGHTS) ? cv_drawdist_nights.value : cv_drawdist.value) << FRACBITS))
+ limit_dist = (fixed_t)(cv_drawdist.value) << FRACBITS;
+ hoop_limit_dist = (fixed_t)(cv_drawdist_nights.value) << FRACBITS;
+ if (limit_dist || hoop_limit_dist)
{
for (thing = sec->thinglist; thing; thing = thing->snext)
{
@@ -1677,8 +1702,16 @@ void R_AddSprites(sector_t *sec, INT32 lightlevel)
approx_dist = P_AproxDistance(viewx-thing->x, viewy-thing->y);
- if (approx_dist > limit_dist)
- continue;
+ if (thing->sprite == SPR_HOOP)
+ {
+ if (hoop_limit_dist && approx_dist > hoop_limit_dist)
+ continue;
+ }
+ else
+ {
+ if (limit_dist && approx_dist > limit_dist)
+ continue;
+ }
R_ProjectSprite(thing);
}
@@ -2527,7 +2560,7 @@ UINT8 P_GetSkinSprite2(skin_t *skin, UINT8 spr2, player_t *player)
if ((playersprite_t)(spr2 & ~FF_SPR2SUPER) >= free_spr2)
return 0;
- while (!(skin->sprites[spr2].numframes)
+ while (!skin->sprites[spr2].numframes
&& spr2 != SPR2_STND
&& ++i < 32) // recursion limiter
{
@@ -2668,6 +2701,7 @@ boolean R_SkinUsable(INT32 playernum, INT32 skinnum)
|| (modeattacking) // If you have someone else's run you might as well take a look
|| (Playing() && (R_SkinAvailable(mapheaderinfo[gamemap-1]->forcecharacter) == skinnum)) // Force 1.
|| (netgame && (cv_forceskin.value == skinnum)) // Force 2.
+ || (metalrecording && skinnum == 5) // Force 3.
);
}
@@ -2786,9 +2820,9 @@ void SetPlayerSkinByNum(INT32 playernum, INT32 skinnum)
}
if (P_IsLocalPlayer(player))
- CONS_Alert(CONS_WARNING, M_GetText("Requested skin not found\n"));
+ CONS_Alert(CONS_WARNING, M_GetText("Requested skin %d not found\n"), skinnum);
else if(server || IsPlayerAdmin(consoleplayer))
- CONS_Alert(CONS_WARNING, "Player %d (%s) skin not found\n", playernum, player_names[playernum]);
+ CONS_Alert(CONS_WARNING, "Player %d (%s) skin %d not found\n", playernum, player_names[playernum], skinnum);
SetPlayerSkinByNum(playernum, 0); // not found put the sonic skin
}
@@ -3156,7 +3190,7 @@ next_token:
#ifdef HWRENDER
if (rendermode == render_opengl)
- HWR_AddPlayerMD2(numskins);
+ HWR_AddPlayerModel(numskins);
#endif
numskins++;
diff --git a/src/s_sound.c b/src/s_sound.c
index 299e4b88976935c271852f024d412bc70a6e635a..8b87bd08328b9d00e0de2a0f0d4bbbc5b4f9d2e8 100644
--- a/src/s_sound.c
+++ b/src/s_sound.c
@@ -64,6 +64,8 @@ static void ModFilter_OnChange(void);
static lumpnum_t S_GetMusicLumpNum(const char *mname);
+static boolean S_CheckQueue(void);
+
// commands for music and sound servers
#ifdef MUSSERV
consvar_t musserver_cmd = {"musserver_cmd", "musserver", CV_SAVE, NULL, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -117,6 +119,10 @@ consvar_t cv_gamedigimusic = {"digimusic", "On", CV_SAVE|CV_CALL|CV_NOINIT, CV_O
consvar_t cv_gamemidimusic = {"midimusic", "On", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, GameMIDIMusic_OnChange, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_gamesounds = {"sounds", "On", CV_SAVE|CV_CALL|CV_NOINIT, CV_OnOff, GameSounds_OnChange, 0, NULL, NULL, 0, 0, NULL};
+// Window focus sound sytem toggles
+consvar_t cv_playmusicifunfocused = {"playmusicifunfocused", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_playsoundsifunfocused = {"playsoundsifunfocused", "No", CV_SAVE, CV_YesNo, NULL, 0, NULL, NULL, 0, 0, NULL};
+
#ifdef HAVE_OPENMPT
static CV_PossibleValue_t interpolationfilter_cons_t[] = {{0, "Default"}, {1, "None"}, {2, "Linear"}, {4, "Cubic"}, {8, "Windowed sinc"}, {0, NULL}};
consvar_t cv_modfilter = {"modfilter", "0", CV_SAVE|CV_CALL, interpolationfilter_cons_t, ModFilter_OnChange, 0, NULL, NULL, 0, 0, NULL};
@@ -278,6 +284,8 @@ void S_RegisterSoundStuff(void)
CV_RegisterVar(&cv_samplerate);
CV_RegisterVar(&cv_resetmusic);
CV_RegisterVar(&cv_resetmusicbyheader);
+ CV_RegisterVar(&cv_playsoundsifunfocused);
+ CV_RegisterVar(&cv_playmusicifunfocused);
CV_RegisterVar(&cv_gamesounds);
CV_RegisterVar(&cv_gamedigimusic);
CV_RegisterVar(&cv_gamemidimusic);
@@ -373,6 +381,18 @@ lumpnum_t S_GetSfxLumpNum(sfxinfo_t *sfx)
return W_GetNumForName("dsthok");
}
+//
+// Sound Status
+//
+
+boolean S_SoundDisabled(void)
+{
+ return (
+ sound_disabled ||
+ ( window_notinfocus && ! cv_playsoundsifunfocused.value )
+ );
+}
+
// Stop all sounds, load level info, THEN start sounds.
void S_StopSounds(void)
{
@@ -540,7 +560,7 @@ void S_StartSoundAtVolume(const void *origin_p, sfxenum_t sfx_id, INT32 volume)
mobj_t *listenmobj = players[displayplayer].mo;
mobj_t *listenmobj2 = NULL;
- if (sound_disabled || !sound_started)
+ if (S_SoundDisabled() || !sound_started)
return;
// Don't want a sound? Okay then...
@@ -730,7 +750,7 @@ dontplay:
void S_StartSound(const void *origin, sfxenum_t sfx_id)
{
- if (sound_disabled)
+ if (S_SoundDisabled())
return;
if (mariomode) // Sounds change in Mario mode!
@@ -1434,6 +1454,13 @@ boolean S_MusicPaused(void)
return I_SongPaused();
}
+boolean S_MusicNotInFocus(void)
+{
+ return (
+ ( window_notinfocus && ! cv_playmusicifunfocused.value )
+ );
+}
+
musictype_t S_MusicType(void)
{
return I_SongType();
@@ -1588,13 +1615,14 @@ static void S_AddMusicStackEntry(const char *mname, UINT16 mflags, boolean loopi
if (!music_stacks)
{
music_stacks = Z_Calloc(sizeof (*mst), PU_MUSIC, NULL);
- strncpy(music_stacks->musname, (status == JT_MASTER ? mname : mapmusname), 7);
- music_stacks->musflags = (status == JT_MASTER ? mflags : mapmusflags);
- music_stacks->looping = (status == JT_MASTER ? looping : true);
- music_stacks->position = (status == JT_MASTER ? position : S_GetMusicPosition());
+ strncpy(music_stacks->musname, (status == JT_MASTER ? mname : (S_CheckQueue() ? queue_name : mapmusname)), 7);
+ music_stacks->musflags = (status == JT_MASTER ? mflags : (S_CheckQueue() ? queue_flags : mapmusflags));
+ music_stacks->looping = (status == JT_MASTER ? looping : (S_CheckQueue() ? queue_looping : true));
+ music_stacks->position = (status == JT_MASTER ? position : (S_CheckQueue() ? queue_position : S_GetMusicPosition()));
music_stacks->tic = gametic;
music_stacks->status = JT_MASTER;
music_stacks->mlumpnum = S_GetMusicLumpNum(music_stacks->musname);
+ music_stacks->noposition = S_CheckQueue();
if (status == JT_MASTER)
return; // we just added the user's entry here
@@ -1613,6 +1641,7 @@ static void S_AddMusicStackEntry(const char *mname, UINT16 mflags, boolean loopi
new_mst->tic = gametic;
new_mst->status = status;
new_mst->mlumpnum = S_GetMusicLumpNum(new_mst->musname);
+ new_mst->noposition = false;
mst->next = new_mst;
new_mst->prev = mst;
@@ -1720,11 +1749,23 @@ boolean S_RecallMusic(UINT16 status, boolean fromfirst)
entry->tic = gametic;
entry->status = JT_MASTER;
entry->mlumpnum = S_GetMusicLumpNum(entry->musname);
+ entry->noposition = false; // don't set this until we do the mapmuschanged check, below. Else, this breaks some resumes.
}
if (entry->status == JT_MASTER)
{
mapmuschanged = strnicmp(entry->musname, mapmusname, 7);
+ if (mapmuschanged)
+ {
+ strncpy(entry->musname, mapmusname, 7);
+ entry->musflags = mapmusflags;
+ entry->looping = true;
+ entry->position = mapmusposition;
+ entry->tic = gametic;
+ entry->status = JT_MASTER;
+ entry->mlumpnum = S_GetMusicLumpNum(entry->musname);
+ entry->noposition = true;
+ }
S_ResetMusicStack();
}
else if (!entry->status)
@@ -1733,7 +1774,7 @@ boolean S_RecallMusic(UINT16 status, boolean fromfirst)
return false;
}
- if (!mapmuschanged && strncmp(entry->musname, S_MusicName(), 7)) // don't restart music if we're already playing it
+ if (strncmp(entry->musname, S_MusicName(), 7)) // don't restart music if we're already playing it
{
if (music_stack_fadeout)
S_ChangeMusicEx(entry->musname, entry->musflags, entry->looping, 0, music_stack_fadeout, 0);
@@ -1741,7 +1782,7 @@ boolean S_RecallMusic(UINT16 status, boolean fromfirst)
{
S_ChangeMusicEx(entry->musname, entry->musflags, entry->looping, 0, 0, music_stack_fadein);
- if (!music_stack_noposition) // HACK: Global boolean to toggle position resuming, e.g., de-superize
+ if (!entry->noposition && !music_stack_noposition) // HACK: Global boolean to toggle position resuming, e.g., de-superize
{
UINT32 poslapse = 0;
@@ -1867,6 +1908,10 @@ static boolean S_PlayMusic(boolean looping, UINT32 fadeinms)
}
S_InitMusicVolume(); // switch between digi and sequence volume
+
+ if (S_MusicNotInFocus())
+ S_PauseAudio();
+
return true;
}
@@ -1879,6 +1924,11 @@ static void S_QueueMusic(const char *mmusic, UINT16 mflags, boolean looping, UIN
queue_fadeinms = fadeinms;
}
+static boolean S_CheckQueue(void)
+{
+ return queue_name[0];
+}
+
static void S_ClearQueue(void)
{
queue_name[0] = queue_flags = queue_looping = queue_position = queue_fadeinms = 0;
@@ -2009,6 +2059,9 @@ void S_PauseAudio(void)
void S_ResumeAudio(void)
{
+ if (S_MusicNotInFocus())
+ return;
+
if (I_SongPlaying() && I_SongPaused())
I_ResumeSong();
@@ -2202,7 +2255,7 @@ static void Command_RestartAudio_f(void)
void GameSounds_OnChange(void)
{
- if (M_CheckParm("-nosound"))
+ if (M_CheckParm("-nosound") || M_CheckParm("-noaudio"))
return;
if (sound_disabled)
@@ -2220,7 +2273,7 @@ void GameSounds_OnChange(void)
void GameDigiMusic_OnChange(void)
{
- if (M_CheckParm("-nomusic"))
+ if (M_CheckParm("-nomusic") || M_CheckParm("-noaudio"))
return;
else if (M_CheckParm("-nodigmusic"))
return;
@@ -2262,7 +2315,7 @@ void GameDigiMusic_OnChange(void)
void GameMIDIMusic_OnChange(void)
{
- if (M_CheckParm("-nomusic"))
+ if (M_CheckParm("-nomusic") || M_CheckParm("-noaudio"))
return;
else if (M_CheckParm("-nomidimusic"))
return;
@@ -2279,7 +2332,7 @@ void GameMIDIMusic_OnChange(void)
else
{
midi_disabled = true;
- if (S_MusicType() == MU_MID)
+ if (S_MusicType() == MU_MID || S_MusicType() == MU_MID_EX)
{
if (digital_disabled)
S_StopMusic();
diff --git a/src/s_sound.h b/src/s_sound.h
index 48128527ce62dd816a66608a886595a5df0b65de..c46c9fa089b40b02965c9dd142469543cf1f8fe2 100644
--- a/src/s_sound.h
+++ b/src/s_sound.h
@@ -45,6 +45,9 @@ extern consvar_t cv_gamedigimusic;
extern consvar_t cv_gamemidimusic;
extern consvar_t cv_gamesounds;
+extern consvar_t cv_playmusicifunfocused;
+extern consvar_t cv_playsoundsifunfocused;
+
#ifdef HAVE_OPENMPT
extern consvar_t cv_modfilter;
#endif
@@ -144,6 +147,12 @@ void S_StartEx(boolean reset);
//
lumpnum_t S_GetSfxLumpNum(sfxinfo_t *sfx);
+//
+// Sound Status
+//
+
+boolean S_SoundDisabled(void);
+
//
// Start sound for thing at <origin> using <sound_id> from sounds.h
//
@@ -164,6 +173,7 @@ boolean S_MIDIMusicDisabled(void);
boolean S_MusicDisabled(void);
boolean S_MusicPlaying(void);
boolean S_MusicPaused(void);
+boolean S_MusicNotInFocus(void);
musictype_t S_MusicType(void);
const char *S_MusicName(void);
boolean S_MusicInfo(char *mname, UINT16 *mflags, boolean *looping);
@@ -210,6 +220,7 @@ typedef struct musicstack_s
tic_t tic;
UINT16 status;
lumpnum_t mlumpnum;
+ boolean noposition; // force music stack resuming from zero (like music_stack_noposition)
struct musicstack_s *prev;
struct musicstack_s *next;
diff --git a/src/screen.c b/src/screen.c
index 3d173d5ff808e104940c7e735d0f696612cd1207..dc25b2acf38342dbae8247eddb5a94e66a605ddf 100644
--- a/src/screen.c
+++ b/src/screen.c
@@ -485,9 +485,9 @@ void SCR_DisplayTicRate(void)
else if (totaltics == TICRATE) ticcntcolor = V_GREENMAP;
V_DrawString(vid.width-(72*vid.dupx), h,
- V_YELLOWMAP|V_NOSCALESTART, "FPS:");
+ V_YELLOWMAP|V_NOSCALESTART|V_HUDTRANS, "FPS:");
V_DrawString(vid.width-(40*vid.dupx), h,
- ticcntcolor|V_NOSCALESTART, va("%02d/%02u", totaltics, TICRATE));
+ ticcntcolor|V_NOSCALESTART|V_HUDTRANS, va("%02d/%02u", totaltics, TICRATE));
lasttic = ontic;
}
diff --git a/src/screen.h b/src/screen.h
index eb06279047356363c1cb5f735548c81a417b2a65..fc83bbfc9b1ac482d4420ad0139d31162c2d36f9 100644
--- a/src/screen.h
+++ b/src/screen.h
@@ -39,13 +39,8 @@
// we try to re-allocate a minimum of buffers for stability of the memory,
// so all the small-enough tables based on screen size, are allocated once
// and for all at the maximum size.
-#if defined (_WIN32_WCE)
-#define MAXVIDWIDTH 320
-#define MAXVIDHEIGHT 200
-#else
#define MAXVIDWIDTH 1920 // don't set this too high because actually
#define MAXVIDHEIGHT 1200 // lots of tables are allocated with the MAX size.
-#endif
#define BASEVIDWIDTH 320 // NEVER CHANGE THIS! This is the original
#define BASEVIDHEIGHT 200 // resolution of the graphics.
diff --git a/src/sdl/Srb2SDL-vc10.vcxproj b/src/sdl/Srb2SDL-vc10.vcxproj
index 72c38b3dc090061f370d6822d7050912ed2f34ca..0bdc26a127171ba73bcb3e4b692768475fe598a4 100644
--- a/src/sdl/Srb2SDL-vc10.vcxproj
+++ b/src/sdl/Srb2SDL-vc10.vcxproj
@@ -229,6 +229,10 @@
<ClInclude Include="..\hardware\hw_light.h" />
<ClInclude Include="..\hardware\hw_main.h" />
<ClInclude Include="..\hardware\hw_md2.h" />
+ <ClInclude Include="..\hardware\hw_md2load.h" />
+ <ClInclude Include="..\hardware\hw_md3load.h" />
+ <ClInclude Include="..\hardware\hw_model.h" />
+ <ClInclude Include="..\hardware\u_list.h" />
<ClInclude Include="..\hu_stuff.h" />
<ClInclude Include="..\info.h" />
<ClInclude Include="..\i_addrinfo.h" />
@@ -368,8 +372,12 @@
<ClCompile Include="..\hardware\hw_light.c" />
<ClCompile Include="..\hardware\hw_main.c" />
<ClCompile Include="..\hardware\hw_md2.c" />
+ <ClCompile Include="..\hardware\hw_md2load.c" />
+ <ClCompile Include="..\hardware\hw_md3load.c" />
+ <ClCompile Include="..\hardware\hw_model.c" />
<ClCompile Include="..\hardware\hw_trick.c" />
<ClCompile Include="..\hardware\r_opengl\r_opengl.c" />
+ <ClCompile Include="..\hardware\u_list.c" />
<ClCompile Include="..\hu_stuff.c" />
<ClCompile Include="..\info.c" />
<ClCompile Include="..\i_addrinfo.c">
diff --git a/src/sdl/Srb2SDL-vc10.vcxproj.filters b/src/sdl/Srb2SDL-vc10.vcxproj.filters
index 9e442000fdc1a5ad0a2e6643cd06eb99ddd8cf11..a2110822edbbe45eb4bcb016b3bed02c33c09784 100644
--- a/src/sdl/Srb2SDL-vc10.vcxproj.filters
+++ b/src/sdl/Srb2SDL-vc10.vcxproj.filters
@@ -246,6 +246,18 @@
<ClInclude Include="..\hardware\hw_md2.h">
<Filter>Hw_Hardware</Filter>
</ClInclude>
+ <ClInclude Include="..\hardware\hw_md2load.h">
+ <Filter>Hw_Hardware</Filter>
+ </ClInclude>
+ <ClInclude Include="..\hardware\hw_md3load.h">
+ <Filter>Hw_Hardware</Filter>
+ </ClInclude>
+ <ClInclude Include="..\hardware\hw_model.h">
+ <Filter>Hw_Hardware</Filter>
+ </ClInclude>
+ <ClInclude Include="..\hardware\u_list.h">
+ <Filter>Hw_Hardware</Filter>
+ </ClInclude>
<ClInclude Include="..\byteptr.h">
<Filter>I_Interface</Filter>
</ClInclude>
@@ -630,9 +642,21 @@
<ClCompile Include="..\hardware\hw_md2.c">
<Filter>Hw_Hardware</Filter>
</ClCompile>
+ <ClCompile Include="..\hardware\hw_md2load.c">
+ <Filter>Hw_Hardware</Filter>
+ </ClCompile>
+ <ClCompile Include="..\hardware\hw_md3load.c">
+ <Filter>Hw_Hardware</Filter>
+ </ClCompile>
+ <ClCompile Include="..\hardware\hw_model.c">
+ <Filter>Hw_Hardware</Filter>
+ </ClCompile>
<ClCompile Include="..\hardware\hw_trick.c">
<Filter>Hw_Hardware</Filter>
</ClCompile>
+ <ClCompile Include="..\hardware\u_list.c">
+ <Filter>Hw_Hardware</Filter>
+ </ClCompile>
<ClCompile Include="..\filesrch.c">
<Filter>I_Interface</Filter>
</ClCompile>
diff --git a/src/sdl/hwsym_sdl.c b/src/sdl/hwsym_sdl.c
index 05ac6450e2267c0c08182775cece05eeaefabeab..5f040023a8032e1086ebec70f8a28891a0b741e1 100644
--- a/src/sdl/hwsym_sdl.c
+++ b/src/sdl/hwsym_sdl.c
@@ -79,6 +79,7 @@ void *hwSym(const char *funcName,void *handle)
GETFUNC(Init);
GETFUNC(Draw2DLine);
GETFUNC(DrawPolygon);
+ GETFUNC(RenderSkyDome);
GETFUNC(SetBlend);
GETFUNC(ClearBuffer);
GETFUNC(SetTexture);
@@ -87,13 +88,11 @@ void *hwSym(const char *funcName,void *handle)
GETFUNC(ClearMipMapCache);
GETFUNC(SetSpecialState);
GETFUNC(GetTextureUsed);
- GETFUNC(DrawMD2);
- GETFUNC(DrawMD2i);
+ GETFUNC(DrawModel);
+ GETFUNC(CreateModelVBOs);
GETFUNC(SetTransform);
GETFUNC(GetRenderVersion);
-#ifdef SHUFFLE
GETFUNC(PostImgRedraw);
-#endif //SHUFFLE
GETFUNC(FlushScreenTextures);
GETFUNC(StartScreenWipe);
GETFUNC(EndScreenWipe);
diff --git a/src/sdl/i_system.c b/src/sdl/i_system.c
index d7926e5b2e7ede6b2d1337be8513e8d72bdacd6e..e7f8f2e4f9529e69a243f30defd30e835e7fc514 100644
--- a/src/sdl/i_system.c
+++ b/src/sdl/i_system.c
@@ -2181,7 +2181,7 @@ void I_Quit(void)
if (demorecording)
G_CheckDemoStatus();
if (metalrecording)
- G_StopMetalRecording();
+ G_StopMetalRecording(false);
D_QuitNetGame();
I_ShutdownMusic();
@@ -2299,7 +2299,7 @@ void I_Error(const char *error, ...)
if (demorecording)
G_CheckDemoStatus();
if (metalrecording)
- G_StopMetalRecording();
+ G_StopMetalRecording(false);
D_QuitNetGame();
I_ShutdownMusic();
diff --git a/src/sdl/i_video.c b/src/sdl/i_video.c
index e0461e4046722db5603320d8e5ab3ecbde0f2cce..ad10ba6c26b717435955e76c044382014b165d06 100644
--- a/src/sdl/i_video.c
+++ b/src/sdl/i_video.c
@@ -358,6 +358,14 @@ static INT32 Impl_SDL_Scancode_To_Keycode(SDL_Scancode code)
return 0;
}
+static void SDLdoGrabMouse(void)
+{
+ SDL_ShowCursor(SDL_DISABLE);
+ SDL_SetWindowGrab(window, SDL_TRUE);
+ if (SDL_SetRelativeMouseMode(SDL_TRUE) == 0) // already warps mouse if successful
+ wrapmouseok = SDL_TRUE; // TODO: is wrapmouseok or HalfWarpMouse needed anymore?
+}
+
static void SDLdoUngrabMouse(void)
{
SDL_ShowCursor(SDL_ENABLE);
@@ -580,12 +588,18 @@ static void Impl_HandleWindowEvent(SDL_WindowEvent evt)
if (cv_usemouse.value) I_StartupMouse();
}
//else firsttimeonmouse = SDL_FALSE;
+
+ if (USE_MOUSEINPUT)
+ SDLdoGrabMouse();
}
else if (!mousefocus && !kbfocus)
{
// Tell game we lost focus, pause music
window_notinfocus = true;
- S_PauseAudio();
+ if (! cv_playmusicifunfocused.value)
+ S_PauseAudio();
+ if (! cv_playsoundsifunfocused.value)
+ S_StopSounds();
if (!disable_mouse)
{
@@ -656,9 +670,7 @@ static void Impl_HandleMouseMotionEvent(SDL_MouseMotionEvent evt)
// -- Monster Iestyn
if (SDL_GetMouseFocus() == window && SDL_GetKeyboardFocus() == window)
{
- SDL_SetWindowGrab(window, SDL_TRUE);
- if (SDL_SetRelativeMouseMode(SDL_TRUE) == 0) // already warps mouse if successful
- wrapmouseok = SDL_TRUE; // TODO: is wrapmouseok or HalfWarpMouse needed anymore?
+ SDLdoGrabMouse();
}
}
}
@@ -1057,7 +1069,7 @@ void I_StartupMouse(void)
else
firsttimeonmouse = SDL_FALSE;
if (cv_usemouse.value)
- return;
+ SDLdoGrabMouse();
else
SDLdoUngrabMouse();
}
@@ -1165,8 +1177,11 @@ void I_FinishUpdate(void)
if (cv_closedcaptioning.value)
SCR_ClosedCaptions();
- if (cv_ticrate.value)
- SCR_DisplayTicRate();
+ if (st_overlay)
+ {
+ if (cv_ticrate.value)
+ SCR_DisplayTicRate();
+ }
if (rendermode == render_soft && screens[0])
{
@@ -1708,6 +1723,7 @@ void I_StartupHardwareGraphics(void)
HWD.pfnFinishUpdate = NULL;
HWD.pfnDraw2DLine = hwSym("Draw2DLine",NULL);
HWD.pfnDrawPolygon = hwSym("DrawPolygon",NULL);
+ HWD.pfnRenderSkyDome = hwSym("RenderSkyDome",NULL);
HWD.pfnSetBlend = hwSym("SetBlend",NULL);
HWD.pfnClearBuffer = hwSym("ClearBuffer",NULL);
HWD.pfnSetTexture = hwSym("SetTexture",NULL);
@@ -1717,13 +1733,11 @@ void I_StartupHardwareGraphics(void)
HWD.pfnSetSpecialState = hwSym("SetSpecialState",NULL);
HWD.pfnSetPalette = hwSym("SetPalette",NULL);
HWD.pfnGetTextureUsed = hwSym("GetTextureUsed",NULL);
- HWD.pfnDrawMD2 = hwSym("DrawMD2",NULL);
- HWD.pfnDrawMD2i = hwSym("DrawMD2i",NULL);
+ HWD.pfnDrawModel = hwSym("DrawModel",NULL);
+ HWD.pfnCreateModelVBOs = hwSym("CreateModelVBOs",NULL);
HWD.pfnSetTransform = hwSym("SetTransform",NULL);
HWD.pfnGetRenderVersion = hwSym("GetRenderVersion",NULL);
-#ifdef SHUFFLE
HWD.pfnPostImgRedraw = hwSym("PostImgRedraw",NULL);
-#endif
HWD.pfnFlushScreenTextures=hwSym("FlushScreenTextures",NULL);
HWD.pfnStartScreenWipe = hwSym("StartScreenWipe",NULL);
HWD.pfnEndScreenWipe = hwSym("EndScreenWipe",NULL);
diff --git a/src/sdl/mixer_sound.c b/src/sdl/mixer_sound.c
index d94010d9add02dcc47693b9149f5b7fc177b148d..c4b2f98f4d73dbbe85df4f0ef7933568cc7fcbd2 100644
--- a/src/sdl/mixer_sound.c
+++ b/src/sdl/mixer_sound.c
@@ -878,7 +878,11 @@ boolean I_SetSongSpeed(float speed)
#ifdef HAVE_OPENMPT
if (openmpt_mhandle)
{
- char modspd[16];
+ char modspd[13];
+
+ if (speed > 4.0f)
+ speed = 4.0f; // Limit this to 4x to prevent crashing, stupid fix but... ~SteelT 27/9/19
+
sprintf(modspd, "%g", speed);
openmpt_module_ctl_set(openmpt_mhandle, "play.tempo_factor", modspd);
return true;
diff --git a/src/sounds.c b/src/sounds.c
index 6940cd9ee69cfc86479bdaea6a1019be2c761d74..791a7571e432b23343fcb39b63ca5a6d9c86bd7f 100644
--- a/src/sounds.c
+++ b/src/sounds.c
@@ -218,6 +218,8 @@ sfxinfo_t S_sfx[NUMSFX] =
{"chuchu", false, 32, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Train horn"},
{"bsnipe", false, 200, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Home-run smash"},
{"sprong", false, 112, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Power spring"},
+ {"lvfal1", true, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Rumble"},
+ {"pscree", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "SCREE!"},
// Menu, interface
{"chchng", false, 120, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Score"},
@@ -504,7 +506,7 @@ sfxinfo_t S_sfx[NUMSFX] =
{"s3k6d", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"s3k6e", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Mechanical damage"},
{"s3k6f", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Ominous rumbling"},
- {"s3k70", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Burst"},
+ {"s3k70", true, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Burst"},
{"s3k71", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Basic Shield"},
{"s3k72", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Movement"},
{"s3k73", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Warp"},
@@ -555,7 +557,7 @@ sfxinfo_t S_sfx[NUMSFX] =
{"s3ka0", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Launch"},
{"s3ka1", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"s3ka2", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Launch"},
- {"s3ka3", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Lift"},
+ {"s3ka3", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Rising charge"},
{"s3ka4", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Powering up"},
{"s3ka5", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"s3ka6", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Attraction fizzle"},
@@ -691,7 +693,7 @@ sfxinfo_t S_sfx[NUMSFX] =
{"cdfm37", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"cdfm38", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Drowning"},
{"cdfm39", false, 128, 8, -1, NULL, 0, -1, -1, LUMPERROR, ""},
- {"cdfm40", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
+ {"cdfm40", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Power up"},
{"cdfm41", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"cdfm42", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"cdfm43", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
@@ -713,7 +715,7 @@ sfxinfo_t S_sfx[NUMSFX] =
{"cdfm59", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"cdfm60", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"cdfm61", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
- {"cdfm62", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
+ {"cdfm62", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Speed boost"},
{"cdfm63", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"cdfm64", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"cdfm65", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
@@ -778,7 +780,7 @@ sfxinfo_t S_sfx[NUMSFX] =
{"kc4a", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"kc4b", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"kc4c", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
- {"kc4d", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
+ {"kc4d", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Power up"},
{"kc4e", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"kc4f", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"kc50", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
@@ -802,7 +804,7 @@ sfxinfo_t S_sfx[NUMSFX] =
{"kc62", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"kc63", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"kc64", false, 96, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Terrifying rumble"},
- {"kc65", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
+ {"kc65", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, "Power down"},
{"kc66", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"kc67", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
{"kc68", false, 64, 0, -1, NULL, 0, -1, -1, LUMPERROR, ""},
diff --git a/src/sounds.h b/src/sounds.h
index e5568b59a49148382c22bcc9b60ae7c57404ea22..9f6e0bab640128b2e8c4a36182479bc2b28f7cbe 100644
--- a/src/sounds.h
+++ b/src/sounds.h
@@ -267,6 +267,8 @@ typedef enum
sfx_chuchu,
sfx_bsnipe,
sfx_sprong,
+ sfx_lvfal1,
+ sfx_pscree,
// Menu, interface
sfx_chchng,
diff --git a/src/st_stuff.c b/src/st_stuff.c
index 72c9e14760243358d6ed3aed7ee250388c03f34a..25761a78d3ad90e89fdaf057724c0e601a71ad22 100644
--- a/src/st_stuff.c
+++ b/src/st_stuff.c
@@ -351,7 +351,7 @@ void ST_LoadFaceGraphics(INT32 skinnum)
if (skins[skinnum].sprites[SPR2_XTRA].numframes)
{
spritedef_t *sprdef = &skins[skinnum].sprites[SPR2_XTRA];
- spriteframe_t *sprframe = &sprdef->spriteframes[0];
+ spriteframe_t *sprframe = &sprdef->spriteframes[XTRA_LIFEPIC];
faceprefix[skinnum] = W_CachePatchNum(sprframe->lumppat[0], PU_HUDGFX);
if (skins[skinnum].sprites[(SPR2_XTRA|FF_SPR2SUPER)].numframes)
{
@@ -837,7 +837,13 @@ static void ST_drawLivesArea(void)
}
// Lives number
- if (G_GametypeUsesLives() || gametype == GT_RACE)
+ if (metalrecording)
+ {
+ if (((2*leveltime)/TICRATE) & 1)
+ V_DrawRightAlignedString(hudinfo[HUD_LIVES].x+58, hudinfo[HUD_LIVES].y+8,
+ hudinfo[HUD_LIVES].f|V_PERPLAYER|V_REDMAP|V_HUDTRANS, "REC");
+ }
+ else if (G_GametypeUsesLives() || gametype == GT_RACE)
{
// x
V_DrawScaledPatch(hudinfo[HUD_LIVES].x+22, hudinfo[HUD_LIVES].y+10,
@@ -1474,12 +1480,9 @@ static void ST_drawNightsRecords(void)
if (P_HasGrades(gamemap, stplyr->lastmare + 1))
{
- if (aflag)
- V_DrawTranslucentPatch(BASEVIDWIDTH/2 + 60, 160, aflag,
- ngradeletters[P_GetGrade(stplyr->lastmarescore, gamemap, stplyr->lastmare)]);
- else
- V_DrawScaledPatch(BASEVIDWIDTH/2 + 60, 160, 0,
- ngradeletters[P_GetGrade(stplyr->lastmarescore, gamemap, stplyr->lastmare)]);
+ UINT8 grade = P_GetGrade(stplyr->lastmarescore, gamemap, stplyr->lastmare);
+ if (modeattacking || grade >= GRADE_A)
+ V_DrawTranslucentPatch(BASEVIDWIDTH/2 + 60, 160, aflag, ngradeletters[grade]);
}
break;
}
@@ -1857,7 +1860,8 @@ static void ST_drawNiGHTSHUD(void)
numbersize = 48/2;
if ((oldspecialstage && leveltime & 2)
- && (stplyr->mo->eflags & (MFE_TOUCHWATER|MFE_UNDERWATER)))
+ && (stplyr->mo->eflags & (MFE_TOUCHWATER|MFE_UNDERWATER))
+ && !(stplyr->powers[pw_shield] & SH_PROTECTWATER))
col = SKINCOLOR_ORANGE;
ST_DrawNightsOverlayNum((160 + numbersize)<<FRACBITS, 14<<FRACBITS, FRACUNIT, V_PERPLAYER|V_SNAPTOTOP, realnightstime, nightsnum, col);
diff --git a/src/v_video.c b/src/v_video.c
index 6eb522f68966804ad714b71717ee059ae1487f75..6cd728c1911e3006901c383f61a3d0e652732226 100644
--- a/src/v_video.c
+++ b/src/v_video.c
@@ -89,8 +89,8 @@ static void CV_Gammaxxx_ONChange(void);
// but they won't do anything.
static CV_PossibleValue_t grgamma_cons_t[] = {{1, "MIN"}, {255, "MAX"}, {0, NULL}};
static CV_PossibleValue_t grsoftwarefog_cons_t[] = {{0, "Off"}, {1, "On"}, {2, "LightPlanes"}, {0, NULL}};
+static CV_PossibleValue_t grmodelinterpolation_cons_t[] = {{0, "Off"}, {1, "Sometimes"}, {2, "Always"}, {0, NULL}};
-consvar_t cv_voodoocompatibility = {"gr_voodoocompatibility", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_grfovchange = {"gr_fovchange", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_grfog = {"gr_fog", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_grfogcolor = {"gr_fogcolor", "AAAAAA", CV_SAVE, NULL, NULL, 0, NULL, NULL, 0, 0, NULL};
@@ -108,10 +108,11 @@ consvar_t cv_grcoronas = {"gr_coronas", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL,
consvar_t cv_grcoronasize = {"gr_coronasize", "1", CV_SAVE| CV_FLOAT, 0, NULL, 0, NULL, NULL, 0, 0, NULL};
#endif
-static CV_PossibleValue_t CV_MD2[] = {{0, "Off"}, {1, "On"}, {2, "Old"}, {0, NULL}};
-// console variables in development
-consvar_t cv_grmd2 = {"gr_md2", "Off", CV_SAVE, CV_MD2, NULL, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_grmodels = {"gr_models", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_grmodelinterpolation = {"gr_modelinterpolation", "Sometimes", CV_SAVE, grmodelinterpolation_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
+
consvar_t cv_grspritebillboarding = {"gr_spritebillboarding", "Off", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_grskydome = {"gr_skydome", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
#endif
// local copy of the palette for V_GetColor()
@@ -1073,7 +1074,7 @@ void V_DrawContinueIcon(INT32 x, INT32 y, INT32 flags, INT32 skinnum, UINT8 skin
if (skinnum >= 0 && skinnum < numskins && skins[skinnum].sprites[SPR2_XTRA].numframes >= 4)
{
spritedef_t *sprdef = &skins[skinnum].sprites[SPR2_XTRA];
- spriteframe_t *sprframe = &sprdef->spriteframes[3];
+ spriteframe_t *sprframe = &sprdef->spriteframes[XTRA_CONTINUE];
patch_t *patch = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
const UINT8 *colormap = R_GetTranslationColormap(skinnum, skincolor, GTC_CACHE);
@@ -2191,7 +2192,7 @@ void V_DrawString(INT32 x, INT32 y, INT32 option, const char *string)
w = SHORT(hu_font[c]->width) * dupx;
if (cx > scrwidth)
- break;
+ continue;
if (cx+left + w < 0) //left boundary check
{
cx += w;
@@ -2305,7 +2306,7 @@ void V_DrawSmallString(INT32 x, INT32 y, INT32 option, const char *string)
w = SHORT(hu_font[c]->width) * dupx / 2;
if (cx > scrwidth)
- break;
+ continue;
if (cx+left + w < 0) //left boundary check
{
cx += w;
@@ -2410,7 +2411,7 @@ void V_DrawThinString(INT32 x, INT32 y, INT32 option, const char *string)
w = (SHORT(tny_font[c]->width) * dupx);
if (cx > scrwidth)
- break;
+ continue;
if (cx+left + w < 0) //left boundary check
{
cx += w;
@@ -2508,7 +2509,7 @@ void V_DrawStringAtFixed(fixed_t x, fixed_t y, INT32 option, const char *string)
w = SHORT(hu_font[c]->width) * dupx;
if ((cx>>FRACBITS) > scrwidth)
- break;
+ continue;
if ((cx>>FRACBITS)+left + w < 0) //left boundary check
{
cx += w<<FRACBITS;
@@ -2620,13 +2621,210 @@ void V_DrawCreditString(fixed_t x, fixed_t y, INT32 option, const char *string)
w = SHORT(cred_font[c]->width) * dupx;
if ((cx>>FRACBITS) > scrwidth)
- break;
+ continue;
V_DrawSciencePatch(cx, cy, option, cred_font[c], FRACUNIT);
cx += w<<FRACBITS;
}
}
+// Draw a string using the nt_font
+// Note that the outline is a seperate font set
+static void V_DrawNameTagLine(INT32 x, INT32 y, INT32 option, fixed_t scale, UINT8 *basecolormap, UINT8 *outlinecolormap, const char *string)
+{
+ fixed_t cx, cy, w;
+ INT32 c, dupx, dupy, scrwidth, left = 0;
+ const char *ch = string;
+
+ if (option & V_CENTERNAMETAG)
+ x -= FixedInt(FixedMul((V_NameTagWidth(string)/2)*FRACUNIT, scale));
+ option &= ~V_CENTERNAMETAG; // which is also shared with V_ALLOWLOWERCASE...
+
+ cx = x<<FRACBITS;
+ cy = y<<FRACBITS;
+
+ if (option & V_NOSCALESTART)
+ {
+ dupx = vid.dupx;
+ dupy = vid.dupy;
+ scrwidth = vid.width;
+ }
+ else
+ {
+ dupx = dupy = 1;
+ scrwidth = vid.width/vid.dupx;
+ left = (scrwidth - BASEVIDWIDTH)/2;
+ scrwidth -= left;
+ }
+
+ for (;;ch++)
+ {
+ if (!*ch)
+ break;
+ if (*ch == '\n')
+ {
+ cx = x<<FRACBITS;
+ cy += FixedMul((21*dupy)*FRACUNIT, scale);
+ continue;
+ }
+
+ c = toupper(*ch);
+ c -= NT_FONTSTART;
+
+ // character does not exist or is a space
+ if (c < 0 || c >= NT_FONTSIZE || !ntb_font[c] || !nto_font[c])
+ {
+ cx += FixedMul((4 * dupx)*FRACUNIT, scale);
+ continue;
+ }
+
+ w = FixedMul((SHORT(ntb_font[c]->width)+2 * dupx) * FRACUNIT, scale);
+
+ if (FixedInt(cx) > scrwidth)
+ continue;
+ if (cx+(left*FRACUNIT) + w < 0) // left boundary check
+ {
+ cx += w;
+ continue;
+ }
+
+ V_DrawFixedPatch(cx, cy, scale, option, nto_font[c], outlinecolormap);
+ V_DrawFixedPatch(cx, cy, scale, option, ntb_font[c], basecolormap);
+
+ cx += w;
+ }
+}
+
+// Looks familiar.
+void V_DrawNameTag(INT32 x, INT32 y, INT32 option, fixed_t scale, UINT8 *basecolormap, UINT8 *outlinecolormap, const char *string)
+{
+ const char *text = string;
+ const char *first_token = text;
+ char *last_token = strchr(text, '\n');
+ const INT32 lbreakheight = 21;
+ INT32 ntlines;
+
+ if (option & V_CENTERNAMETAG)
+ {
+ ntlines = V_CountNameTagLines(string);
+ y -= FixedInt(FixedMul(((lbreakheight/2) * (ntlines-1))*FRACUNIT, scale));
+ }
+
+ // No line breaks?
+ // Draw entire string
+ if (!last_token)
+ V_DrawNameTagLine(x, y, option, scale, basecolormap, outlinecolormap, string);
+ // Split string by the line break character
+ else
+ {
+ char *str = NULL;
+ INT32 len;
+ while (true)
+ {
+ // There are still lines left to draw
+ if (last_token)
+ {
+ size_t shift = 0;
+ // Free this line
+ if (str)
+ Z_Free(str);
+ // Find string length, do a malloc...
+ len = (last_token-first_token)+1;
+ str = ZZ_Alloc(len);
+ // Copy the line
+ strncpy(str, first_token, len-1);
+ str[len-1] = '\0';
+ // Don't leave a line break character
+ // at the start of the string!
+ if ((strlen(str) >= 2) && (string[0] == '\n') && (string[1] != '\n'))
+ shift++;
+ // Then draw it
+ V_DrawNameTagLine(x, y, option, scale, basecolormap, outlinecolormap, str+shift);
+ }
+ // No line break character was found
+ else
+ {
+ // Don't leave a line break character
+ // at the start of the string!
+ if ((strlen(first_token) >= 2) && (first_token[0] == '\n') && (first_token[1] != '\n'))
+ first_token++;
+ // Then draw it
+ V_DrawNameTagLine(x, y, option, scale, basecolormap, outlinecolormap, first_token);
+ break;
+ }
+
+ // Next line
+ y += FixedInt(FixedMul(lbreakheight*FRACUNIT, scale));
+ if ((last_token-text)+1 >= (signed)strlen(text))
+ last_token = NULL;
+ else
+ {
+ first_token = last_token;
+ last_token = strchr(first_token+1, '\n');
+ }
+ }
+ // Free this line
+ if (str)
+ Z_Free(str);
+ }
+}
+
+// Count the amount of lines in name tag string
+INT32 V_CountNameTagLines(const char *string)
+{
+ INT32 ntlines = 1;
+ const char *text = string;
+ const char *first_token = text;
+ char *last_token = strchr(text, '\n');
+
+ // No line breaks?
+ if (!last_token)
+ return ntlines;
+ // Split string by the line break character
+ else
+ {
+ while (true)
+ {
+ if (last_token)
+ ntlines++;
+ // No line break character was found
+ else
+ break;
+
+ // Next line
+ if ((last_token-text)+1 >= (signed)strlen(text))
+ last_token = NULL;
+ else
+ {
+ first_token = last_token;
+ last_token = strchr(first_token+1, '\n');
+ }
+ }
+ }
+ return ntlines;
+}
+
+INT32 V_NameTagWidth(const char *string)
+{
+ INT32 c, w = 0;
+ size_t i;
+
+ // It's possible for string to be a null pointer
+ if (!string)
+ return 0;
+
+ for (i = 0; i < strlen(string); i++)
+ {
+ c = toupper(string[i]) - NT_FONTSTART;
+ if (c < 0 || c >= NT_FONTSIZE || !ntb_font[c] || !nto_font[c])
+ w += 4;
+ else
+ w += SHORT(ntb_font[c]->width)+2;
+ }
+
+ return w;
+}
+
// Find string width from cred_font chars
//
INT32 V_CreditStringWidth(const char *string)
@@ -2702,7 +2900,7 @@ void V_DrawLevelTitle(INT32 x, INT32 y, INT32 option, const char *string)
w = SHORT(lt_font[c]->width) * dupx;
if (cx > scrwidth)
- break;
+ continue;
if (cx+left + w < 0) //left boundary check
{
cx += w;
diff --git a/src/v_video.h b/src/v_video.h
index 7eb990295de7c23d35eef3ebf29a243b74081eae..01d50cd57957479dfe74700aba40212caa215996 100644
--- a/src/v_video.h
+++ b/src/v_video.h
@@ -112,6 +112,7 @@ extern RGBA_t *pMasterPalette;
#define V_OFFSET 0x00400000 // account for offsets in patches
#define V_ALLOWLOWERCASE 0x00800000 // (strings only) allow fonts that have lowercase letters to use them
#define V_FLIP 0x00800000 // (patches only) Horizontal flip
+#define V_CENTERNAMETAG 0x00800000 // (nametag only) center nametag lines
#define V_SNAPTOTOP 0x01000000 // for centering
#define V_SNAPTOBOTTOM 0x02000000 // for centering
@@ -205,6 +206,11 @@ INT32 V_LevelActNumWidth(INT32 num); // act number width
void V_DrawCreditString(fixed_t x, fixed_t y, INT32 option, const char *string);
INT32 V_CreditStringWidth(const char *string);
+// Draw a string using the nt_font
+void V_DrawNameTag(INT32 x, INT32 y, INT32 option, fixed_t scale, UINT8 *basecolormap, UINT8 *outlinecolormap, const char *string);
+INT32 V_CountNameTagLines(const char *string);
+INT32 V_NameTagWidth(const char *string);
+
// Find string width from hu_font chars
INT32 V_StringWidth(const char *string, INT32 option);
// Find string width from hu_font chars, 0.5x scale
diff --git a/src/w_wad.c b/src/w_wad.c
index a6f611b85682bad6dfc4d29e19ff8f771d37c47a..df22398915d98a24f26b096bfd421980091b5afb 100644
--- a/src/w_wad.c
+++ b/src/w_wad.c
@@ -1550,7 +1550,10 @@ void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
if (!lumpcache[lump])
{
size_t len = W_LumpLengthPwad(wad, lump);
- void *ptr, *lumpdata, *srcdata = NULL;
+ void *ptr, *lumpdata;
+#ifndef NO_PNG_LUMPS
+ void *srcdata = NULL;
+#endif
ptr = Z_Malloc(len, tag, &lumpcache[lump]);
lumpdata = Z_Malloc(len, tag, NULL);
@@ -1581,22 +1584,22 @@ void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
grPatch = HWR_GetCachedGLPatchPwad(wad, lump);
- if (grPatch->mipmap.grInfo.data)
+ if (grPatch->mipmap->grInfo.data)
{
if (tag == PU_CACHE)
tag = PU_HWRCACHE;
- Z_ChangeTag(grPatch->mipmap.grInfo.data, tag);
+ Z_ChangeTag(grPatch->mipmap->grInfo.data, tag);
}
else
{
patch_t *ptr = NULL;
// Only load the patch if we haven't initialised the grPatch yet
- if (grPatch->mipmap.width == 0)
+ if (grPatch->mipmap->width == 0)
ptr = W_CacheLumpNumPwad(grPatch->wadnum, grPatch->lumpnum, PU_STATIC);
// Run HWR_MakePatch in all cases, to recalculate some things
- HWR_MakePatch(ptr, grPatch, &grPatch->mipmap, false);
+ HWR_MakePatch(ptr, grPatch, grPatch->mipmap, false);
Z_Free(ptr);
}
@@ -1695,12 +1698,12 @@ void W_VerifyFileMD5(UINT16 wadfilenum, const char *matchmd5)
{
char actualmd5text[2*MD5_LEN+1];
PrintMD5String(wadfiles[wadfilenum]->md5sum, actualmd5text);
-#ifdef _DEBUG
+/*#ifdef _DEBUG
CONS_Printf
#else
I_Error
#endif
- (M_GetText("File is corrupt or has been modified: %s (found md5: %s, wanted: %s)\n"), wadfiles[wadfilenum]->filename, actualmd5text, matchmd5);
+ (M_GetText("File is corrupt or has been modified: %s (found md5: %s, wanted: %s)\n"), wadfiles[wadfilenum]->filename, actualmd5text, matchmd5);*/
}
#endif
}
diff --git a/src/win32/Srb2win-vc10.vcxproj b/src/win32/Srb2win-vc10.vcxproj
index c0fe8eda9ad5f2d73f7a0c2cd7f1a2023a02dd0e..dea71925c09796e93ae577fad417b9a2bbc3d3a2 100644
--- a/src/win32/Srb2win-vc10.vcxproj
+++ b/src/win32/Srb2win-vc10.vcxproj
@@ -231,7 +231,11 @@
<ClCompile Include="..\hardware\hw_light.c" />
<ClCompile Include="..\hardware\hw_main.c" />
<ClCompile Include="..\hardware\hw_md2.c" />
+ <ClCompile Include="..\hardware\hw_md2load.c" />
+ <ClCompile Include="..\hardware\hw_md3load.c" />
+ <ClCompile Include="..\hardware\hw_model.c" />
<ClCompile Include="..\hardware\hw_trick.c" />
+ <ClCompile Include="..\hardware\u_list.c" />
<ClCompile Include="..\hu_stuff.c" />
<ClCompile Include="..\info.c" />
<ClCompile Include="..\i_addrinfo.c">
@@ -396,6 +400,10 @@
<ClInclude Include="..\hardware\hw_light.h" />
<ClInclude Include="..\hardware\hw_main.h" />
<ClInclude Include="..\hardware\hw_md2.h" />
+ <ClInclude Include="..\hardware\hw_md2load.h" />
+ <ClInclude Include="..\hardware\hw_md3load.h" />
+ <ClInclude Include="..\hardware\hw_model.h" />
+ <ClInclude Include="..\hardware\u_list.h" />
<ClInclude Include="..\hu_stuff.h" />
<ClInclude Include="..\info.h" />
<ClInclude Include="..\i_addrinfo.h" />
diff --git a/src/win32/Srb2win-vc10.vcxproj.filters b/src/win32/Srb2win-vc10.vcxproj.filters
index 93806e3951066fff4172cdc9f60a0315171e74f4..c7e93ddd9a257feb994a025d4ffd74b328b723f2 100644
--- a/src/win32/Srb2win-vc10.vcxproj.filters
+++ b/src/win32/Srb2win-vc10.vcxproj.filters
@@ -453,6 +453,18 @@
<ClCompile Include="..\string.c">
<Filter>M_Misc</Filter>
</ClCompile>
+ <ClCompile Include="..\hardware\hw_md2load.c">
+ <Filter>Hw_Hardware</Filter>
+ </ClCompile>
+ <ClCompile Include="..\hardware\hw_md3load.c">
+ <Filter>Hw_Hardware</Filter>
+ </ClCompile>
+ <ClCompile Include="..\hardware\hw_model.c">
+ <Filter>Hw_Hardware</Filter>
+ </ClCompile>
+ <ClCompile Include="..\hardware\u_list.c">
+ <Filter>Hw_Hardware</Filter>
+ </ClCompile>
<ClCompile Include="..\hardware\hw_clip.c">
<Filter>Hw_Hardware</Filter>
</ClCompile>
@@ -513,6 +525,15 @@
<ClInclude Include="..\hardware\hw_md2.h">
<Filter>Hw_Hardware</Filter>
</ClInclude>
+ <ClInclude Include="..\hardware\hw_md2load.h">
+ <Filter>Hw_Hardware</Filter>
+ </ClInclude>
+ <ClInclude Include="..\hardware\hw_md3load.h">
+ <Filter>Hw_Hardware</Filter>
+ </ClInclude>
+ <ClInclude Include="..\hardware\hw_model.h">
+ <Filter>Hw_Hardware</Filter>
+ </ClInclude>
<ClInclude Include="..\hardware\hw3dsdrv.h">
<Filter>Hw_Hardware</Filter>
</ClInclude>
@@ -522,6 +543,9 @@
<ClInclude Include="..\hardware\hws_data.h">
<Filter>Hw_Hardware</Filter>
</ClInclude>
+ <ClInclude Include="..\hardware\u_list.h">
+ <Filter>Hw_Hardware</Filter>
+ </ClInclude>
<ClInclude Include="..\blua\lapi.h">
<Filter>BLUA</Filter>
</ClInclude>
diff --git a/src/win32/win_dll.c b/src/win32/win_dll.c
index 71eda04371d4223dedcd5e193d8c27ed8cf0f70d..5378bb52f645bc10abc0c58dcf27d38f15d9b85a 100644
--- a/src/win32/win_dll.c
+++ b/src/win32/win_dll.c
@@ -102,6 +102,7 @@ static loadfunc_t hwdFuncTable[] = {
{"FinishUpdate@4", &hwdriver.pfnFinishUpdate},
{"Draw2DLine@12", &hwdriver.pfnDraw2DLine},
{"DrawPolygon@16", &hwdriver.pfnDrawPolygon},
+ {"RenderSkyDome@16", &hwdriver.pfnRenderSkyDome},
{"SetBlend@4", &hwdriver.pfnSetBlend},
{"ClearBuffer@12", &hwdriver.pfnClearBuffer},
{"SetTexture@4", &hwdriver.pfnSetTexture},
@@ -109,8 +110,7 @@ static loadfunc_t hwdFuncTable[] = {
{"GClipRect@20", &hwdriver.pfnGClipRect},
{"ClearMipMapCache@0", &hwdriver.pfnClearMipMapCache},
{"SetSpecialState@8", &hwdriver.pfnSetSpecialState},
- {"DrawMD2@16", &hwdriver.pfnDrawMD2},
- {"DrawMD2i@36", &hwdriver.pfnDrawMD2i},
+ {"DrawModel@16", &hwdriver.pfnDrawModel},
{"SetTransform@4", &hwdriver.pfnSetTransform},
{"GetTextureUsed@0", &hwdriver.pfnGetTextureUsed},
{"GetRenderVersion@0", &hwdriver.pfnGetRenderVersion},
@@ -133,6 +133,7 @@ static loadfunc_t hwdFuncTable[] = {
{"FinishUpdate", &hwdriver.pfnFinishUpdate},
{"Draw2DLine", &hwdriver.pfnDraw2DLine},
{"DrawPolygon", &hwdriver.pfnDrawPolygon},
+ {"RenderSkyDome", &hwdriver.pfnRenderSkyDome},
{"SetBlend", &hwdriver.pfnSetBlend},
{"ClearBuffer", &hwdriver.pfnClearBuffer},
{"SetTexture", &hwdriver.pfnSetTexture},
@@ -140,8 +141,7 @@ static loadfunc_t hwdFuncTable[] = {
{"GClipRect", &hwdriver.pfnGClipRect},
{"ClearMipMapCache", &hwdriver.pfnClearMipMapCache},
{"SetSpecialState", &hwdriver.pfnSetSpecialState},
- {"DrawMD2", &hwdriver.pfnDrawMD2},
- {"DrawMD2i", &hwdriver.pfnDrawMD2i},
+ {"DrawModel", &hwdriver.pfnDrawModel},
{"SetTransform", &hwdriver.pfnSetTransform},
{"GetTextureUsed", &hwdriver.pfnGetTextureUsed},
{"GetRenderVersion", &hwdriver.pfnGetRenderVersion},
diff --git a/src/win32/win_sys.c b/src/win32/win_sys.c
index 93b3ff52381998528099495a738236c918351498..c9fdb1c9742fa87a803aed9e88fb1578aceac904 100644
--- a/src/win32/win_sys.c
+++ b/src/win32/win_sys.c
@@ -647,7 +647,7 @@ void I_Error(const char *error, ...)
if (demorecording)
G_CheckDemoStatus();
if (metalrecording)
- G_StopMetalRecording();
+ G_StopMetalRecording(false);
D_QuitNetGame();
@@ -733,7 +733,7 @@ void I_Quit(void)
if (demorecording)
G_CheckDemoStatus();
if (metalrecording)
- G_StopMetalRecording();
+ G_StopMetalRecording(false);
M_SaveConfig(NULL); // save game config, cvars..
#ifndef NONET
diff --git a/src/y_inter.c b/src/y_inter.c
index cdf6378b348e56e48b885d91223e1f9670b34f26..0059d5f068dd44b9703a44aaca5717772360cbac 100644
--- a/src/y_inter.c
+++ b/src/y_inter.c
@@ -35,6 +35,7 @@
#include "p_local.h"
#include "m_cond.h" // condition sets
+#include "lua_hook.h" // IntermissionThinker hook
#ifdef HWRENDER
#include "hardware/hw_main.h"
@@ -142,10 +143,22 @@ static patch_t *widebgpatch = NULL; // INTERSCW
static patch_t *bgtile = NULL; // SPECTILE/SRB2BACK
static patch_t *interpic = NULL; // custom picture defined in map header
static boolean usetile;
+static INT32 timer;
+
+typedef struct
+{
+ INT32 source_width, source_height;
+ INT32 source_bpp, source_rowbytes;
+ UINT8 *source_picture;
+ INT32 target_width, target_height;
+ INT32 target_bpp, target_rowbytes;
+ UINT8 *target_picture;
+} y_buffer_t;
+
boolean usebuffer = false;
static boolean useinterpic;
static boolean safetorender = true;
-static INT32 timer;
+static y_buffer_t *y_buffer;
static INT32 intertic;
static INT32 tallydonetic = -1;
@@ -153,6 +166,8 @@ static INT32 endtic = -1;
intertype_t intertype = int_none;
+static void Y_RescaleScreenBuffer(void);
+static void Y_CleanupScreenBuffer(void);
static void Y_AwardCoopBonuses(void);
static void Y_AwardSpecialStageBonus(void);
static void Y_CalculateCompetitionWinners(void);
@@ -208,6 +223,94 @@ static void Y_IntermissionTokenDrawer(void)
V_DrawCroppedPatch(32<<FRACBITS, y<<FRACBITS, FRACUNIT/2, 0, tokenicon, 0, 0, SHORT(tokenicon->width), calc);
}
+//
+// Y_ConsiderScreenBuffer
+//
+// Can we copy the current screen
+// to a buffer?
+//
+void Y_ConsiderScreenBuffer(void)
+{
+ if (gameaction != ga_completed)
+ return;
+
+ if (y_buffer == NULL)
+ y_buffer = Z_Calloc(sizeof(y_buffer_t), PU_STATIC, NULL);
+ else
+ return;
+
+ y_buffer->source_width = vid.width;
+ y_buffer->source_height = vid.height;
+ y_buffer->source_bpp = vid.bpp;
+ y_buffer->source_rowbytes = vid.rowbytes;
+ y_buffer->source_picture = ZZ_Alloc(y_buffer->source_width*vid.bpp * y_buffer->source_height);
+ VID_BlitLinearScreen(screens[1], y_buffer->source_picture, vid.width*vid.bpp, vid.height, vid.width*vid.bpp, vid.rowbytes);
+
+ // Make the rescaled screen buffer
+ Y_RescaleScreenBuffer();
+}
+
+//
+// Y_RescaleScreenBuffer
+//
+// Write the rescaled source picture,
+// to the destination picture that
+// has the current screen's resolutions.
+//
+static void Y_RescaleScreenBuffer(void)
+{
+ INT32 sx, sy; // source
+ INT32 dx, dy; // dest
+ fixed_t scalefac, yscalefac;
+ fixed_t rowfrac, colfrac;
+ UINT8 *dest;
+
+ // Who knows?
+ if (y_buffer == NULL)
+ return;
+
+ if (y_buffer->target_picture)
+ Z_Free(y_buffer->target_picture);
+
+ y_buffer->target_width = vid.width;
+ y_buffer->target_height = vid.height;
+ y_buffer->target_rowbytes = vid.rowbytes;
+ y_buffer->target_bpp = vid.bpp;
+ y_buffer->target_picture = ZZ_Alloc(y_buffer->target_width*vid.bpp * y_buffer->target_height);
+ dest = y_buffer->target_picture;
+
+ scalefac = FixedDiv(y_buffer->target_width*FRACUNIT, y_buffer->source_width*FRACUNIT);
+ yscalefac = FixedDiv(y_buffer->target_height*FRACUNIT, y_buffer->source_height*FRACUNIT);
+
+ rowfrac = FixedDiv(FRACUNIT, yscalefac);
+ colfrac = FixedDiv(FRACUNIT, scalefac);
+
+ for (sy = 0, dy = 0; sy < (y_buffer->source_height << FRACBITS) && dy < y_buffer->target_height; sy += rowfrac, dy++)
+ for (sx = 0, dx = 0; sx < (y_buffer->source_width << FRACBITS) && dx < y_buffer->target_width; sx += colfrac, dx += y_buffer->target_bpp)
+ dest[(dy * y_buffer->target_rowbytes) + dx] = y_buffer->source_picture[((sy>>FRACBITS) * y_buffer->source_width) + (sx>>FRACBITS)];
+}
+
+//
+// Y_CleanupScreenBuffer
+//
+// Free all related memory.
+//
+static void Y_CleanupScreenBuffer(void)
+{
+ // Who knows?
+ if (y_buffer == NULL)
+ return;
+
+ if (y_buffer->target_picture)
+ Z_Free(y_buffer->target_picture);
+
+ if (y_buffer->source_picture)
+ Z_Free(y_buffer->source_picture);
+
+ Z_Free(y_buffer);
+ y_buffer = NULL;
+}
+
//
// Y_IntermissionDrawer
//
@@ -232,32 +335,44 @@ void Y_IntermissionDrawer(void)
if (!usebuffer || !safetorender)
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
- if (safetorender)
+ if (!safetorender)
+ goto dontdrawbg;
+
+ if (useinterpic)
+ V_DrawScaledPatch(0, 0, 0, interpic);
+ else if (!usetile)
{
- if (useinterpic)
- V_DrawScaledPatch(0, 0, 0, interpic);
- else if (!usetile)
+ if (rendermode == render_soft && usebuffer)
{
- if (rendermode == render_soft && usebuffer)
+ // no y_buffer
+ if (y_buffer == NULL)
VID_BlitLinearScreen(screens[1], screens[0], vid.width*vid.bpp, vid.height, vid.width*vid.bpp, vid.rowbytes);
-#ifdef HWRENDER
- else if(rendermode != render_soft && usebuffer)
- {
- HWR_DrawIntermissionBG();
- }
-#endif
else
{
- if (widebgpatch && rendermode == render_soft && vid.width / vid.dupx == 400)
- V_DrawScaledPatch(0, 0, V_SNAPTOLEFT, widebgpatch);
- else
- V_DrawScaledPatch(0, 0, 0, bgpatch);
+ // Maybe the resolution changed?
+ if ((y_buffer->target_width != vid.width) || (y_buffer->target_height != vid.height))
+ Y_RescaleScreenBuffer();
+
+ // Blit the already-scaled screen buffer to the current screen
+ VID_BlitLinearScreen(y_buffer->target_picture, screens[0], vid.width*vid.bpp, vid.height, vid.width*vid.bpp, vid.rowbytes);
}
}
+#ifdef HWRENDER
+ else if (rendermode != render_soft && usebuffer)
+ HWR_DrawIntermissionBG();
+#endif
else
- V_DrawPatchFill(bgtile);
+ {
+ if (widebgpatch && rendermode == render_soft && vid.width / vid.dupx == 400)
+ V_DrawScaledPatch(0, 0, V_SNAPTOLEFT, widebgpatch);
+ else
+ V_DrawScaledPatch(0, 0, 0, bgpatch);
+ }
}
+ else
+ V_DrawPatchFill(bgtile);
+dontdrawbg:
if (intertype == int_coop)
{
INT32 bonusy;
@@ -439,11 +554,23 @@ void Y_IntermissionDrawer(void)
UINT8 continues = data.spec.continues & 0x7F;
V_DrawScaledPatch(152 + xoffset5, 150+yoffset, 0, data.spec.pcontinues);
- for (i = 0; i < continues; ++i)
+ if (continues > 5)
{
- if ((data.spec.continues & 0x80) && i == continues-1 && (endtic < 0 || intertic%20 < 10))
- break;
- V_DrawContinueIcon(246 + xoffset5 - (i*20), 162+yoffset, 0, *data.spec.playerchar, *data.spec.playercolor);
+ INT32 leftx = (continues >= 10) ? 216 : 224;
+ V_DrawContinueIcon(leftx + xoffset5, 162+yoffset, 0, *data.spec.playerchar, *data.spec.playercolor);
+ V_DrawScaledPatch(leftx + xoffset5 + 12, 160+yoffset, 0, stlivex);
+ if (!((data.spec.continues & 0x80) && !(endtic < 0 || intertic%20 < 10)))
+ V_DrawRightAlignedString(252 + xoffset5, 158+yoffset, 0,
+ va("%d",(((data.spec.continues & 0x80) && (endtic < 0)) ? continues-1 : continues)));
+ }
+ else
+ {
+ for (i = 0; i < continues; ++i)
+ {
+ if ((data.spec.continues & 0x80) && i == continues-1 && (endtic < 0 || intertic%20 < 10))
+ break;
+ V_DrawContinueIcon(246 + xoffset5 - (i*20), 162+yoffset, 0, *data.spec.playerchar, *data.spec.playercolor);
+ }
}
}
}
@@ -818,6 +945,10 @@ void Y_Ticker(void)
if (paused || P_AutoPause())
return;
+#ifdef HAVE_BLUA
+ LUAh_IntermissionThinker();
+#endif
+
intertic++;
// Team scramble code for team match and CTF.
@@ -1063,6 +1194,9 @@ static void Y_UpdateRecordReplays(void)
if ((UINT16)(players[consoleplayer].rings) > mainrecords[gamemap-1]->rings)
mainrecords[gamemap-1]->rings = (UINT16)(players[consoleplayer].rings);
+ if (data.coop.gotperfbonus)
+ mainrecords[gamemap-1]->gotperfect = true;
+
// Save demo!
bestdemo[255] = '\0';
lastdemo[255] = '\0';
@@ -2016,7 +2150,7 @@ static void Y_AwardSpecialStageBonus(void)
data.spec.score = players[consoleplayer].score;
memset(data.spec.bonuses, 0, sizeof(data.spec.bonuses));
- memset(data.spec.bonuspatches, 0, sizeof(data.coop.bonuspatches));
+ memset(data.spec.bonuspatches, 0, sizeof(data.spec.bonuspatches));
for (i = 0; i < MAXPLAYERS; i++)
{
@@ -2107,6 +2241,8 @@ static void Y_UnloadData(void)
if (rendermode != render_soft)
return;
+ Y_CleanupScreenBuffer();
+
// unload the background patches
UNLOAD(bgpatch);
UNLOAD(widebgpatch);
diff --git a/src/y_inter.h b/src/y_inter.h
index 4c6ad2bdfcfeaff454fffb1ecfc0075f421705dc..ccb48dbd4c3ed5cd43273a3971724bb9b6c897b7 100644
--- a/src/y_inter.h
+++ b/src/y_inter.h
@@ -15,6 +15,7 @@ void Y_IntermissionDrawer(void);
void Y_Ticker(void);
void Y_StartIntermission(void);
void Y_EndIntermission(void);
+void Y_ConsiderScreenBuffer(void);
typedef enum
{
diff --git a/src/z_zone.c b/src/z_zone.c
index ce38947cb3a9a0565c429c33a7eb20f0285e6dce..1824adc06655500cb94fe26fbcc6afb8cf6da6b9 100644
--- a/src/z_zone.c
+++ b/src/z_zone.c
@@ -247,7 +247,11 @@ void Z_Free(void *ptr)
static void *xm(size_t size)
{
const size_t padedsize = size+sizeof (size_t);
- void *p = malloc(padedsize);
+ void *p;
+
+ if (padedsize < size)/* overflow check */
+ I_Error("You are allocating memory too large!");
+ p = malloc(padedsize);
if (p == NULL)
{
@@ -295,6 +299,9 @@ void *Z_MallocAlign(size_t size, INT32 tag, void *user, INT32 alignbits)
CONS_Debug(DBG_MEMORY, "Z_Malloc %s:%d\n", file, line);
#endif
+ if (blocksize < size)/* overflow check */
+ I_Error("You are allocating memory too large!");
+
block = xm(sizeof *block);
#ifdef HAVE_VALGRIND
padsize += (1<<sizeof(size_t))*2;
diff --git a/tools/flatb/Makefile b/tools/flatb/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..2134973e68099497121ed8d79526e83549897163
--- /dev/null
+++ b/tools/flatb/Makefile
@@ -0,0 +1,9 @@
+.PHONY : all clean
+
+all : flatb
+
+flatb.exe : flatb.c
+ i686-w64-mingw32-gcc $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) $(LDLIBS) -o $@ $<
+
+clean :
+ $(RM) flatb flatb.exe
diff --git a/tools/flatb/flatb.c b/tools/flatb/flatb.c
new file mode 100644
index 0000000000000000000000000000000000000000..edc0892324d3728da88a6aad7d98738547c8c37b
--- /dev/null
+++ b/tools/flatb/flatb.c
@@ -0,0 +1,566 @@
+#define HELP \
+"Usage: flatb WAD-file list-file" "\n"\
+"Replace flats and textures by name in a DOOM WAD." "\n"\
+"\n"\
+"list-file may have the following format:" "\n"\
+"\n"\
+"GFZFLR01 GFZFLR02" "\n"\
+"# Comment" "\n"\
+"GFZROCK GFZBLOCK" "\n"\
+"\n"\
+"The first name and second name may be delimited by any whitespace." "\n"\
+"\n"\
+"Copyright 2019 James R." "\n"\
+"All rights reserved." "\n"
+
+/*
+Copyright 2019 James R.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+
+#define cchar const char
+#define cvoid const void
+
+#define LONG int32_t
+
+#define va_inline( __ap,__last, ... )\
+(\
+ va_start (__ap,__last),\
+ __VA_ARGS__,\
+ va_end (__ap)\
+)
+
+#define DELIM "\t\n\r "
+
+typedef struct
+{
+ FILE * fp;
+ cchar * filename;
+}
+File;
+
+int (*le32)(cvoid *);
+
+void
+Pexit (int c, cchar *s, ...)
+{
+ va_list ap;
+ va_inline (ap, s,
+
+ vfprintf(stderr, s, ap)
+
+ );
+ exit(c);
+}
+
+void
+Prexit (cchar *pr, ...)
+{
+ va_list ap;
+ va_inline (ap, pr,
+
+ vfprintf(stderr, pr, ap)
+
+ );
+ perror("");
+ exit(-1);
+}
+
+void
+Fopen (File *f, cchar *filename, const char *mode)
+{
+ FILE *fp;
+ if (!( fp = fopen(filename, mode) ))
+ Prexit("%s", filename);
+ f->filename = filename;
+ f->fp = fp;
+}
+
+void
+Ferr (File *f)
+{
+ if (ferror(f->fp))
+ Prexit("%s", f->filename);
+}
+
+char *
+Fgets (File *f, int b, char *p)
+{
+ if (!( p = fgets(p, b, f->fp) ))
+ Ferr(f);
+ return p;
+}
+
+void
+Fread (File *f, int b, void *p)
+{
+ if (fread(p, 1, b, f->fp) < b)
+ Ferr(f);
+}
+
+void
+Fwrite (File *f, int b, cvoid *s)
+{
+ if (fwrite(s, 1, b, f->fp) < b)
+ Ferr(f);
+}
+
+void
+Fseek (File *f, long o)
+{
+ if (fseek(f->fp, o, SEEK_SET) == -1)
+ Prexit("%s", f->filename);
+}
+
+void *
+Malloc (int b)
+{
+ void *p;
+ if (!( p = malloc(b) ))
+ Prexit("%d", b);
+ return p;
+}
+
+void *
+Calloc (int c, int b)
+{
+ void *p;
+ if (!( p = calloc(c, b) ))
+ Prexit("(%d)%d", c, b);
+ return p;
+}
+
+void
+Reallocp (void *pp, int b)
+{
+ void *p;
+ if (!( p = realloc((*(void **)pp), b) ))
+ Prexit("%d", b);
+ (*(void **)pp) = p;
+}
+
+void
+strucpy (char *p, cchar *s, int n)
+{
+ int c;
+ int i;
+ for (i = 0; i < n && ( c = s[i] ); ++i)
+ p[i] = toupper(c);
+}
+
+int
+e32 (cvoid *s)
+{
+ unsigned int c;
+ c = *(LONG *)s;
+ return (
+ ( c >> 24 ) |
+ (( c >> 8 )& 0x00FF00 )|
+ (( c << 8 )& 0xFF0000 )|
+ ( c << 24 )
+ );
+}
+
+int
+n32 (cvoid *s)
+{
+ return *(LONG *)s;
+}
+
+void
+Ie ()
+{
+ int c;
+ c = 1;
+ if (*(char *)&c == 1)
+ le32 = n32;
+ else
+ le32 = e32;
+}
+
+File wad_file;
+File list_file;
+
+int list_c;
+char *** list_v;
+
+char * directory;
+char * lump;
+int lumpsize;
+
+char * sectors;
+int sectors_c;
+
+char * sides;
+int sides_c;
+
+int st_floors;
+int st_ceilings;
+int st_sectors;
+
+int st_sides;
+int st_uppers;
+int st_mids;
+int st_lowers;
+
+/* this is horseshit */
+char * old;
+char * new;
+int did;
+
+void
+Itable ()
+{
+ char a[1024];
+
+ char ***ttt;
+ char ***ppp;
+
+ char **pp;
+
+ int c;
+
+ while (Fgets(&list_file, sizeof a, a))
+ {
+ c = a[0];
+ if (!(
+ c == '\n' ||
+ c == '#'
+ ))
+ {
+ list_c++;
+ }
+ }
+
+ rewind(list_file.fp);
+
+ list_v = Calloc(list_c, sizeof (char **));
+ for (
+ ttt = ( ppp = list_v ) + list_c;
+ ppp < ttt;
+ ++ppp
+ )
+ {
+ (*ppp) = pp = Calloc(2, sizeof (char *));
+ pp[0] = Malloc(9);
+ pp[1] = Malloc(9);
+ }
+}
+
+void
+Iwad ()
+{
+ char buf[12];
+
+ char * t;
+ char * p;
+ int map;
+
+ char *sector_p;
+ char * side_p;
+
+ int n;
+ int h;
+
+ Fread(&wad_file, 12, buf);
+ if (
+ memcmp(buf, "IWAD", 4) != 0 &&
+ memcmp(buf, "PWAD", 4) != 0
+ )
+ {
+ Pexit(-1,"%s: Not a WAD\n", wad_file.filename);
+ }
+
+ Fseek(&wad_file, (*le32)(&buf[8]));
+
+ n = (*le32)(&buf[4]) * 8;
+ h = n / 9;
+ n *= 2;
+ directory = Malloc(n);
+ /* minimum number of lumps for a map */
+ sectors = Malloc(h);
+ sides = Malloc(h);
+
+ Fread(&wad_file, n, directory);
+
+ sector_p = sectors;
+ side_p = sides;
+ map = 3;
+ for (t = ( p = directory ) + n; p < t; p += 16)
+ {
+ /* looking for SECTORS? Hopefully order doesn't matter in real world. */
+ /* also search for fucking SIDES MY SIDES AAAAAAAAAA */
+ switch (map)
+ {
+ case 0:
+ case 2:
+ if (strncmp(&p[8], "SECTORS", 8) == 0)
+ {
+ /* copy file offset and size */
+ memcpy(sector_p, p, 8);
+ sector_p += 8;
+ sectors_c++;
+ map |= 1;
+ }
+ case 1:
+ if (strncmp(&p[8], "SIDEDEFS", 8) == 0)
+ {
+ memcpy(side_p, p, 8);
+ side_p += 8;
+ sides_c++;
+ map |= 2;
+ }
+ }
+ if (map == 3)
+ {
+ /* MAP marker */
+ if (p[13] == '\0' && strncmp(&p[8], "MAP", 3) == 0)
+ map = 0;
+ }
+ }
+}
+
+void
+Fuckyou (char *p, int f, int *st)
+{
+ if (strncmp(p, old, 8) == 0)
+ {
+ strncpy(p, new, 8);
+ (*st)++;
+ did |= f;
+ }
+}
+
+void
+Epic (char *p, char *t)
+{
+ char *top;
+ char *bot;
+ int i;
+ /* oh hi magic number! */
+ for (; p < t; p += 26)
+ {
+ bot = &p [4];
+ top = &p[12];
+ did = 0;
+ for (i = 0; i < list_c; ++i)
+ {
+ old = list_v[i][0];
+ new = list_v[i][1];
+ switch (did)
+ {
+ case 0:
+ case 2:
+ Fuckyou(bot, 1, &st_floors);
+ case 1:
+ Fuckyou(top, 2, &st_ceilings);
+ }
+ if (did == 3)
+ break;
+ }
+ if (did)
+ st_sectors++;
+ }
+}
+
+void
+Epic2 (char *p, char *t)
+{
+ char *top;
+ char *mid;
+ char *bot;
+ int i;
+ for (; p < t; p += 30)
+ {
+ top = &p [4];
+ bot = &p[12];
+ mid = &p[20];
+ did = 0;
+ for (i = 0; i < list_c; ++i)
+ {
+ old = list_v[i][0];
+ new = list_v[i][1];
+ switch (did)
+ {
+ case 0:
+ case 2:
+ case 4:
+ case 6:
+ Fuckyou(top, 1, &st_uppers);
+ case 1:
+ case 5:
+ Fuckyou(mid, 2, &st_mids);
+ case 3:
+ Fuckyou(bot, 4, &st_lowers);
+ }
+ if (did == 7)
+ break;
+ }
+ if (did)
+ st_sides++;
+ }
+}
+
+void
+Fuck (char *p, int c, void (*fn)(char *,char *))
+{
+ char *t;
+ int offs;
+ int size;
+ for (t = p + c * 8; p < t; p += 8)
+ {
+ offs = (*le32)(p);
+ size = (*le32)(p + 4);
+ if (lumpsize < size)
+ {
+ Reallocp(&lump, size);
+ lumpsize = size;
+ }
+ Fseek(&wad_file, offs);
+ Fread(&wad_file, size, lump);
+ (*fn)(lump, lump + size);
+ Fseek(&wad_file, offs);
+ Fwrite(&wad_file, size, lump);
+ }
+}
+
+void
+Awad ()
+{
+ Fuck (sectors, sectors_c, Epic);
+ Fuck (sides, sides_c, Epic2);
+}
+
+void
+Readtable ()
+{
+ char a[1024];
+
+ int s;
+ char *old;
+ char *new;
+
+ int c;
+
+ s = 0;
+
+ while (Fgets(&list_file, sizeof a, a))
+ {
+ c = a[0];
+ if (!(
+ c == '\n' ||
+ c == '#'
+ ))
+ {
+ if (
+ ( old = strtok(a, DELIM) ) &&
+ ( new = strtok(0, DELIM) )
+ )
+ {
+ strucpy(list_v[s][0], old, 8);
+ strucpy(list_v[s][1], new, 8);
+ ++s;
+ }
+ }
+ }
+}
+
+void
+Cleanup ()
+{
+ char ***ttt;
+ char ***ppp;
+
+ char **pp;
+
+ free(lump);
+ free(sides);
+ free(sectors);
+ free(directory);
+
+ if (list_v)
+ {
+ for (
+ ttt = ( ppp = list_v ) + list_c;
+ ppp < ttt && ( pp = (*ppp) );
+ ++ppp
+ )
+ {
+ free(pp[0]);
+ free(pp[1]);
+ free(pp);
+ }
+ free(list_v);
+ }
+}
+
+int
+main (int ac, char **av)
+{
+ int n;
+
+ if (ac < 3)
+ Pexit(0,HELP);
+
+ Fopen (& wad_file, av[1], "rb+");
+ Fopen (&list_file, av[2], "r");
+
+ if (atexit(Cleanup) != 0)
+ Pexit(-1,"Failed to register cleanup function.\n");
+
+ Itable();
+ Readtable();
+
+ Ie();
+
+ Iwad();
+ Awad();
+
+ printf(
+ "%5d sectors changed.\n"
+ "%5d floors.\n"
+ "%5d ceilings.\n"
+ "\n"
+ "%5d sides.\n"
+ "%5d upper textures.\n"
+ "%5d mid textures.\n"
+ "%5d lower textures.\n",
+
+ st_sectors,
+
+ st_floors,
+ st_ceilings,
+
+ st_sides,
+
+ st_uppers,
+ st_mids,
+ st_lowers);
+
+ return 0;
+}