diff --git a/extras/conf/Includes/Game_SRB222.cfg b/extras/conf/Includes/Game_SRB222.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3c4b11e9f301f90b68a5ee90c366416048946b73
--- /dev/null
+++ b/extras/conf/Includes/Game_SRB222.cfg
@@ -0,0 +1,77 @@
+// Default lump name for new map
+defaultlumpname = "MAP01";
+//GZDB specific. Don't try to load lumps that don't exist.
+basegame = 0;
+
+//Sky textures for vanilla maps
+defaultskytextures
+{
+ SKY1 = "MAP01,MAP02,MAP03,MAP33,MAP50,MAP60,MAPF0,MAPM0";
+ SKY2 = "MAPM7,MAPMB";
+ SKY4 = "MAP04,MAP06,MAP61,MAPF6,MAPM1";
+ SKY6 = "MAP05,MAP51,MAPMA";
+ SKY7 = "MAPM2,MAPM5";
+ SKY8 = "MAP07,MAP08,MAP09,MAP52,MAP62,MAPF1";
+ SKY10 = "MAP10,MAP12,MAP53,MAP63,MAPM3";
+ SKY11 = "MAP11,MAPF7";
+ SKY13 = "MAP13,MAP64";
+ SKY14 = "MAP14";
+ SKY15 = "MAP15,MAP54";
+ SKY17 = "MAP70";
+ SKY20 = "MAP32,MAP55,MAP65,MAPF2,MAPF5";
+ SKY21 = "MAPM4";
+ SKY22 = "MAP22,MAP23,MAP25,MAP26,MAP27,MAP56,MAP66,MAPF4,MAPM6";
+ SKY30 = "MAP30";
+ SKY31 = "MAP31";
+ SKY35 = "MAP42";
+ SKY40 = "MAP41,MAP71,MAPM9";
+ SKY55 = "MAPF3,MAPM8";
+ SKY68 = "MAPF8";
+ SKY99 = "MAP57,MAPZ0";
+ SKY159 = "MAP16";
+ SKY172 = "MAP40";
+ SKY300 = "MAP72";
+ SKY301 = "MAP73";
+}
+
+// Skill levels
+skills
+{
+ 1 = "Normal";
+}
+
+// Skins
+skins
+{
+ Sonic;
+ Tails;
+ Knuckles;
+ Amy;
+ Fang;
+ Metalsonic;
+}
+
+// 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";
+}
+
+// Texture loading options
+defaultwalltexture = "GFZROCK";
+defaultfloortexture = "GFZFLR01";
+defaultceilingtexture = "F_SKY1";
+
+// Default texture sets
+// (these are not required, but useful for new users)
+texturesets
+{
+}
\ No newline at end of file
diff --git a/extras/conf/Includes/SRB222_common.cfg b/extras/conf/Includes/SRB222_common.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a832e6cefe6c2ba1580cbd48083bcf1c2702da81
--- /dev/null
+++ b/extras/conf/Includes/SRB222_common.cfg
@@ -0,0 +1,309 @@
+common
+{
+ // Some common settings
+
+
+
+ // Default testing parameters
+ testparameters = "-file \"%AP\" \"%F\" -warp %L";
+ testshortpaths = true;
+
+ // Action special help (mxd)
+ actionspecialhelp = "https://wiki.srb2.org/wiki/Linedef_type_%K";
+
+ // Default nodebuilder configurations
+ defaultsavecompiler = "zennode_normal";
+ defaulttestcompiler = "zennode_fast";
+
+ // Generalized actions
+ generalizedlinedefs = false;
+ generalizedsectors = true;
+
+ mixtexturesflats = true;
+ defaulttexturescale = 1.0f;
+ defaultflatscale = 1.0f;
+ scaledtextureoffsets = true;
+
+ // Thing number for start position in 3D Mode
+ start3dmode = 3328;
+
+ // Texture sources
+ textures
+ {
+ include("SRB222_misc.cfg", "textures");
+ }
+
+ // Patch sources
+ patches
+ {
+ include("SRB222_misc.cfg", "patches");
+ }
+
+ // Sprite sources
+ sprites
+ {
+ include("SRB222_misc.cfg", "sprites");
+ }
+
+ // Flat sources
+ flats
+ {
+ include("SRB222_misc.cfg", "flats");
+ }
+}
+
+mapformat_doom
+{
+ // The format interface handles the map data format - DoomMapSetIO for SRB2DB2, SRB2MapSetIO for Zone Builder
+ formatinterface = "SRB2MapSetIO";
+
+ /*
+ 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
+ {
+ include("SRB222_misc.cfg", "doommaplumpnames");
+ }
+
+ // When this is set to true, sectors with the same tag will light up when a line is highlighted
+ linetagindicatesectors = true;
+
+ // Special linedefs
+ include("SRB222_misc.cfg", "speciallinedefs");
+
+ // Default flags for first new thing (As far as 2.2 goes, they're empty just like in 2.1)
+ defaultthingflags
+ {
+ }
+
+ // DEFAULT SECTOR BRIGHTNESS LEVELS
+ sectorbrightness
+ {
+ include("SRB222_misc.cfg", "sectorbrightness");
+ }
+
+ // SECTOR TYPES-----------------------------------------------------------------
+ sectortypes
+ {
+ include("SRB222_sectors.cfg", "sectortypes");
+ }
+
+ // GENERALISED SECTOR TYPES-----------------------------------------------------------------
+ gen_sectortypes
+ {
+ include("SRB222_sectors.cfg", "gen_sectortypes");
+ }
+
+ // LINEDEF FLAGS
+ linedefflags
+ {
+ include("SRB222_misc.cfg", "linedefflags");
+ }
+
+ // 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
+ {
+ include("SRB222_misc.cfg", "linedefflagstranslation");
+ }
+
+ // LINEDEF ACTIVATIONS
+ linedefactivations
+ {
+ }
+
+ // LINEDEF TYPES
+ linedeftypes
+ {
+ include("SRB222_linedefs.cfg", "doom");
+ }
+
+ // THING FLAGS
+ thingflags
+ {
+ include("SRB222_misc.cfg", "thingflags");
+ }
+
+ // 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
+ {
+ include("SRB222_misc.cfg", "thingflagstranslation");
+ }
+
+ // 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;
+}
+
+mapformat_udmf
+{
+ // The format interface handles the map data format
+ formatinterface = "UniversalMapSetIO";
+
+ // Enables support for long (> 8 chars) texture names
+ // WARNING: this should only be enabled for UDMF game configurations!
+ // WARNING: enabling this will make maps incompatible with Doom Builder 2 and can lead to problems in Slade 3!
+ longtexturenames = false;
+
+ // Default nodebuilder configurations
+ defaultsavecompiler = "zdbsp_udmf_normal";
+ defaulttestcompiler = "zdbsp_udmf_fast";
+
+ engine = "srb2"; // override that so that DB2 uses the correct namespace
+
+ maplumpnames
+ {
+ include("UDMF_misc.cfg", "udmfmaplumpnames_begin");
+ include("SRB222_misc.cfg", "udmfmaplumpnames");
+ include("UDMF_misc.cfg", "udmfmaplumpnames_end");
+ }
+
+ universalfields
+ {
+// include("SRB222_misc.cfg", "universalfields");
+ }
+
+ // When this is set to true, sectors with the same tag will light up when a line is highlighted
+ linetagindicatesectors = false;
+
+ // Special linedefs
+ include("SRB222_misc.cfg", "speciallinedefs_udmf");
+
+ // Default flags for first new thing (As far as 2.2 goes, they're empty just like in 2.1)
+ defaultthingflags
+ {
+ }
+
+ // Generalized actions
+ generalizedlinedefs = false;
+
+ // SECTOR FLAGS
+ sectorflags
+ {
+// include("SRB222_misc.cfg", "sectorflags");
+ }
+
+ // DEFAULT SECTOR BRIGHTNESS LEVELS
+ sectorbrightness
+ {
+ include("SRB222_misc.cfg", "sectorbrightness");
+ }
+
+ // SECTOR TYPES
+ sectortypes
+ {
+ include("SRB222_sectors.cfg", "sectortypes");
+ }
+
+ // SECTOR RENSERSTYLES
+/* sectorrenderstyles
+ {
+ include("SRB222_misc.cfg", "sectorrenderstyles");
+ }*/
+
+ // LINEDEF FLAGS
+ linedefflags
+ {
+ include("SRB222_misc.cfg", "linedefflags_udmf");
+ }
+
+ // LINEDEF ACTIVATIONS
+ linedefactivations
+ {
+ include("SRB222_misc.cfg", "linedefactivations_udmf");
+ }
+
+ linedefflagstranslation
+ {
+ }
+
+
+ // LINEDEF RENSERSTYLES
+ linedefrenderstyles
+ {
+ include("SRB222_misc.cfg", "linedefrenderstyles");
+ }
+
+ //SIDEDEF FLAGS
+/* sidedefflags
+ {
+ include("UDMF_misc.cfg", "sidedefflags");
+ }*/
+
+ // THING FLAGS
+ thingflags
+ {
+ include("SRB222_misc.cfg", "thingflags_udmf");
+ }
+
+ // 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
+ {
+ include("SRB222_misc.cfg", "thingflagstranslation");
+ }
+
+ // THING RENSERSTYLES
+/* thingrenderstyles
+ {
+ include("SRB222_misc.cfg", "thingrenderstyles");
+ }*/
+
+ // How to compare thing flags (for the stuck things error checker)
+/* thingflagscompare
+ {
+ include("UDMF_misc.cfg", "thingflagscompare");
+ }*/
+
+ //mxd. 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
+ {
+ }
+
+ // LINEDEF TYPES
+ linedeftypes
+ {
+ include("SRB222_linedefs.cfg", "udmf");
+ }
+}
\ No newline at end of file
diff --git a/extras/conf/Includes/SRB222_linedefs.cfg b/extras/conf/Includes/SRB222_linedefs.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fdf1918502a582abebe398e2ecb7bc8c98db442e
--- /dev/null
+++ b/extras/conf/Includes/SRB222_linedefs.cfg
@@ -0,0 +1,2486 @@
+doom
+{
+ 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 end item";
+ flags256text = "[8] Spawn link 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";
+ }
+
+ 462
+ {
+ title = "Stop Timer/Exit Stage in Record Attack";
+ prefix = "(462)";
+ }
+ }
+
+ 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)";
+ }
+ }
+}
+
+udmf
+{
+ misc
+ {
+ title = "Miscellaneous";
+
+ 0
+ {
+ title = "None";
+ prefix = "(0)";
+ }
+ }
+}
\ No newline at end of file
diff --git a/extras/conf/Includes/SRB222_misc.cfg b/extras/conf/Includes/SRB222_misc.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ce23388b2362094d097ff3893a106e6664a0b255
--- /dev/null
+++ b/extras/conf/Includes/SRB222_misc.cfg
@@ -0,0 +1,726 @@
+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 ACTIVATIONS
+// Make sure these are in order from lowest value to highest value
+linedefactivations
+{
+}
+
+
+// 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 = "skewtd";
+ 64 = "noclimb";
+ 128 = "noskew";
+ 256 = "midpeg";
+ 512 = "midsolid";
+ 1024 = "wrapmidtex";
+ 2048 = "netonly";
+ 4096 = "nonet";
+ 8192 = "effect6";
+ 16384 = "bouncy";
+ 32768 = "transfer";
+}
+
+
+linedefflags_udmf
+{
+ blocking = "Impassable";
+ blockmonsters = "Block Enemies";
+ twosided = "Double-Sided";
+ dontpegtop = "Upper Unpegged";
+ dontpegbottom = "Lower Unpegged";
+ skewtd = "Slope Skew";
+ noclimb = "Not Climbable";
+ noskew = "No Midtexture Skew";
+ midpeg = "Peg Midtexture";
+ midsolid = "Solid Midtexture";
+ wrapmidtex = "Repeat Midtexture";
+// netonly = "Netgame-Only special";
+// nonet = "No netgame special";
+// effect6 = "Effect 6";
+ bouncy = "Bouncy Wall";
+// transfer = "Transfer Line";
+}
+
+
+linedefactivations_udmf
+{
+ notriggerorder = "Out of Order";
+ netonly = "Netgame-Only";
+ nonet = "No netgame";
+}
+
+sidedefflags
+{
+ clipmidtex = "Clip middle texture";
+ wrapmidtex = "Wrap middle texture";
+ smoothlighting = "Smooth lighting";
+ nofakecontrast = "Even lighting";
+ nodecals = "No decals";
+ lightfog = "Use sidedef brightness on fogged walls";
+}
+
+//RENDER STYLES
+thingrenderstyles
+{
+}
+
+linedefrenderstyles
+{
+ translucent = "Translucent";
+ fog = "Fog";
+}
+
+sectorrenderstyles
+{
+}
+
+thingflags
+{
+ 1 = "[1] Extra";
+ 2 = "[2] Flip";
+ 4 = "[4] Special";
+ 8 = "[8] Ambush";
+}
+
+// THING FLAGS
+thingflags_udmf
+{
+ extra = "Extra";
+ flip = "Flip";
+ special = "Special";
+ ambush = "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 = "extra";
+ 2 = "flip";
+ 4 = "special";
+ 8 = "ambush";
+}
+
+
+// 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;
+}
+
+/*
+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.
+*/
+textures
+{
+ zdoom1
+ {
+ start = "TX_START";
+ end = "TX_END";
+ }
+}
+
+/*
+ADDITIONAL UNIVERSAL DOOM MAP FORMAT FIELD DEFINITIONS
+Only add fields here that Doom Builder does not edit with its own user-interface!
+The "default" field must match the UDMF specifications!
+
+Field data types:
+0 = integer *
+1 = float
+2 = string
+3 = bool
+4 = linedef action (integer) *
+5 = sector effect (integer) *
+6 = texture (string)
+7 = flat (string)
+8 = angle in degrees (integer)
+9 = angle in radians (float)
+10 = XXRRGGBB color (integer)
+11 = enum option (integer) *
+12 = enum bits (integer) *
+13 = sector tag (integer) *
+14 = thing tag (integer) *
+15 = linedef tag (integer) *
+16 = enum option (string)
+17 = angle in degrees (float)
+22 = byte angle (integer)
+*/
+universalfields
+{
+ sector
+ {
+ friction
+ {
+ name = "Friction";
+ type = 1;
+ default = 1;
+ }
+
+ specialeffectplanes
+ {
+ type = 11;
+ enum = "floorceiling";
+ default = 0;
+ }
+
+ colormapbegin
+ {
+ type = 0;
+ default = 0;
+ }
+
+ colormapend
+ {
+ type = 0;
+ default = 33;
+ }
+
+ foglighting
+ {
+ type = 3;
+ default = false;
+ }
+
+ teambase
+ {
+ type = 11;
+ enum = "ctfteam";
+ default = 0;
+ }
+
+ triggersector
+ {
+ type = 3;
+ default = false;
+ }
+
+ triggerobject
+ {
+ type = 11;
+ enum = "triggerobjects";
+ default = 0;
+ }
+
+ triggersurface
+ {
+ type = 11;
+ enum = "triggersurfaces";
+ default = 0;
+ }
+
+ ringdrain
+ {
+ type = 1;
+ default = 0;
+ }
+ }
+
+ linedef
+ {
+ executordelay
+ {
+ type = 0;
+ default = 0;
+ }
+ midtexrepetitions
+ {
+ type = 0;
+ default = 0;
+ }
+ arg5
+ {
+ type = 0;
+ default = 0;
+ }
+ arg1str
+ {
+ type = 2;
+ default = "";
+ }
+ }
+
+ thing
+ {
+ }
+}
+
+/*
+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. (useful for lumps Doom Builder doesn't use)
+nodebuild = The nodebuilder generates this lump.
+allowempty = The nodebuilder is allowed to leave this lump empty.
+scriptbuild = This lump is a text-based script, which should be compiled using current script compiler;
+script = This lump is a text-based script. Specify the filename of the script configuration to use.
+*/
+
+doommaplumpnames
+{
+ ~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;
+ }
+}
+
+udmfmaplumpnames
+{
+ ZNODES
+ {
+ required = false;
+ nodebuild = true;
+ allowempty = false;
+ }
+
+ REJECT
+ {
+ required = false;
+ nodebuild = true;
+ allowempty = false;
+ }
+
+ BLOCKMAP
+ {
+ required = false;
+ nodebuild = true;
+ allowempty = true;
+ }
+}
+
+// ENUMERATIONS
+// These are enumerated lists for linedef types and UDMF fields.
+// Reserved names are: angledeg, anglerad, color, texture, flat
+enums
+{
+ falsetrue
+ {
+ 0 = "False";
+ 1 = "True";
+ }
+
+ yesno
+ {
+ 0 = "Yes";
+ 1 = "No";
+ }
+
+ noyes
+ {
+ 0 = "No";
+ 1 = "Yes";
+ }
+
+ onoff
+ {
+ 0 = "On";
+ 1 = "Off";
+ }
+
+ offon
+ {
+ 0 = "Off";
+ 1 = "On";
+ }
+
+ updown
+ {
+ 0 = "Up";
+ 1 = "Down";
+ }
+
+ downup
+ {
+ 0 = "Down";
+ 1 = "Up";
+ }
+
+ addset
+ {
+ 0 = "Add";
+ 1 = "Set";
+ }
+
+ floorceiling
+ {
+ 0 = "Floor";
+ 1 = "Ceiling";
+ 2 = "Floor and ceiling";
+ }
+
+ triggertype
+ {
+ 0 = "Continuous";
+ 1 = "Each Time (Enter)";
+ 2 = "Each Time (Enter and leave)";
+ 3 = "Once";
+ }
+
+ frontback
+ {
+ 0 = "None";
+ 1 = "Front";
+ 2 = "Back";
+ }
+
+ ctfteam
+ {
+ 0 = "None";
+ 1 = "Red";
+ 2 = "Blue";
+ }
+
+ triggerobjects
+ {
+ 0 = "Any player";
+ 1 = "All players";
+ 2 = "Pushable object";
+ 3 = "Any object with thinker";
+ }
+
+ triggersurfaces
+ {
+ 0 = "Floor touch";
+ 1 = "Ceiling touch";
+ 2 = "Floor or ceiling touch";
+ 3 = "Anywhere in sector";
+ }
+
+ tangibility
+ {
+ 1 = "Intangible from top";
+ 2 = "Intangible from bottom";
+ 4 = "Don't block players";
+ 8 = "Don't block non-players";
+ }
+}
+
+//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;
+ }
+
+ }
+}
+
+thingsfilters_udmf
+{
+}
+
+// Special linedefs
+speciallinedefs
+{
+ soundlinedefflag = 64; // See linedefflags
+ singlesidedflag = 1; // See linedefflags
+ doublesidedflag = 4; // See linedefflags
+ impassableflag = 1;
+ upperunpeggedflag = 8;
+ lowerunpeggedflag = 16;
+ repeatmidtextureflag = 1024;
+ pegmidtextureflag = 256;
+}
+
+speciallinedefs_udmf
+{
+ soundlinedefflag = "noclimb";
+ singlesidedflag = "blocking";
+ doublesidedflag = "twosided";
+ impassableflag = "blocking";
+ upperunpeggedflag = "dontpegtop";
+ lowerunpeggedflag = "dontpegbottom";
+ repeatmidtextureflag = "wrapmidtex";
+ pegmidtextureflag = "midpeg";
+}
+
+scriptlumpnames
+{
+ MAINCFG
+ {
+ script = "SOC.cfg";
+ }
+
+ OBJCTCFG
+ {
+ script = "SOC.cfg";
+ }
+
+ SOC_
+ {
+ script = "SOC.cfg";
+ isprefix = true;
+ }
+
+ LUA_
+ {
+ script = "Lua.cfg";
+ isprefix = true;
+ }
+}
+
+// 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";
+ }
+}
\ No newline at end of file
diff --git a/extras/conf/Includes/SRB222_sectors.cfg b/extras/conf/Includes/SRB222_sectors.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..3bcbeb1b14d8ac6466f79e888a5be7ef3aa9bc24
--- /dev/null
+++ b/extras/conf/Includes/SRB222_sectors.cfg
@@ -0,0 +1,109 @@
+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";
+}
+
+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";
+ }
+}
\ No newline at end of file
diff --git a/extras/conf/Includes/SRB222_things.cfg b/extras/conf/Includes/SRB222_things.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..194e43630b70f5f98b6a3963b4b27371c85d2e02
--- /dev/null
+++ b/extras/conf/Includes/SRB222_things.cfg
@@ -0,0 +1,3398 @@
+// 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
+
+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 = "Lance-a-Bot";
+ sprite = "CBFSA1";
+ width = 32;
+ height = 72;
+ }
+ 1113
+ {
+ title = "Suspicious Lance-a-Bot 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 = "MNUSA0";
+ 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";
+ }
+ 137
+ {
+ title = "Dragonbomber";
+ sprite = "DRABA1";
+ width = 28;
+ height = 48;
+ }
+ 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;
+ flags1text = "[1] No origin-fling death";
+ 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 = 0;
+ height = 0;
+ sprite = "UNKNA0";
+ sort = 1;
+ fixedsize = true;
+ blocking = 0;
+
+ 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;
+ flags1text = "[1] Solid gold";
+ 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 = "Lance-a-Bot 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;
+ }
+ 1505
+ {
+ title = "Green Flame";
+ sprite = "CFLMA0E0";
+ width = 8;
+ height = 32;
+ }
+ 1506
+ {
+ arrow = 1;
+ blocking = 2;
+ title = "Blue Gargoyle";
+ sprite = "BGARD1";
+ width = 16;
+ height = 40;
+ flags4text = "[4] Slides when pushed";
+ flags8text = "[8] Not pushable";
+ }
+}
+
+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";
+ }
+}
\ No newline at end of file
diff --git a/extras/conf/SRB2_22Doom.cfg b/extras/conf/SRB2_22Doom.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..65e49d3871be87df0c3eb20831543a3304191d1d
--- /dev/null
+++ b/extras/conf/SRB2_22Doom.cfg
@@ -0,0 +1,38 @@
+/************************************************************************\
+ Zone Builder Game Configuration for Sonic Robo Blast 2 Version 2.2
+\************************************************************************/
+
+// 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 (Doom format)";
+
+// This is the simplified game engine/sourceport name
+engine = "zdoom";
+
+// Settings common to all games and all map formats
+include("Includes\\SRB222_common.cfg", "common");
+
+// Settings common to Doom map format
+include("Includes\\SRB222_common.cfg", "mapformat_doom");
+
+include("Includes\\Game_SRB222.cfg");
+
+// Script lumps detection
+scriptlumpnames
+{
+ include("Includes\\SRB222_misc.cfg", "scriptlumpnames");
+}
+
+// THING TYPES
+thingtypes
+{
+ include("Includes\\SRB222_things.cfg");
+}
+
+//Default things filters
+thingsfilters
+{
+ include("Includes\\SRB222_misc.cfg", "thingsfilters");
+}
\ No newline at end of file
diff --git a/extras/conf/SRB2_22UDMF.cfg b/extras/conf/SRB2_22UDMF.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..52104ed090b766914ee69d350c16799b1272d0d2
--- /dev/null
+++ b/extras/conf/SRB2_22UDMF.cfg
@@ -0,0 +1,47 @@
+/************************************************************************\
+ Zone Builder Game Configuration for Sonic Robo Blast 2 Version 2.2
+\************************************************************************/
+
+// 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 (UDMF)";
+
+// This is the simplified game engine/sourceport name
+engine = "zdoom";
+
+// Settings common to all games and all map formats
+include("Includes\\SRB222_common.cfg", "common");
+
+// Settings common to Doom map format
+include("Includes\\SRB222_common.cfg", "mapformat_udmf");
+
+include("Includes\\Game_SRB222.cfg");
+
+// Script lumps detection
+scriptlumpnames
+{
+ include("Includes\\SRB222_misc.cfg", "scriptlumpnames");
+}
+
+// THING TYPES
+thingtypes
+{
+ include("Includes\\SRB222_things.cfg");
+}
+
+//Default things filters
+thingsfilters
+{
+ include("Includes\\SRB222_misc.cfg", "thingsfilters");
+}
+
+// ENUMERATIONS
+// Each engine has its own additional thing types
+// These are enumerated lists for linedef types and UDMF fields.
+enums
+{
+ // Basic game enums
+ include("Includes\\SRB222_misc.cfg", "enums");
+}
\ No newline at end of file
diff --git a/src/android/i_video.c b/src/android/i_video.c
index 2d0151f5e27cd906e4856109fd8529772c704955..b8bb4fefbf408970af9c23ace95f5217548dc43e 100644
--- a/src/android/i_video.c
+++ b/src/android/i_video.c
@@ -19,6 +19,7 @@ boolean allow_fullscreen = false;
consvar_t cv_vidwait = {"vid_wait", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
void I_StartupGraphics(void){}
+void I_StartupHardwareGraphics(void){}
void I_ShutdownGraphics(void){}
@@ -51,6 +52,11 @@ INT32 VID_SetMode(INT32 modenum)
return 0;
}
+void VID_CheckRenderer(void)
+{
+ // ..............
+}
+
const char *VID_GetModeName(INT32 modenum)
{
return "A320x240";
diff --git a/src/command.c b/src/command.c
index 889ea3f02ab90041071ff8b6fd3185741849ed58..2c82a514b3748e59706c0c805e8ebe191b349f73 100644
--- a/src/command.c
+++ b/src/command.c
@@ -61,6 +61,8 @@ static consvar_t *consvar_vars; // list of registered console variables
static char com_token[1024];
static char *COM_Parse(char *data);
+static char * COM_Purge (char *text, int *lenp);
+
CV_PossibleValue_t CV_OnOff[] = {{0, "Off"}, {1, "On"}, {0, NULL}};
CV_PossibleValue_t CV_YesNo[] = {{0, "No"}, {1, "Yes"}, {0, NULL}};
CV_PossibleValue_t CV_Unsigned[] = {{0, "MIN"}, {999999999, "MAX"}, {0, NULL}};
@@ -100,31 +102,61 @@ static cmdalias_t *com_alias; // aliases list
static vsbuf_t com_text; // variable sized buffer
+/** Purges control characters out of some text.
+ *
+ * \param s The text.
+ * \param np Optionally a pointer to fill with the new string length.
+ * \return The text.
+ * \sa COM_ExecuteString
+ */
+static char *
+COM_Purge (char *s, int *np)
+{
+ char *t;
+ char *p;
+ int n;
+ n = strlen(s);
+ t = s + n + 1;
+ p = s;
+ while (( p = strchr(p, '\033') ))
+ {
+ memmove(p, &p[1], t - p - 1);
+ n--;
+ }
+ if (np)
+ (*np) = n;
+ return s;
+}
+
/** Adds text into the command buffer for later execution.
*
* \param ptext The text to add.
- * \sa COM_BufInsertText
+ * \sa COM_BufInsertTextEx
*/
-void COM_BufAddText(const char *ptext)
+void COM_BufAddTextEx(const char *ptext, int flags)
{
- size_t l;
+ int l;
+ char *text;
- l = strlen(ptext);
+ text = COM_Purge(Z_StrDup(ptext), &l);
- if (com_text.cursize + l >= com_text.maxsize)
+ if (com_text.cursize + 2 + l >= com_text.maxsize)
{
CONS_Alert(CONS_WARNING, M_GetText("Command buffer full!\n"));
return;
}
- VS_Write(&com_text, ptext, l);
+
+ VS_WriteEx(&com_text, text, l, flags);
+
+ Z_Free(text);
}
/** Adds command text and executes it immediately.
*
* \param ptext The text to execute. A newline is automatically added.
- * \sa COM_BufAddText
+ * \sa COM_BufAddTextEx
*/
-void COM_BufInsertText(const char *ptext)
+void COM_BufInsertTextEx(const char *ptext, int flags)
{
char *temp = NULL;
size_t templen;
@@ -138,7 +170,7 @@ void COM_BufInsertText(const char *ptext)
}
// add the entire text of the file (or alias)
- COM_BufAddText(ptext);
+ COM_BufAddTextEx(ptext, flags);
COM_BufExecute(); // do it right away
// add the copied off data
@@ -272,6 +304,7 @@ static size_t com_argc;
static char *com_argv[MAX_ARGS];
static const char *com_null_string = "";
static char *com_args = NULL; // current command args or NULL
+static int com_flags;
static void Got_NetVar(UINT8 **p, INT32 playernum);
@@ -395,6 +428,14 @@ static void COM_TokenizeString(char *ptext)
com_argc = 0;
com_args = NULL;
+ if (ptext[0] == '\033')
+ {
+ com_flags = (unsigned)ptext[1];
+ ptext += 2;
+ }
+ else
+ com_flags = 0;
+
while (com_argc < MAX_ARGS)
{
// Skip whitespace up to a newline.
@@ -1016,6 +1057,15 @@ void VS_Write(vsbuf_t *buf, const void *data, size_t length)
M_Memcpy(VS_GetSpace(buf, length), data, length);
}
+void VS_WriteEx(vsbuf_t *buf, const void *data, size_t length, int flags)
+{
+ char *p;
+ p = VS_GetSpace(buf, 2 + length);
+ p[0] = '\033';
+ p[1] = flags;
+ M_Memcpy(&p[2], data, length);
+}
+
/** Prints text in a variable buffer. Like VS_Write() plus a
* trailing NUL.
*
@@ -2015,6 +2065,9 @@ static boolean CV_Command(void)
if (!v)
return false;
+ if (( com_flags & COM_SAFE ) && ( v->flags & CV_NOLUA ))
+ return false;
+
// perform a variable print or set
if (COM_Argc() == 1)
{
diff --git a/src/command.h b/src/command.h
index 51e161cd05943c7211d4e26f8b8cb78674a89511..b1026437f131e75cc4b1fb84d12458f02d1f5d22 100644
--- a/src/command.h
+++ b/src/command.h
@@ -20,6 +20,11 @@
// Command buffer & command execution
//===================================
+enum
+{
+ COM_SAFE = 1,
+};
+
typedef void (*com_func_t)(void);
void COM_AddCommand(const char *name, com_func_t func);
@@ -36,10 +41,12 @@ size_t COM_FirstOption(void);
const char *COM_CompleteCommand(const char *partial, INT32 skips);
// insert at queu (at end of other command)
-void COM_BufAddText(const char *btext);
+#define COM_BufAddText(s) COM_BufAddTextEx(s, 0)
+void COM_BufAddTextEx(const char *btext, int flags);
// insert in head (before other command)
-void COM_BufInsertText(const char *btext);
+#define COM_BufInsertText(s) COM_BufInsertTextEx(s, 0)
+void COM_BufInsertTextEx(const char *btext, int flags);
// don't bother inserting, just do immediately
void COM_ImmedExecute(const char *ptext);
@@ -71,6 +78,7 @@ void VS_Free(vsbuf_t *buf);
void VS_Clear(vsbuf_t *buf);
void *VS_GetSpace(vsbuf_t *buf, size_t length);
void VS_Write(vsbuf_t *buf, const void *data, size_t length);
+void VS_WriteEx(vsbuf_t *buf, const void *data, size_t length, int flags);
void VS_Print(vsbuf_t *buf, const char *data); // strcats onto the sizebuf
//==================
@@ -100,7 +108,8 @@ typedef enum
CV_HIDEN = 1024, // variable is not part of the cvar list so cannot be accessed by the console
// can only be set when we have the pointer to it
// used on menus
- CV_CHEAT = 2048 // Don't let this be used in multiplayer unless cheats are on.
+ CV_CHEAT = 2048, // Don't let this be used in multiplayer unless cheats are on.
+ CV_NOLUA = 4096,/* don't let this be called from Lua */
} cvflags_t;
typedef struct CV_PossibleValue_s
diff --git a/src/console.c b/src/console.c
index 1fbca75b4cf6fcacbeaa2b8948bdf1525faa4036..6549370eeda227a1dc48b0ff062261115277f3cd 100644
--- a/src/console.c
+++ b/src/console.c
@@ -20,6 +20,7 @@
#include "g_input.h"
#include "hu_stuff.h"
#include "keys.h"
+#include "r_main.h"
#include "r_defs.h"
#include "sounds.h"
#include "st_stuff.h"
@@ -1285,10 +1286,10 @@ void CONS_Printf(const char *fmt, ...)
con_scrollup = 0;
// if not in display loop, force screen update
- if (con_startup)
+ if (con_startup && (!setrenderneeded))
{
#ifdef _WINDOWS
- patch_t *con_backpic = W_CachePatchName("CONSBACK", PU_CACHE);
+ patch_t *con_backpic = W_CachePatchName("CONSBACK", PU_PATCH);
// Jimita: CON_DrawBackpic just called V_DrawScaledPatch
V_DrawScaledPatch(0, 0, 0, con_backpic);
@@ -1545,7 +1546,7 @@ static void CON_DrawConsole(void)
// draw console background
if (cons_backpic.value || con_forcepic)
{
- patch_t *con_backpic = W_CachePatchName("CONSBACK", PU_CACHE);
+ patch_t *con_backpic = W_CachePatchName("CONSBACK", PU_PATCH);
// Jimita: CON_DrawBackpic just called V_DrawScaledPatch
V_DrawScaledPatch(0, 0, 0, con_backpic);
@@ -1602,8 +1603,18 @@ void CON_Drawer(void)
if (!con_started || !graphics_started)
return;
+ if (needpatchrecache)
+ {
+ W_FlushCachedPatches();
+ HU_LoadGraphics();
+ }
+
if (con_recalc)
+ {
CON_RecalcSize();
+ if (con_curlines <= 0)
+ CON_ClearHUD();
+ }
if (con_curlines > 0)
CON_DrawConsole();
diff --git a/src/d_clisrv.c b/src/d_clisrv.c
index 2504c93862e4440546e4422505901d81ba9b202e..dcd2dd299df02ead327c6516ef5d7bc2030e2f54 100644
--- a/src/d_clisrv.c
+++ b/src/d_clisrv.c
@@ -611,11 +611,7 @@ static inline void resynch_write_player(resynch_pak *rsp, const size_t i)
rsp->health = LONG(players[i].mo->health);
rsp->angle = (angle_t)LONG(players[i].mo->angle);
-#ifdef ROTSPRITE
rsp->rollangle = (angle_t)LONG(players[i].mo->rollangle);
-#else
- rsp->rollangle = 0;
-#endif
rsp->x = LONG(players[i].mo->x);
rsp->y = LONG(players[i].mo->y);
rsp->z = LONG(players[i].mo->z);
@@ -766,9 +762,7 @@ static void resynch_read_player(resynch_pak *rsp)
//At this point, the player should have a body, whether they were respawned or not.
P_UnsetThingPosition(players[i].mo);
players[i].mo->angle = (angle_t)LONG(rsp->angle);
-#ifdef ROTSPRITE
players[i].mo->rollangle = (angle_t)LONG(rsp->rollangle);
-#endif
players[i].mo->eflags = (UINT16)SHORT(rsp->eflags);
players[i].mo->flags = LONG(rsp->flags);
players[i].mo->flags2 = LONG(rsp->flags2);
@@ -1025,7 +1019,7 @@ static void SV_SendResynch(INT32 node)
netbuffer->packettype = PT_RESYNCHEND;
netbuffer->u.resynchend.randomseed = P_GetRandSeed();
- if (gametype == GT_CTF)
+ if (gametyperules & GTR_TEAMFLAGS)
resynch_write_ctf(&netbuffer->u.resynchend);
resynch_write_others(&netbuffer->u.resynchend);
@@ -1271,8 +1265,12 @@ static boolean CL_SendJoin(void)
if (splitscreen || botingame)
localplayers++;
netbuffer->u.clientcfg.localplayers = localplayers;
+ netbuffer->u.clientcfg._255 = 255;
+ netbuffer->u.clientcfg.packetversion = PACKETVERSION;
netbuffer->u.clientcfg.version = VERSION;
netbuffer->u.clientcfg.subversion = SUBVERSION;
+ strncpy(netbuffer->u.clientcfg.application, SRB2APPLICATION,
+ sizeof netbuffer->u.clientcfg.application);
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));
@@ -1283,8 +1281,12 @@ static void SV_SendServerInfo(INT32 node, tic_t servertime)
UINT8 *p;
netbuffer->packettype = PT_SERVERINFO;
+ netbuffer->u.serverinfo._255 = 255;
+ netbuffer->u.serverinfo.packetversion = PACKETVERSION;
netbuffer->u.serverinfo.version = VERSION;
netbuffer->u.serverinfo.subversion = SUBVERSION;
+ strncpy(netbuffer->u.serverinfo.application, SRB2APPLICATION,
+ sizeof netbuffer->u.serverinfo.application);
// return back the time value so client can compute their ping
netbuffer->u.serverinfo.time = (tic_t)LONG(servertime);
netbuffer->u.serverinfo.leveltime = (tic_t)LONG(leveltime);
@@ -1718,12 +1720,21 @@ static void SL_InsertServer(serverinfo_pak* info, SINT8 node)
if (serverlistcount >= MAXSERVERLIST)
return; // list full
+ if (info->_255 != 255)
+ return;/* old packet format */
+
+ if (info->packetversion != PACKETVERSION)
+ return;/* old new packet format */
+
if (info->version != VERSION)
return; // Not same version.
if (info->subversion != SUBVERSION)
return; // Close, but no cigar.
+ if (strcmp(info->application, SRB2APPLICATION))
+ return;/* that's a different mod */
+
i = serverlistcount++;
}
@@ -2111,10 +2122,10 @@ static void CL_ConnectToServer(boolean viams)
if (i != -1)
{
- UINT8 num = serverlist[i].info.gametype;
+ UINT16 num = serverlist[i].info.gametype;
const char *gametypestr = NULL;
CONS_Printf(M_GetText("Connecting to: %s\n"), serverlist[i].info.servername);
- if (num < NUMGAMETYPES)
+ if (num < gametypecount)
gametypestr = Gametype_Names[num];
if (gametypestr)
CONS_Printf(M_GetText("Gametype: %s\n"), gametypestr);
@@ -2430,7 +2441,7 @@ static void CL_RemovePlayer(INT32 playernum, INT32 reason)
}
}
- if (gametype == GT_CTF)
+ if (gametyperules & GTR_TEAMFLAGS)
P_PlayerFlagBurst(&players[playernum], false); // Don't take the flag with you!
// If in a special stage, redistribute the player's spheres across
@@ -2486,6 +2497,17 @@ static void CL_RemovePlayer(INT32 playernum, INT32 reason)
(void)reason;
#endif
+ // don't look through someone's view who isn't there
+ if (playernum == displayplayer)
+ {
+#ifdef HAVE_BLUA
+ // Call ViewpointSwitch hooks here.
+ // The viewpoint was forcibly changed.
+ LUAh_ViewpointSwitch(&players[consoleplayer], &players[displayplayer], true);
+#endif
+ displayplayer = consoleplayer;
+ }
+
// Reset player data
CL_ClearPlayer(playernum);
@@ -2503,16 +2525,13 @@ static void CL_RemovePlayer(INT32 playernum, INT32 reason)
RemoveAdminPlayer(playernum); // don't stay admin after you're gone
}
- if (playernum == displayplayer)
- displayplayer = consoleplayer; // don't look through someone's view who isn't there
-
#ifdef HAVE_BLUA
LUA_InvalidatePlayer(&players[playernum]);
#endif
if (G_TagGametype()) //Check if you still have a game. Location flexible. =P
P_CheckSurvivors();
- else if (gametype == GT_RACE || gametype == GT_COMPETITION)
+ else if (gametyperules & GTR_RACE)
P_CheckRacers();
}
@@ -3461,7 +3480,7 @@ void SV_StartSinglePlayerServer(void)
server = true;
netgame = false;
multiplayer = false;
- gametype = GT_COOP;
+ G_SetGametype(GT_COOP);
// no more tic the game with this settings!
SV_StopServer();
@@ -3507,6 +3526,12 @@ static void HandleConnect(SINT8 node)
if (bannednode && bannednode[node])
SV_SendRefuse(node, M_GetText("You have been banned\nfrom the server"));
+ else if (netbuffer->u.clientcfg._255 != 255 ||
+ netbuffer->u.clientcfg.packetversion != PACKETVERSION)
+ SV_SendRefuse(node, "Incompatible packet formats.");
+ else if (strncmp(netbuffer->u.clientcfg.application, SRB2APPLICATION,
+ sizeof netbuffer->u.clientcfg.application))
+ SV_SendRefuse(node, "Different SRB2 modifications\nare not compatible.");
else if (netbuffer->u.clientcfg.version != VERSION
|| netbuffer->u.clientcfg.subversion != SUBVERSION)
SV_SendRefuse(node, va(M_GetText("Different SRB2 versions cannot\nplay a netgame!\n(server version %d.%d.%d)"), VERSION/100, VERSION%100, SUBVERSION));
@@ -3629,6 +3654,8 @@ static void HandleServerInfo(SINT8 node)
const tic_t ticdiff = (ticnow - ticthen)*1000/NEWTICRATE;
netbuffer->u.serverinfo.time = (tic_t)LONG(ticdiff);
netbuffer->u.serverinfo.servername[MAXSERVERNAME-1] = 0;
+ netbuffer->u.serverinfo.application
+ [sizeof netbuffer->u.serverinfo.application - 1] = '\0';
SL_InsertServer(&netbuffer->u.serverinfo, node);
}
@@ -3740,7 +3767,7 @@ static void HandlePacketFromAwayNode(SINT8 node)
if (client)
{
maketic = gametic = neededtic = (tic_t)LONG(netbuffer->u.servercfg.gametic);
- gametype = netbuffer->u.servercfg.gametype;
+ G_SetGametype(netbuffer->u.servercfg.gametype);
modifiedgame = netbuffer->u.servercfg.modifiedgame;
for (j = 0; j < MAXPLAYERS; j++)
adminplayers[j] = netbuffer->u.servercfg.adminplayers[j];
@@ -4124,7 +4151,7 @@ static void HandlePacketFromPlayer(SINT8 node)
P_SetRandSeed(netbuffer->u.resynchend.randomseed);
- if (gametype == GT_CTF)
+ if (gametyperules & GTR_TEAMFLAGS)
resynch_read_ctf(&netbuffer->u.resynchend);
resynch_read_others(&netbuffer->u.resynchend);
diff --git a/src/d_clisrv.h b/src/d_clisrv.h
index 4ba4ee0eb7a1a08ad5639191cf18a4a96bf2a520..49f8afc7630c6123a705f2ed2e66d3d150cab07b 100644
--- a/src/d_clisrv.h
+++ b/src/d_clisrv.h
@@ -19,6 +19,16 @@
#include "tables.h"
#include "d_player.h"
+/*
+The 'packet version' may be used with packets whose
+format is expected to change between versions.
+
+This version is independent of the mod name, and standard
+version and subversion. It should only account for the
+basic fields of the packet, and change infrequently.
+*/
+#define PACKETVERSION 0
+
// Network play related stuff.
// There is a data struct that stores network
// communication related stuff, and another
@@ -320,8 +330,13 @@ typedef struct {
#pragma warning(default : 4200)
#endif
+#define MAXAPPLICATION 16
+
typedef struct
{
+ UINT8 _255;/* see serverinfo_pak */
+ UINT8 packetversion;
+ char application[MAXAPPLICATION];
UINT8 version; // Different versions don't work
UINT8 subversion; // Contains build version
UINT8 localplayers;
@@ -334,6 +349,14 @@ typedef struct
// This packet is too large
typedef struct
{
+ /*
+ In the old packet, 'version' is the first field. Now that field is set
+ to 255 always, so older versions won't be confused with the new
+ versions or vice-versa.
+ */
+ UINT8 _255;
+ UINT8 packetversion;
+ char application[MAXAPPLICATION];
UINT8 version;
UINT8 subversion;
UINT8 numberofplayer;
diff --git a/src/d_main.c b/src/d_main.c
index f3e84985a783be1c36e5d10de74c28fb0cb3eb42..b4c1ea80aec25f1a38c70d95867792d62fd260ac 100644
--- a/src/d_main.c
+++ b/src/d_main.c
@@ -108,6 +108,8 @@ boolean devparm = false; // started game with -devparm
boolean singletics = false; // timedemo
boolean lastdraw = false;
+static void D_CheckRendererState(void);
+
postimg_t postimgtype = postimg_none;
INT32 postimgparam;
postimg_t postimgtype2 = postimg_none;
@@ -212,6 +214,7 @@ INT16 wipetypepost = -1;
static void D_Display(void)
{
+ INT32 setrenderstillneeded = 0;
boolean forcerefresh = false;
static boolean wipe = false;
INT32 wipedefindex = 0;
@@ -222,11 +225,38 @@ static void D_Display(void)
if (nodrawers)
return; // for comparative timing/profiling
- // check for change of screen size (video mode)
- if (setmodeneeded && !wipe)
+ // Lactozilla: Switching renderers works by checking
+ // if the game has to do it right when the frame
+ // needs to render. If so, five things will happen:
+ // 1. Interface functions will be called so
+ // that switching to OpenGL creates a
+ // GL context, and switching to Software
+ // allocates screen buffers.
+ // 2. Software will set drawer functions,
+ // and OpenGL will load textures and
+ // create plane polygons, if necessary.
+ // 3. Functions related to switching video
+ // modes (resolution) are called.
+ // 4. Patch data is freed from memory,
+ // and recached if necessary.
+ // 5. The frame is ready to be drawn!
+
+ // stop movie if needs to change renderer
+ if (setrenderneeded && (moviemode == MM_APNG))
+ M_StopMovie();
+
+ // check for change of renderer or screen size (video mode)
+ if ((setrenderneeded || setmodeneeded) && !wipe)
+ {
+ if (setrenderneeded)
+ {
+ CONS_Debug(DBG_RENDER, "setrenderneeded set (%d)\n", setrenderneeded);
+ setrenderstillneeded = setrenderneeded;
+ }
SCR_SetMode(); // change video mode
+ }
- if (vid.recalc)
+ if (vid.recalc || setrenderstillneeded)
{
SCR_Recalc(); // NOTE! setsizeneeded is set by SCR_Recalc()
#ifdef HWRENDER
@@ -237,12 +267,15 @@ static void D_Display(void)
}
// change the view size if needed
- if (setsizeneeded)
+ if (setsizeneeded || setrenderstillneeded)
{
R_ExecuteSetViewSize();
forcerefresh = true; // force background redraw
}
+ // Lactozilla: Renderer switching
+ D_CheckRendererState();
+
// draw buffered stuff to screen
// Used only by linux GGI version
I_UpdateNoBlit();
@@ -457,7 +490,7 @@ static void D_Display(void)
py = 4;
else
py = viewwindowy + 4;
- patch = W_CachePatchName("M_PAUSE", PU_CACHE);
+ patch = W_CachePatchName("M_PAUSE", PU_PATCH);
V_DrawScaledPatch(viewwindowx + (BASEVIDWIDTH - SHORT(patch->width))/2, py, 0, patch);
#else
INT32 y = ((automapactive) ? (32) : (BASEVIDHEIGHT/2));
@@ -557,6 +590,25 @@ static void D_Display(void)
I_FinishUpdate(); // page flip or blit buffer
}
+
+ needpatchflush = false;
+ needpatchrecache = false;
+}
+
+// Lactozilla: Check the renderer's state
+// after a possible renderer switch.
+void D_CheckRendererState(void)
+{
+ // flush all patches from memory
+ // (also frees memory tagged with PU_CACHE)
+ // (which are not necessarily patches but I don't care)
+ if (needpatchflush)
+ Z_FlushCachedPatches();
+
+ // some patches have been freed,
+ // so cache them again
+ if (needpatchrecache)
+ R_ReloadHUDGraphics();
}
// =========================================================================
@@ -600,8 +652,7 @@ void D_SRB2Loop(void)
// hack to start on a nice clear console screen.
COM_ImmedExecute("cls;version");
- if (rendermode == render_soft)
- V_DrawScaledPatch(0, 0, 0, (patch_t *)W_CacheLumpNum(W_GetNumForName("CONSBACK"), PU_CACHE));
+ V_DrawScaledPatch(0, 0, 0, W_CachePatchNum(W_GetNumForName("CONSBACK"), PU_CACHE));
I_FinishUpdate(); // page flip or blit buffer
for (;;)
@@ -762,7 +813,7 @@ void D_StartTitle(void)
gameaction = ga_nothing;
displayplayer = consoleplayer = 0;
- gametype = GT_COOP;
+ G_SetGametype(GT_COOP);
paused = false;
advancedemo = false;
F_InitMenuPresValues();
@@ -1239,6 +1290,16 @@ void D_SRB2Main(void)
// set user default mode or mode set at cmdline
SCR_CheckDefaultMode();
+ // Lactozilla: Does the render mode need to change?
+ if ((setrenderneeded != 0) && (setrenderneeded != rendermode))
+ {
+ needpatchflush = true;
+ needpatchrecache = true;
+ VID_CheckRenderer();
+ SCR_ChangeRendererCVars(setrenderneeded);
+ }
+ D_CheckRendererState();
+
wipegamestate = gamestate;
savedata.lives = 0; // flag this as not-used
@@ -1419,14 +1480,14 @@ void D_SRB2Main(void)
if (newgametype == -1) // reached end of the list with no match
{
j = atoi(sgametype); // assume they gave us a gametype number, which is okay too
- if (j >= 0 && j < NUMGAMETYPES)
+ if (j >= 0 && j < gametypecount)
newgametype = (INT16)j;
}
if (newgametype != -1)
{
j = gametype;
- gametype = newgametype;
+ G_SetGametype(newgametype);
D_GameTypeChanged(j);
}
}
@@ -1462,7 +1523,7 @@ void D_SRB2Main(void)
{
levelstarttic = gametic;
G_SetGamestate(GS_LEVEL);
- if (!P_SetupLevel(false))
+ if (!P_LoadLevel(false))
I_Quit(); // fail so reset game stuff
}
}
diff --git a/src/d_netcmd.c b/src/d_netcmd.c
index c7f1b765d8d231d6a7f2f13d4f819f39128723df..5dd728b3a90004f3f41b2ea36aa05b7cf44b31e4 100644
--- a/src/d_netcmd.c
+++ b/src/d_netcmd.c
@@ -327,6 +327,10 @@ consvar_t cv_numlaps = {"numlaps", "4", CV_NETVAR|CV_CALL|CV_NOINIT, numlaps_con
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};
+// Point and time limits for every gametype
+INT32 pointlimits[NUMGAMETYPES];
+INT32 timelimits[NUMGAMETYPES];
+
// 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};
@@ -381,6 +385,9 @@ char timedemo_csv_id[256];
boolean timedemo_quit;
INT16 gametype = GT_COOP;
+UINT32 gametyperules = 0;
+INT16 gametypecount = (GT_CTF + 1);
+
boolean splitscreen = false;
boolean circuitmap = false;
INT32 adminplayers[MAXPLAYERS];
@@ -859,6 +866,8 @@ void D_RegisterClientCommands(void)
// screen.c
CV_RegisterVar(&cv_fullscreen);
CV_RegisterVar(&cv_renderview);
+ CV_RegisterVar(&cv_renderer);
+ CV_RegisterVar(&cv_newrenderer);
CV_RegisterVar(&cv_scr_depth);
CV_RegisterVar(&cv_scr_width);
CV_RegisterVar(&cv_scr_height);
@@ -1144,7 +1153,7 @@ UINT8 CanChangeSkin(INT32 playernum)
return true;
// Can change skin during initial countdown.
- if ((gametype == GT_RACE || gametype == GT_COMPETITION) && leveltime < 4*TICRATE)
+ if ((gametyperules & GTR_RACE) && leveltime < 4*TICRATE)
return true;
if (G_TagGametype())
@@ -1960,7 +1969,7 @@ static void Command_Map_f(void)
if (isdigit(gametypename[0]))
{
d = atoi(gametypename);
- if (d >= 0 && d < NUMGAMETYPES)
+ if (d >= 0 && d < gametypecount)
newgametype = d;
else
{
@@ -1968,7 +1977,7 @@ static void Command_Map_f(void)
"Gametype number %d is out of range. Use a number between"
" 0 and %d inclusive. ...Or just use the name. :v\n",
d,
- NUMGAMETYPES-1);
+ gametypecount-1);
Z_Free(realmapname);
Z_Free(mapname);
return;
@@ -2087,8 +2096,9 @@ static void Got_Mapcmd(UINT8 **cp, INT32 playernum)
lastgametype = gametype;
gametype = READUINT8(*cp);
+ G_SetGametype(gametype); // I fear putting that macro as an argument
- if (gametype < 0 || gametype >= NUMGAMETYPES)
+ if (gametype < 0 || gametype >= gametypecount)
gametype = lastgametype;
else if (gametype != lastgametype)
D_GameTypeChanged(lastgametype); // emulate consvar_t behavior for gametype
@@ -2431,7 +2441,7 @@ static void Command_Teamchange_f(void)
}
//additional check for hide and seek. Don't allow change of status after hidetime ends.
- if (gametype == GT_HIDEANDSEEK && leveltime >= (hidetime * TICRATE))
+ if ((gametyperules & GTR_HIDEFROZEN) && leveltime >= (hidetime * TICRATE))
{
CONS_Alert(CONS_NOTICE, M_GetText("Hiding time expired; no Hide and Seek status changes allowed!\n"));
return;
@@ -2528,7 +2538,7 @@ static void Command_Teamchange2_f(void)
}
//additional check for hide and seek. Don't allow change of status after hidetime ends.
- if (gametype == GT_HIDEANDSEEK && leveltime >= (hidetime * TICRATE))
+ if ((gametyperules & GTR_HIDEFROZEN) && leveltime >= (hidetime * TICRATE))
{
CONS_Alert(CONS_NOTICE, M_GetText("Hiding time expired; no Hide and Seek status changes allowed!\n"));
return;
@@ -2657,7 +2667,7 @@ static void Command_ServerTeamChange_f(void)
}
//additional check for hide and seek. Don't allow change of status after hidetime ends.
- if (gametype == GT_HIDEANDSEEK && leveltime >= (hidetime * TICRATE))
+ if ((gametyperules & GTR_HIDEFROZEN) && leveltime >= (hidetime * TICRATE))
{
CONS_Alert(CONS_NOTICE, M_GetText("Hiding time expired; no Hide and Seek status changes allowed!\n"));
return;
@@ -2746,6 +2756,16 @@ static void Got_Teamchange(UINT8 **cp, INT32 playernum)
return;
}
+#ifdef HAVE_BLUA
+ // Don't switch team, just go away, please, go awaayyyy, aaauuauugghhhghgh
+ if (!LUAh_TeamSwitch(&players[playernum], NetPacket.packet.newteam, players[playernum].spectator, NetPacket.packet.autobalance, NetPacket.packet.scrambled))
+ return;
+#endif
+
+ //no status changes after hidetime
+ if ((gametyperules & GTR_HIDEFROZEN) && (leveltime >= (hidetime * TICRATE)))
+ error = true;
+
//Make sure that the right team number is sent. Keep in mind that normal clients cannot change to certain teams in certain gametypes.
switch (gametype)
{
@@ -2900,7 +2920,15 @@ static void Got_Teamchange(UINT8 **cp, INT32 playernum)
//reset view if you are changed, or viewing someone who was changed.
if (playernum == consoleplayer || displayplayer == playernum)
+ {
+#ifdef HAVE_BLUA
+ // Call ViewpointSwitch hooks here.
+ // The viewpoint was forcibly changed.
+ if (displayplayer != consoleplayer) // You're already viewing yourself. No big deal.
+ LUAh_ViewpointSwitch(&players[playernum], &players[displayplayer], true);
+#endif
displayplayer = consoleplayer;
+ }
if (G_GametypeHasTeams())
{
@@ -3636,7 +3664,7 @@ static void Command_ShowGametype_f(void)
}
// get name string for current gametype
- if (gametype >= 0 && gametype < NUMGAMETYPES)
+ if (gametype >= 0 && gametype < gametypecount)
gametypestr = Gametype_Names[gametype];
if (gametypestr)
@@ -3698,7 +3726,7 @@ void ItemFinder_OnChange(void)
static void PointLimit_OnChange(void)
{
// Don't allow pointlimit in Single Player/Co-Op/Race!
- if (server && Playing() && G_PlatformGametype())
+ if (server && Playing() && !(gametyperules & GTR_POINTLIMIT))
{
if (cv_pointlimit.value)
CV_StealthSetValue(&cv_pointlimit, 0);
@@ -3861,7 +3889,7 @@ UINT32 timelimitintics = 0;
static void TimeLimit_OnChange(void)
{
// Don't allow timelimit in Single Player/Co-Op/Race!
- if (server && Playing() && cv_timelimit.value != 0 && G_PlatformGametype())
+ if (server && Playing() && cv_timelimit.value != 0 && !(gametyperules & GTR_TIMELIMIT))
{
CV_SetValue(&cv_timelimit, 0);
return;
@@ -3897,9 +3925,9 @@ void D_GameTypeChanged(INT32 lastgametype)
{
const char *oldgt = NULL, *newgt = NULL;
- if (lastgametype >= 0 && lastgametype < NUMGAMETYPES)
+ if (lastgametype >= 0 && lastgametype < gametypecount)
oldgt = Gametype_Names[lastgametype];
- if (gametype >= 0 && lastgametype < NUMGAMETYPES)
+ if (gametype >= 0 && lastgametype < gametypecount)
newgt = Gametype_Names[gametype];
if (oldgt && newgt)
@@ -3953,11 +3981,20 @@ void D_GameTypeChanged(INT32 lastgametype)
if (!cv_itemrespawntime.changed)
CV_Set(&cv_itemrespawntime, cv_itemrespawntime.defaultvalue); // respawn normally
break;
+ default:
+ if (!cv_timelimit.changed && !cv_pointlimit.changed) // user hasn't changed limits
+ {
+ CV_SetValue(&cv_timelimit, timelimits[gametype]);
+ CV_SetValue(&cv_pointlimit, pointlimits[gametype]);
+ }
+ if (!cv_itemrespawntime.changed)
+ CV_Set(&cv_itemrespawntime, cv_itemrespawntime.defaultvalue); // respawn normally
+ break;
}
}
else if (!multiplayer && !netgame)
{
- gametype = GT_COOP;
+ G_SetGametype(GT_COOP);
// These shouldn't matter anymore
//CV_Set(&cv_itemrespawntime, cv_itemrespawntime.defaultvalue);
//CV_SetValue(&cv_itemrespawn, 0);
@@ -3966,7 +4003,7 @@ void D_GameTypeChanged(INT32 lastgametype)
// reset timelimit and pointlimit in race/coop, prevent stupid cheats
if (server)
{
- if (G_PlatformGametype())
+ if (!(gametyperules & GTR_POINTLIMIT))
{
if (cv_timelimit.value)
CV_SetValue(&cv_timelimit, 0);
@@ -3984,6 +4021,7 @@ void D_GameTypeChanged(INT32 lastgametype)
// When swapping to a gametype that supports spectators,
// make everyone a spectator initially.
+ // Averted with GTR_NOSPECTATORSPAWN.
if (!splitscreen && (G_GametypeHasSpectators()))
{
INT32 i;
@@ -3991,7 +4029,7 @@ void D_GameTypeChanged(INT32 lastgametype)
if (playeringame[i])
{
players[i].ctfteam = 0;
- players[i].spectator = true;
+ players[i].spectator = (gametyperules & GTR_NOSPECTATORSPAWN) ? false : true;
}
}
diff --git a/src/dehacked.c b/src/dehacked.c
index 9abb708a9495b10075b4c7a239afd934508aa707..125086d4444da5d7ad304412fdb244996835b08d 100644
--- a/src/dehacked.c
+++ b/src/dehacked.c
@@ -22,6 +22,7 @@
#include "m_menu.h"
#include "m_misc.h"
#include "f_finale.h"
+#include "y_inter.h"
#include "dehacked.h"
#include "st_stuff.h"
#include "i_system.h"
@@ -76,6 +77,7 @@ static UINT16 get_mus(const char *word, UINT8 dehacked_mode);
static hudnum_t get_huditem(const char *word);
static menutype_t get_menutype(const char *word);
#ifndef HAVE_BLUA
+static INT16 get_gametype(const char *word);
static powertype_t get_power(const char *word);
#endif
@@ -590,6 +592,16 @@ static void readfreeslots(MYFILE *f)
} else
CONS_Alert(CONS_WARNING, "Ran out of free SPR2 slots!\n");
}
+ else if (fastcmp(type, "TOL"))
+ {
+ if (lastcustomtol > 31)
+ CONS_Alert(CONS_WARNING, "Ran out of free typeoflevel slots!\n");
+ else
+ {
+ G_AddTOL((1<<lastcustomtol), word);
+ lastcustomtol++;
+ }
+ }
else
deh_warning("Freeslots: unknown enum class '%s' for '%s_%s'", type, type, word);
}
@@ -863,14 +875,12 @@ static void readspriteframe(MYFILE *f, spriteinfo_t *sprinfo, UINT8 frame)
strupr(word);
value = atoi(word2); // used for numerical settings
-#ifdef ROTSPRITE
if (fastcmp(word, "XPIVOT"))
sprinfo->pivot[frame].x = value;
else if (fastcmp(word, "YPIVOT"))
sprinfo->pivot[frame].y = value;
else if (fastcmp(word, "ROTAXIS"))
sprinfo->pivot[frame].rotaxis = value;
-#endif
else
{
f->curpos = lastline;
@@ -1095,10 +1105,10 @@ static void readsprite2(MYFILE *f, INT32 num)
Z_Free(s);
}
-static const struct {
- const char *name;
- const UINT16 flag;
-} TYPEOFLEVEL[] = {
+INT32 numtolinfo = NUMBASETOL;
+UINT32 lastcustomtol = 13;
+
+tolinfo_t TYPEOFLEVEL[NUMMAXTOL] = {
{"SOLO",TOL_SP},
{"SP",TOL_SP},
{"SINGLEPLAYER",TOL_SP},
@@ -1114,8 +1124,6 @@ static const struct {
{"TAG",TOL_TAG},
{"CTF",TOL_CTF},
- {"CUSTOM",TOL_CUSTOM},
-
{"2D",TOL_2D},
{"MARIO",TOL_MARIO},
{"NIGHTS",TOL_NIGHTS},
@@ -1128,6 +1136,216 @@ static const struct {
{NULL, 0}
};
+// copypasted from readPlayer :sleep:
+static const char *const GAMETYPERULE_LIST[];
+static void readgametype(MYFILE *f, char *gtname)
+{
+ char *s = Z_Malloc(MAXLINELEN, PU_STATIC, NULL);
+ char *word;
+ char *word2, *word2lwr = NULL;
+ char *tmp;
+ INT32 i, j;
+
+ INT16 newgtidx = 0;
+ UINT32 newgtrules = 0;
+ UINT32 newgttol = 0;
+ INT32 newgtpointlimit = 0;
+ INT32 newgttimelimit = 0;
+ UINT8 newgtleftcolor = 0;
+ UINT8 newgtrightcolor = 0;
+ INT16 newgtrankingstype = -1;
+ int newgtinttype = 0;
+ char gtdescription[441];
+ char gtconst[MAXLINELEN];
+
+ // Empty strings.
+ gtdescription[0] = '\0';
+ gtconst[0] = '\0';
+
+ do
+ {
+ if (myfgets(s, MAXLINELEN, f))
+ {
+ if (s[0] == '\n')
+ break;
+
+ word = strtok(s, " ");
+ if (word)
+ strupr(word);
+ else
+ break;
+
+ if (fastcmp(word, "DESCRIPTION"))
+ {
+ char *descr = NULL;
+
+ for (i = 0; i < MAXLINELEN-3; i++)
+ {
+ if (s[i] == '=')
+ {
+ descr = &s[i+2];
+ break;
+ }
+ }
+ if (descr)
+ {
+ strcpy(gtdescription, descr);
+ strcat(gtdescription, myhashfgets(descr, sizeof (gtdescription), f));
+ }
+ else
+ strcpy(gtdescription, "");
+
+ // For some reason, cutting the string did not work above. Most likely due to strcpy or strcat...
+ // It works down here, though.
+ {
+ INT32 numline = 0;
+ for (i = 0; i < MAXLINELEN-1; i++)
+ {
+ if (numline < 20 && gtdescription[i] == '\n')
+ numline++;
+
+ if (numline >= 20 || gtdescription[i] == '\0' || gtdescription[i] == '#')
+ break;
+ }
+ }
+ gtdescription[strlen(gtdescription)-1] = '\0';
+ gtdescription[i] = '\0';
+ continue;
+ }
+
+ word2 = strtok(NULL, " = ");
+ if (word2)
+ {
+ if (!word2lwr)
+ word2lwr = Z_Malloc(MAXLINELEN, PU_STATIC, NULL);
+ strcpy(word2lwr, word2);
+ strupr(word2);
+ }
+ else
+ break;
+
+ if (word2[strlen(word2)-1] == '\n')
+ word2[strlen(word2)-1] = '\0';
+ i = atoi(word2);
+
+ // Game type rules
+ if (fastcmp(word, "RULES"))
+ {
+ // GTR_
+ newgtrules = (UINT32)get_number(word2);
+ }
+ // Identifier
+ else if (fastcmp(word, "IDENTIFIER"))
+ {
+ // GT_
+ strncpy(gtconst, word2, MAXLINELEN);
+ }
+ // Point and time limits
+ else if (fastcmp(word, "DEFAULTPOINTLIMIT"))
+ newgtpointlimit = (INT32)i;
+ else if (fastcmp(word, "DEFAULTTIMELIMIT"))
+ newgttimelimit = (INT32)i;
+ // Level platter
+ else if (fastcmp(word, "HEADERCOLOR") || fastcmp(word, "HEADERCOLOUR"))
+ newgtleftcolor = newgtrightcolor = (UINT8)get_number(word2);
+ else if (fastcmp(word, "HEADERLEFTCOLOR") || fastcmp(word, "HEADERLEFTCOLOUR"))
+ newgtleftcolor = (UINT8)get_number(word2);
+ else if (fastcmp(word, "HEADERRIGHTCOLOR") || fastcmp(word, "HEADERRIGHTCOLOUR"))
+ newgtrightcolor = (UINT8)get_number(word2);
+ // Rankings type
+ else if (fastcmp(word, "RANKINGTYPE"))
+ {
+ // Case insensitive
+ newgtrankingstype = (int)get_number(word2);
+ }
+ // Intermission type
+ else if (fastcmp(word, "INTERMISSIONTYPE"))
+ {
+ // Case sensitive
+ newgtinttype = (int)get_number(word2lwr);
+ }
+ // Type of level
+ else if (fastcmp(word, "TYPEOFLEVEL"))
+ {
+ if (i) // it's just a number
+ newgttol = (UINT32)i;
+ else
+ {
+ UINT16 tol = 0;
+ tmp = strtok(word2,",");
+ do {
+ for (i = 0; TYPEOFLEVEL[i].name; i++)
+ if (fasticmp(tmp, TYPEOFLEVEL[i].name))
+ break;
+ if (!TYPEOFLEVEL[i].name)
+ deh_warning("readgametype %s: unknown typeoflevel flag %s\n", gtname, tmp);
+ tol |= TYPEOFLEVEL[i].flag;
+ } while((tmp = strtok(NULL,",")) != NULL);
+ newgttol = tol;
+ }
+ }
+ // The SOC probably provided gametype rules as words,
+ // instead of using the RULES keyword.
+ // Like for example "NOSPECTATORSPAWN = TRUE".
+ // This is completely valid, and looks better anyway.
+ else
+ {
+ UINT32 wordgt = 0;
+ for (j = 0; GAMETYPERULE_LIST[j]; j++)
+ if (fastcmp(word, GAMETYPERULE_LIST[j])) {
+ if (!j) // GTR_CAMPAIGN
+ wordgt |= 1;
+ else
+ wordgt |= (1<<j);
+ if (i || word2[0] == 'T' || word2[0] == 'Y')
+ newgtrules |= wordgt;
+ break;
+ }
+ if (!wordgt)
+ deh_warning("readgametype %s: unknown word '%s'", gtname, word);
+ }
+ }
+ } while (!myfeof(f)); // finish when the line is empty
+
+ // Free strings.
+ Z_Free(s);
+ if (word2lwr)
+ Z_Free(word2lwr);
+
+ // Ran out of gametype slots
+ if (gametypecount == NUMGAMETYPEFREESLOTS)
+ {
+ CONS_Alert(CONS_WARNING, "Ran out of free gametype slots!\n");
+ return;
+ }
+
+ // Add the new gametype
+ newgtidx = G_AddGametype(newgtrules);
+ G_AddGametypeTOL(newgtidx, newgttol);
+ G_SetGametypeDescription(newgtidx, gtdescription, newgtleftcolor, newgtrightcolor);
+
+ // Not covered by G_AddGametype alone.
+ if (newgtrankingstype == -1)
+ newgtrankingstype = newgtidx;
+ gametyperankings[newgtidx] = newgtrankingstype;
+ intermissiontypes[newgtidx] = newgtinttype;
+ pointlimits[newgtidx] = newgtpointlimit;
+ timelimits[newgtidx] = newgttimelimit;
+
+ // Write the new gametype name.
+ Gametype_Names[newgtidx] = Z_StrDup((const char *)gtname);
+
+ // Write the constant name.
+ if (gtconst[0] == '\0')
+ strncpy(gtconst, gtname, MAXLINELEN);
+ G_AddGametypeConstant(newgtidx, (const char *)gtconst);
+
+ // Update gametype_cons_t accordingly.
+ G_UpdateGametypeSelections();
+
+ CONS_Printf("Added gametype %s\n", Gametype_Names[newgtidx]);
+}
+
static const struct {
const char *name;
const mobjtype_t type;
@@ -1395,7 +1613,7 @@ static void readlevelheader(MYFILE *f, INT32 num)
else if (fastcmp(word, "TYPEOFLEVEL"))
{
if (i) // it's just a number
- mapheaderinfo[num-1]->typeoflevel = (UINT16)i;
+ mapheaderinfo[num-1]->typeoflevel = (UINT32)i;
else
{
UINT16 tol = 0;
@@ -1520,10 +1738,27 @@ static void readlevelheader(MYFILE *f, INT32 num)
deh_warning("Level header %d: invalid bonus type number %d", num, i);
}
+ // Title card
+ else if (fastcmp(word, "TITLECARDZIGZAG"))
+ {
+ deh_strlcpy(mapheaderinfo[num-1]->ltzzpatch, word2,
+ sizeof(mapheaderinfo[num-1]->ltzzpatch), va("Level header %d: title card zigzag patch name", num));
+ }
+ else if (fastcmp(word, "TITLECARDZIGZAGTEXT"))
+ {
+ deh_strlcpy(mapheaderinfo[num-1]->ltzztext, word2,
+ sizeof(mapheaderinfo[num-1]->ltzztext), va("Level header %d: title card zigzag text patch name", num));
+ }
+ else if (fastcmp(word, "TITLECARDACTDIAMOND"))
+ {
+ deh_strlcpy(mapheaderinfo[num-1]->ltactdiamond, word2,
+ sizeof(mapheaderinfo[num-1]->ltactdiamond), va("Level header %d: title card act diamond patch name", num));
+ }
+
else if (fastcmp(word, "MAXBONUSLIVES"))
mapheaderinfo[num-1]->maxbonuslives = (SINT8)i;
else if (fastcmp(word, "LEVELFLAGS"))
- mapheaderinfo[num-1]->levelflags = (UINT8)i;
+ mapheaderinfo[num-1]->levelflags = (UINT16)i;
else if (fastcmp(word, "MENUFLAGS"))
mapheaderinfo[num-1]->menuflags = (UINT8)i;
@@ -2673,11 +2908,9 @@ static actionpointer_t actionpointers[] =
{{A_SpawnObjectRelative}, "A_SPAWNOBJECTRELATIVE"},
{{A_ChangeAngleRelative}, "A_CHANGEANGLERELATIVE"},
{{A_ChangeAngleAbsolute}, "A_CHANGEANGLEABSOLUTE"},
-#ifdef ROTSPRITE
{{A_RollAngle}, "A_ROLLANGLE"},
{{A_ChangeRollAngleRelative},"A_CHANGEROLLANGLERELATIVE"},
{{A_ChangeRollAngleAbsolute},"A_CHANGEROLLANGLEABSOLUTE"},
-#endif
{{A_PlaySound}, "A_PLAYSOUND"},
{{A_FindTarget}, "A_FINDTARGET"},
{{A_FindTracer}, "A_FINDTRACER"},
@@ -4155,6 +4388,7 @@ static void ignorelines(MYFILE *f)
static void DEH_LoadDehackedFile(MYFILE *f, boolean mainfile)
{
char *s = Z_Malloc(MAXLINELEN, PU_STATIC, NULL);
+ char textline[MAXLINELEN];
char *word;
char *word2;
INT32 i;
@@ -4175,6 +4409,7 @@ static void DEH_LoadDehackedFile(MYFILE *f, boolean mainfile)
char *traverse;
myfgets(s, MAXLINELEN, f);
+ memcpy(textline, s, MAXLINELEN);
if (s[0] == '\n' || s[0] == '#')
continue;
@@ -4363,6 +4598,36 @@ static void DEH_LoadDehackedFile(MYFILE *f, boolean mainfile)
ignorelines(f);
}
}
+ else if (fastcmp(word, "GAMETYPE"))
+ {
+ // Get the gametype name from textline
+ // instead of word2, so that gametype names
+ // aren't allcaps
+ INT32 c;
+ for (c = 0; c < MAXLINELEN; c++)
+ {
+ if (textline[c] == '\0')
+ break;
+ if (textline[c] == ' ')
+ {
+ char *gtname = (textline+c+1);
+ if (gtname)
+ {
+ // remove funny characters
+ INT32 j;
+ for (j = 0; j < (MAXLINELEN - c); j++)
+ {
+ if (gtname[j] == '\0')
+ break;
+ if (gtname[j] < 32)
+ gtname[j] = '\0';
+ }
+ readgametype(f, gtname);
+ }
+ break;
+ }
+ }
+ }
else if (fastcmp(word, "CUTSCENE"))
{
if (i > 0 && i < 129)
@@ -8559,9 +8824,11 @@ static const char *const MOBJEFLAG_LIST[] = {
"JUSTSTEPPEDDOWN", // used for ramp sectors
"VERTICALFLIP", // Vertically flip sprite/allow upside-down physics
"GOOWATER", // Goo water
+ "TOUCHLAVA", // The mobj is touching a lava block
"PUSHED", // Mobj was already pushed this tic
"SPRUNG", // Mobj was already sprung this tic
"APPLYPMOMZ", // Platform movement
+ "TRACERANGLE", // Compute and trigger on mobj angle relative to tracer
NULL
};
@@ -8633,6 +8900,39 @@ static const char *const PLAYERFLAG_LIST[] = {
NULL // stop loop here.
};
+static const char *const GAMETYPERULE_LIST[] = {
+ "CAMPAIGN",
+ "RINGSLINGER",
+ "SPECTATORS",
+ "FRIENDLYFIRE",
+ "LIVES",
+ "TEAMS",
+ "RACE",
+ "TAG",
+ "POINTLIMIT",
+ "TIMELIMIT",
+ "HIDETIME",
+ "HIDEFROZEN",
+ "BLINDFOLDED",
+ "FIRSTPERSON",
+ "MATCHEMERALDS",
+ "TEAMFLAGS",
+ "PITYSHIELD",
+ "DEATHPENALTY",
+ "NOSPECTATORSPAWN",
+ "DEATHMATCHSTARTS",
+ "SPECIALSTAGES",
+ "EMERALDTOKENS",
+ "EMERALDHUNT",
+ "SPAWNENEMIES",
+ "ALLOWEXIT",
+ "NOTITLECARD",
+ "OVERTIME",
+ "HURTMESSAGES",
+ "SPAWNINVUL",
+ NULL
+};
+
#ifdef HAVE_BLUA
// Linedef flags
static const char *const ML_LIST[16] = {
@@ -9048,21 +9348,6 @@ struct {
{"tr_trans90",tr_trans90},
{"NUMTRANSMAPS",NUMTRANSMAPS},
- // Type of levels
- {"TOL_SP",TOL_SP},
- {"TOL_COOP",TOL_COOP},
- {"TOL_COMPETITION",TOL_COMPETITION},
- {"TOL_RACE",TOL_RACE},
- {"TOL_MATCH",TOL_MATCH},
- {"TOL_TAG",TOL_TAG},
- {"TOL_CTF",TOL_CTF},
- {"TOL_CUSTOM",TOL_CUSTOM},
- {"TOL_2D",TOL_2D},
- {"TOL_MARIO",TOL_MARIO},
- {"TOL_NIGHTS",TOL_NIGHTS},
- {"TOL_ERZ3",TOL_ERZ3},
- {"TOL_XMAS",TOL_XMAS},
-
// Level flags
{"LF_SCRIPTISFILE",LF_SCRIPTISFILE},
{"LF_SPEEDMUSIC",LF_SPEEDMUSIC},
@@ -9245,15 +9530,16 @@ struct {
{"DMG_CANHURTSELF",DMG_CANHURTSELF},
{"DMG_DEATHMASK",DMG_DEATHMASK},
- // Gametypes, for use with global var "gametype"
- {"GT_COOP",GT_COOP},
- {"GT_COMPETITION",GT_COMPETITION},
- {"GT_RACE",GT_RACE},
- {"GT_MATCH",GT_MATCH},
- {"GT_TEAMMATCH",GT_TEAMMATCH},
- {"GT_TAG",GT_TAG},
- {"GT_HIDEANDSEEK",GT_HIDEANDSEEK},
- {"GT_CTF",GT_CTF},
+ // Intermission types
+ {"int_none",int_none},
+ {"int_coop",int_coop},
+ {"int_match",int_match},
+ {"int_teammatch",int_teammatch},
+ //{"int_tag",int_tag},
+ {"int_ctf",int_ctf},
+ {"int_spec",int_spec},
+ {"int_race",int_race},
+ {"int_comp",int_comp},
// Jingles (jingletype_t)
{"JT_NONE",JT_NONE},
@@ -9426,12 +9712,10 @@ struct {
{"DI_SOUTHEAST",DI_SOUTHEAST},
{"NUMDIRS",NUMDIRS},
-#ifdef ROTSPRITE
// Sprite rotation axis (rotaxis_t)
{"ROTAXIS_X",ROTAXIS_X},
{"ROTAXIS_Y",ROTAXIS_Y},
{"ROTAXIS_Z",ROTAXIS_Z},
-#endif
// Buttons (ticcmd_t)
{"BT_WEAPONMASK",BT_WEAPONMASK}, //our first four bits.
@@ -9462,6 +9746,7 @@ struct {
{"CV_HIDEN",CV_HIDEN},
{"CV_HIDDEN",CV_HIDEN},
{"CV_CHEAT",CV_CHEAT},
+ {"CV_NOLUA",CV_NOLUA},
// v_video flags
{"V_NOSCALEPATCH",V_NOSCALEPATCH},
@@ -9546,7 +9831,7 @@ struct {
};
static mobjtype_t get_mobjtype(const char *word)
-{ // Returns the vlaue of MT_ enumerations
+{ // Returns the value of MT_ enumerations
mobjtype_t i;
if (*word >= '0' && *word <= '9')
return atoi(word);
@@ -9698,8 +9983,22 @@ static menutype_t get_menutype(const char *word)
}
#ifndef HAVE_BLUA
+static INT16 get_gametype(const char *word)
+{ // Returns the value of GT_ enumerations
+ INT16 i;
+ if (*word >= '0' && *word <= '9')
+ return atoi(word);
+ if (fastncmp("GT_",word,3))
+ word += 3; // take off the GT_
+ for (i = 0; i < NUMGAMETYPES; i++)
+ if (fastcmp(word, Gametype_ConstantNames[i]+3))
+ return i;
+ deh_warning("Couldn't find gametype named 'GT_%s'",word);
+ return GT_COOP;
+}
+
static powertype_t get_power(const char *word)
-{ // Returns the vlaue of pw_ enumerations
+{ // Returns the value of pw_ enumerations
powertype_t i;
if (*word >= '0' && *word <= '9')
return atoi(word);
@@ -9893,11 +10192,42 @@ static fixed_t find_const(const char **rword)
free(word);
return r;
}
- else if (fastncmp("MN_",word,4)) {
+ else if (fastncmp("MN_",word,3)) {
r = get_menutype(word);
free(word);
return r;
}
+ else if (fastncmp("GT_",word,4)) {
+ r = get_gametype(word);
+ free(word);
+ return r;
+ }
+ else if (fastncmp("GTR_", word, 4)) {
+ char *p = word+4;
+ for (i = 0; GAMETYPERULE_LIST[i]; i++)
+ if (fastcmp(p, GAMETYPERULE_LIST[i])) {
+ free(word);
+ return (1<<i);
+ }
+
+ // Not found error
+ const_warning("game type rule",word);
+ free(word);
+ return 0;
+ }
+ else if (fastncmp("TOL_", word, 4)) {
+ char *p = word+4;
+ for (i = 0; TYPEOFLEVEL[i].name; i++)
+ if (fastcmp(p, TYPEOFLEVEL[i].name)) {
+ free(word);
+ return TYPEOFLEVEL[i].flag;
+ }
+
+ // Not found error
+ const_warning("typeoflevel",word);
+ free(word);
+ return 0;
+ }
else if (fastncmp("HUD_",word,4)) {
r = get_huditem(word);
free(word);
@@ -10107,6 +10437,20 @@ static inline int lib_freeslot(lua_State *L)
}
r++;
}
+ else if (fastcmp(type, "TOL"))
+ {
+ if (lastcustomtol > 31)
+ CONS_Alert(CONS_WARNING, "Ran out of free typeoflevel slots!\n");
+ else
+ {
+ UINT32 newtol = (1<<lastcustomtol);
+ CONS_Printf("TypeOfLevel TOL_%s allocated.\n",word);
+ G_AddTOL(newtol, word);
+ lua_pushinteger(L, newtol);
+ lastcustomtol++;
+ r++;
+ }
+ }
Z_Free(s);
lua_remove(L, 1);
continue;
@@ -10211,6 +10555,36 @@ static inline int lib_getenum(lua_State *L)
if (mathlib) return luaL_error(L, "playerflag '%s' could not be found.\n", word);
return 0;
}
+ else if (fastncmp("GT_", word, 3)) {
+ p = word;
+ for (i = 0; Gametype_ConstantNames[i]; i++)
+ if (fastcmp(p, Gametype_ConstantNames[i])) {
+ lua_pushinteger(L, i);
+ return 1;
+ }
+ if (mathlib) return luaL_error(L, "gametype '%s' could not be found.\n", word);
+ return 0;
+ }
+ else if (fastncmp("GTR_", word, 4)) {
+ p = word+4;
+ for (i = 0; GAMETYPERULE_LIST[i]; i++)
+ if (fastcmp(p, GAMETYPERULE_LIST[i])) {
+ lua_pushinteger(L, ((lua_Integer)1<<i));
+ return 1;
+ }
+ if (mathlib) return luaL_error(L, "game type rule '%s' could not be found.\n", word);
+ return 0;
+ }
+ else if (fastncmp("TOL_", word, 4)) {
+ p = word+4;
+ for (i = 0; TYPEOFLEVEL[i].name; i++)
+ if (fastcmp(p, TYPEOFLEVEL[i].name)) {
+ lua_pushinteger(L, TYPEOFLEVEL[i].flag);
+ return 1;
+ }
+ if (mathlib) return luaL_error(L, "typeoflevel '%s' could not be found.\n", word);
+ return 0;
+ }
else if (fastncmp("ML_", word, 3)) {
p = word+3;
for (i = 0; i < 16; i++)
@@ -10448,126 +10822,7 @@ static inline int lib_getenum(lua_State *L)
// DYNAMIC variables too!!
// Try not to add anything that would break netgames or timeattack replays here.
// You know, like consoleplayer, displayplayer, secondarydisplayplayer, or gametime.
- if (fastcmp(word,"gamemap")) {
- lua_pushinteger(L, gamemap);
- return 1;
- } else if (fastcmp(word,"maptol")) {
- lua_pushinteger(L, maptol);
- return 1;
- } else if (fastcmp(word,"ultimatemode")) {
- lua_pushboolean(L, ultimatemode != 0);
- return 1;
- } else if (fastcmp(word,"mariomode")) {
- lua_pushboolean(L, mariomode != 0);
- return 1;
- } else if (fastcmp(word,"twodlevel")) {
- lua_pushboolean(L, twodlevel != 0);
- return 1;
- } else if (fastcmp(word,"circuitmap")) {
- lua_pushboolean(L, circuitmap);
- return 1;
- } else if (fastcmp(word,"netgame")) {
- lua_pushboolean(L, netgame);
- return 1;
- } else if (fastcmp(word,"multiplayer")) {
- lua_pushboolean(L, multiplayer);
- return 1;
- } else if (fastcmp(word,"modeattacking")) {
- lua_pushboolean(L, modeattacking);
- return 1;
- } else if (fastcmp(word,"splitscreen")) {
- lua_pushboolean(L, splitscreen);
- return 1;
- } else if (fastcmp(word,"gamecomplete")) {
- lua_pushboolean(L, gamecomplete);
- return 1;
- } else if (fastcmp(word,"devparm")) {
- lua_pushboolean(L, devparm);
- return 1;
- } else if (fastcmp(word,"modifiedgame")) {
- lua_pushboolean(L, modifiedgame && !savemoddata);
- return 1;
- } else if (fastcmp(word,"menuactive")) {
- lua_pushboolean(L, menuactive);
- return 1;
- } else if (fastcmp(word,"paused")) {
- lua_pushboolean(L, paused);
- return 1;
- } else if (fastcmp(word,"titlemap")) {
- lua_pushinteger(L, titlemap);
- return 1;
- } else if (fastcmp(word,"titlemapinaction")) {
- lua_pushboolean(L, (titlemapinaction != TITLEMAP_OFF));
- return 1;
- } else if (fastcmp(word,"gametype")) {
- lua_pushinteger(L, gametype);
- return 1;
- } else if (fastcmp(word,"leveltime")) {
- lua_pushinteger(L, leveltime);
- return 1;
- } else if (fastcmp(word,"curWeather")) {
- lua_pushinteger(L, curWeather);
- return 1;
- } else if (fastcmp(word,"globalweather")) {
- lua_pushinteger(L, globalweather);
- return 1;
- } else if (fastcmp(word,"levelskynum")) {
- lua_pushinteger(L, levelskynum);
- return 1;
- } else if (fastcmp(word,"globallevelskynum")) {
- lua_pushinteger(L, globallevelskynum);
- return 1;
- } else if (fastcmp(word,"mapmusname")) {
- lua_pushstring(L, mapmusname);
- return 1;
- } else if (fastcmp(word,"mapmusflags")) {
- lua_pushinteger(L, mapmusflags);
- return 1;
- } 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;
- LUA_PushUserdata(L, &players[serverplayer], META_PLAYER);
- return 1;
- } else if (fastcmp(word,"admin")) { // BACKWARDS COMPATIBILITY HACK: This was replaced with IsPlayerAdmin(), but some 2.1 Lua scripts still use the admin variable. It now points to the first admin player in the array.
- LUA_Deprecated(L, "admin", "IsPlayerAdmin(player)");
- if (!playeringame[adminplayers[0]] || IsPlayerAdmin(serverplayer))
- return 0;
- LUA_PushUserdata(L, &players[adminplayers[0]], META_PLAYER);
- return 1;
- } else if (fastcmp(word,"emeralds")) {
- lua_pushinteger(L, emeralds);
- return 1;
- } else if (fastcmp(word,"gravity")) {
- lua_pushinteger(L, gravity);
- return 1;
- } else if (fastcmp(word,"VERSIONSTRING")) {
- lua_pushstring(L, VERSIONSTRING);
- return 1;
- } else if (fastcmp(word, "token")) {
- lua_pushinteger(L, token);
- return 1;
- }
- return 0;
+ return LUA_PushGlobals(L, word);
}
int LUA_EnumLib(lua_State *L)
@@ -10634,6 +10889,8 @@ static int lib_getActionName(lua_State *L)
return luaL_typerror(L, 1, "action userdata or Lua function");
}
+
+
int LUA_SOCLib(lua_State *L)
{
lua_register(L,"freeslot",lib_freeslot);
diff --git a/src/djgppdos/i_video.c b/src/djgppdos/i_video.c
index 56570b7bf8daf871fca8db3a03909823c33ad605..02c7a842bc2c0aa77fb7d8d7180a04d9029878b5 100644
--- a/src/djgppdos/i_video.c
+++ b/src/djgppdos/i_video.c
@@ -338,3 +338,8 @@ void I_StartupGraphics(void)
graphics_started = true;
}
+
+void I_StartupHardwareGraphics(void)
+{
+ // oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo y
+}
diff --git a/src/djgppdos/vid_vesa.c b/src/djgppdos/vid_vesa.c
index ec7b8b886343d0d8fe9c8d9e66eff3c1aeaf1793..c8ce7dae52e645372455b76cbad40ffd03c53a0e 100644
--- a/src/djgppdos/vid_vesa.c
+++ b/src/djgppdos/vid_vesa.c
@@ -378,6 +378,11 @@ INT32 VID_SetMode (INT32 modenum) //, UINT8 *palette)
return 1;
}
+void VID_CheckRenderer(void)
+{
+ // ..............
+}
+
// converts a segm:offs 32bit pair to a 32bit flat ptr
diff --git a/src/doomdef.h b/src/doomdef.h
index fe6a5faa3a36bbda215c77240067140f3edb66e6..7d65398d7302723b5bb481a0b0e4426f750f0480 100644
--- a/src/doomdef.h
+++ b/src/doomdef.h
@@ -130,6 +130,9 @@ extern FILE *logstream;
extern char logfilename[1024];
#endif
+/* A mod name to further distinguish versions. */
+#define SRB2APPLICATION "SRB2"
+
//#define DEVELOP // Disable this for release builds to remove excessive cheat commands and enable MD5 checking and stuff, all in one go. :3
#ifdef DEVELOP
#define VERSION 0 // Game version
@@ -624,9 +627,12 @@ extern const char *compdate, *comptime, *comprevision, *compbranch;
/// SRB2CB itself ported this from PrBoom+
#define NEWCLIP
+/// Cache patches in Lua in a way that renderer switching will work flawlessly.
+//#define LUA_PATCH_SAFETY
+
/// Sprite rotation
#define ROTSPRITE
-#define ROTANGLES 24 // Needs to be a divisor of 360 (45, 60, 90, 120...)
+#define ROTANGLES 72 // Needs to be a divisor of 360 (45, 60, 90, 120...)
#define ROTANGDIFF (360 / ROTANGLES)
/// PNG support
diff --git a/src/doomstat.h b/src/doomstat.h
index cc4e0ca98ce6f8eb0942b61d7e52c1388365fd3f..36ef44c2609604c2ab3d48edb34eebc3d209ed95 100644
--- a/src/doomstat.h
+++ b/src/doomstat.h
@@ -39,7 +39,7 @@ extern UINT32 mapmusposition;
#define MUSIC_FORCERESET 0x4000 // -*--------------
// Use other bits if necessary.
-extern INT16 maptol;
+extern UINT32 maptol;
extern UINT8 globalweather;
extern INT32 curWeather;
extern INT32 cursaveslot;
@@ -84,6 +84,9 @@ extern boolean addedtogame; // true after the server has added you
extern boolean multiplayer;
extern INT16 gametype;
+extern UINT32 gametyperules;
+extern INT16 gametypecount;
+
extern boolean splitscreen;
extern boolean circuitmap; // Does this level have 'circuit mode'?
extern boolean fromlevelselect;
@@ -284,7 +287,7 @@ typedef struct
char lvlttl[22]; ///< Level name without "Zone". (21 character limit instead of 32, 21 characters can display on screen max anyway)
char subttl[33]; ///< Subtitle for level
UINT8 actnum; ///< Act number or 0 for none.
- UINT16 typeoflevel; ///< Combination of typeoflevel flags.
+ UINT32 typeoflevel; ///< Combination of typeoflevel flags.
INT16 nextlevel; ///< Map number of next level, or 1100-1102 to end.
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.
@@ -310,12 +313,17 @@ typedef struct
SINT8 bonustype; ///< What type of bonus does this level have? (-1 for null.)
SINT8 maxbonuslives; ///< How many bonus lives to award at Intermission? (-1 for unlimited.)
- UINT8 levelflags; ///< LF_flags: merged booleans into one UINT8 for space, see below
+ UINT16 levelflags; ///< LF_flags: merged booleans into one UINT16 for space, see below
UINT8 menuflags; ///< LF2_flags: options that affect record attack / nights mode menus
char selectheading[22]; ///< Level select heading. Allows for controllable grouping.
UINT16 startrings; ///< Number of rings players start with.
+ // Title card.
+ char ltzzpatch[8]; ///< Zig zag patch.
+ char ltzztext[8]; ///< Zig zag text.
+ char ltactdiamond[8]; ///< Act diamond.
+
// Freed animals stuff.
UINT8 numFlickies; ///< Internal. For freed flicky support.
mobjtype_t *flickies; ///< List of freeable flickies in this level. Allocated dynamically for space reasons. Be careful.
@@ -361,6 +369,70 @@ typedef struct
extern mapheader_t* mapheaderinfo[NUMMAPS];
+// Gametypes
+#define NUMGAMETYPEFREESLOTS 128
+enum GameType
+{
+ GT_COOP = 0, // also used in single player
+ GT_COMPETITION, // Classic "Race"
+ GT_RACE,
+
+ GT_MATCH,
+ GT_TEAMMATCH,
+
+ GT_TAG,
+ GT_HIDEANDSEEK,
+
+ GT_CTF, // capture the flag
+
+ GT_FIRSTFREESLOT,
+ GT_LASTFREESLOT = GT_FIRSTFREESLOT + NUMGAMETYPEFREESLOTS - 1,
+ NUMGAMETYPES
+};
+// If you alter this list, update dehacked.c, MISC_ChangeGameTypeMenu in m_menu.c, and Gametype_Names in g_game.c
+
+// Gametype rules
+enum GameTypeRules
+{
+ GTR_CAMPAIGN = 1, // Linear Co-op map progression, don't allow random maps
+ GTR_RINGSLINGER = 1<<1, // Outside of Co-op, Competition, and Race (overriden by cv_ringslinger)
+ GTR_SPECTATORS = 1<<2, // Outside of Co-op, Competition, and Race
+ GTR_FRIENDLYFIRE = 1<<3, // Always allow friendly fire
+ GTR_LIVES = 1<<4, // Co-op and Competition
+ GTR_TEAMS = 1<<5, // Team Match, CTF
+ GTR_RACE = 1<<6, // Race and Competition
+ GTR_TAG = 1<<7, // Tag and Hide and Seek
+ GTR_POINTLIMIT = 1<<8, // Ringslinger point limit
+ GTR_TIMELIMIT = 1<<9, // Ringslinger time limit
+ GTR_HIDETIME = 1<<10, // Hide time (Tag and Hide and Seek)
+ GTR_HIDEFROZEN = 1<<11, // Frozen after hide time (Hide and Seek, but not Tag)
+ GTR_BLINDFOLDED = 1<<12, // Blindfolded view (Tag and Hide and Seek)
+ GTR_FIRSTPERSON = 1<<13, // First person camera
+ GTR_MATCHEMERALDS = 1<<14, // Ringslinger emeralds (Match and CTF)
+ GTR_TEAMFLAGS = 1<<15, // Gametype has team flags (CTF)
+ GTR_PITYSHIELD = 1<<16, // Award pity shield
+ GTR_DEATHPENALTY = 1<<17, // Death score penalty
+ GTR_NOSPECTATORSPAWN = 1<<18, // Use with GTR_SPECTATORS, spawn in the map instead of with the spectators
+ GTR_DEATHMATCHSTARTS = 1<<19, // Use deathmatch starts
+ GTR_SPECIALSTAGES = 1<<20, // Allow special stages
+ GTR_EMERALDTOKENS = 1<<21, // Spawn emerald tokens
+ GTR_EMERALDHUNT = 1<<22, // Emerald Hunt
+ GTR_SPAWNENEMIES = 1<<23, // Spawn enemies
+ GTR_ALLOWEXIT = 1<<24, // Allow exit sectors
+ GTR_NOTITLECARD = 1<<25, // Don't show the title card
+ GTR_OVERTIME = 1<<26, // Allow overtime
+ GTR_HURTMESSAGES = 1<<27, // Hit and death messages
+ GTR_SPAWNINVUL = 1<<28, // Babysitting deterrent
+};
+
+// String names for gametypes
+extern const char *Gametype_Names[NUMGAMETYPES];
+extern const char *Gametype_ConstantNames[NUMGAMETYPES];
+
+// Point and time limits for every gametype
+extern INT32 pointlimits[NUMGAMETYPES];
+extern INT32 timelimits[NUMGAMETYPES];
+
enum TypeOfLevel
{
TOL_SP = 0x01, ///< Single Player
@@ -376,36 +448,26 @@ enum TypeOfLevel
TOL_CTF = 0x40, ///< Capture the Flag
// CTF default = 64
- TOL_CUSTOM = 0x80, ///< Custom (Lua-scripted, etc.)
+ // 0x80 was here
TOL_2D = 0x0100, ///< 2D
TOL_MARIO = 0x0200, ///< Mario
TOL_NIGHTS = 0x0400, ///< NiGHTS
TOL_ERZ3 = 0x0800, ///< ERZ3
- TOL_XMAS = 0x1000 ///< Christmas NiGHTS
+ TOL_XMAS = 0x1000, ///< Christmas NiGHTS
};
-// Gametypes
-enum GameType
-{
- GT_COOP = 0, // also used in single player
- GT_COMPETITION, // Classic "Race"
- GT_RACE,
-
- GT_MATCH,
- GT_TEAMMATCH,
+#define NUMBASETOL 18
+#define NUMMAXTOL (18 + NUMGAMETYPEFREESLOTS)
- GT_TAG,
- GT_HIDEANDSEEK,
-
- GT_CTF, // capture the flag
-
- NUMGAMETYPES
-};
-// If you alter this list, update dehacked.c, MISC_ChangeGameTypeMenu in m_menu.c, and Gametype_Names in g_game.c
-
-// String names for gametypes
-extern const char *Gametype_Names[NUMGAMETYPES];
+typedef struct
+{
+ const char *name;
+ UINT32 flag;
+} tolinfo_t;
+extern tolinfo_t TYPEOFLEVEL[NUMMAXTOL];
+extern INT32 numtolinfo;
+extern UINT32 lastcustomtol;
extern tic_t totalplaytime;
diff --git a/src/dummy/i_video.c b/src/dummy/i_video.c
index e167e833fb152d6fcc5daa7a490cede554944d3b..fafeee0001400ef868b6c8d91042870c6c2e3773 100644
--- a/src/dummy/i_video.c
+++ b/src/dummy/i_video.c
@@ -11,6 +11,7 @@ boolean allow_fullscreen = false;
consvar_t cv_vidwait = {"vid_wait", "On", CV_SAVE, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
void I_StartupGraphics(void){}
+void I_StartupHardwareGraphics(void){}
void I_ShutdownGraphics(void){}
@@ -39,6 +40,11 @@ INT32 VID_SetMode(INT32 modenum)
return 0;
}
+void VID_CheckRenderer(void)
+{
+ // ..............
+}
+
const char *VID_GetModeName(INT32 modenum)
{
(void)modenum;
diff --git a/src/f_finale.c b/src/f_finale.c
index 1436a159b1285cb40ba302a15f767412f0c0f77c..317a57f3d385efdaa1795788bbf96390588b9ddf 100644
--- a/src/f_finale.c
+++ b/src/f_finale.c
@@ -530,78 +530,78 @@ static void F_IntroDrawScene(void)
case 0:
break;
case 1:
- background = W_CachePatchName("INTRO1", PU_CACHE);
+ background = W_CachePatchName("INTRO1", PU_PATCH);
break;
case 2:
- background = W_CachePatchName("INTRO2", PU_CACHE);
+ background = W_CachePatchName("INTRO2", PU_PATCH);
break;
case 3:
- background = W_CachePatchName("INTRO3", PU_CACHE);
+ background = W_CachePatchName("INTRO3", PU_PATCH);
break;
case 4:
- background = W_CachePatchName("INTRO4", PU_CACHE);
+ background = W_CachePatchName("INTRO4", PU_PATCH);
break;
case 5:
if (intro_curtime >= 5*TICRATE)
- background = W_CachePatchName("RADAR", PU_CACHE);
+ background = W_CachePatchName("RADAR", PU_PATCH);
else
- background = W_CachePatchName("DRAT", PU_CACHE);
+ background = W_CachePatchName("DRAT", PU_PATCH);
break;
case 6:
- background = W_CachePatchName("INTRO6", PU_CACHE);
+ background = W_CachePatchName("INTRO6", PU_PATCH);
cx = 180;
cy = 8;
break;
case 7:
{
if (intro_curtime >= 7*TICRATE + ((TICRATE/7)*2))
- background = W_CachePatchName("SGRASS5", PU_CACHE);
+ background = W_CachePatchName("SGRASS5", PU_PATCH);
else if (intro_curtime >= 7*TICRATE + (TICRATE/7))
- background = W_CachePatchName("SGRASS4", PU_CACHE);
+ background = W_CachePatchName("SGRASS4", PU_PATCH);
else if (intro_curtime >= 7*TICRATE)
- background = W_CachePatchName("SGRASS3", PU_CACHE);
+ background = W_CachePatchName("SGRASS3", PU_PATCH);
else if (intro_curtime >= 6*TICRATE)
- background = W_CachePatchName("SGRASS2", PU_CACHE);
+ background = W_CachePatchName("SGRASS2", PU_PATCH);
else
- background = W_CachePatchName("SGRASS1", PU_CACHE);
+ background = W_CachePatchName("SGRASS1", PU_PATCH);
break;
}
case 8:
- background = W_CachePatchName("WATCHING", PU_CACHE);
+ background = W_CachePatchName("WATCHING", PU_PATCH);
break;
case 9:
- background = W_CachePatchName("ZOOMING", PU_CACHE);
+ background = W_CachePatchName("ZOOMING", PU_PATCH);
break;
case 10:
break;
case 11:
- background = W_CachePatchName("INTRO5", PU_CACHE);
+ background = W_CachePatchName("INTRO5", PU_PATCH);
break;
case 12:
- background = W_CachePatchName("REVENGE", PU_CACHE);
+ background = W_CachePatchName("REVENGE", PU_PATCH);
cx = 208;
cy = 8;
break;
case 13:
- background = W_CachePatchName("CONFRONT", PU_CACHE);
+ background = W_CachePatchName("CONFRONT", PU_PATCH);
cy += 48;
break;
case 14:
- background = W_CachePatchName("TAILSSAD", PU_CACHE);
+ background = W_CachePatchName("TAILSSAD", PU_PATCH);
bgxoffs = 144;
cx = 8;
cy = 8;
break;
case 15:
if (intro_curtime >= 7*TICRATE)
- background = W_CachePatchName("SONICDO2", PU_CACHE);
+ background = W_CachePatchName("SONICDO2", PU_PATCH);
else
- background = W_CachePatchName("SONICDO1", PU_CACHE);
+ background = W_CachePatchName("SONICDO1", PU_PATCH);
cx = 224;
cy = 8;
break;
case 16:
- background = W_CachePatchName("INTRO7", PU_CACHE);
+ background = W_CachePatchName("INTRO7", PU_PATCH);
break;
default:
break;
@@ -631,30 +631,30 @@ static void F_IntroDrawScene(void)
S_ChangeMusicInternal("_stjr", false);
x = (BASEVIDWIDTH<<FRACBITS)/2 - FixedMul(334<<FRACBITS, aspect)/2;
y = (BASEVIDHEIGHT<<FRACBITS)/2 - FixedMul(358<<FRACBITS, aspect)/2;
- V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH1", PU_CACHE)), aspect);
+ V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH1", PU_PATCH)), aspect);
W_UnlockCachedPatch(patch);
if (finalecount > 6) {
- V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH2", PU_CACHE)), aspect);
+ V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH2", PU_PATCH)), aspect);
W_UnlockCachedPatch(patch);
}
if (finalecount > 10) {
- V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH3", PU_CACHE)), aspect);
+ V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH3", PU_PATCH)), aspect);
W_UnlockCachedPatch(patch);
}
if (finalecount > 14) {
- V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH4", PU_CACHE)), aspect);
+ V_DrawSciencePatch(x, y, 0, (patch = W_CachePatchName("WAHH4", PU_PATCH)), aspect);
W_UnlockCachedPatch(patch);
}
}
else if (finalecount-30 < 20) { // Big eggy
- background = W_CachePatchName("FEEDIN", PU_CACHE);
+ background = W_CachePatchName("FEEDIN", PU_PATCH);
x = (BASEVIDWIDTH<<FRACBITS)/2 - FixedMul(560<<FRACBITS, aspect)/2;
y = (BASEVIDHEIGHT<<FRACBITS) - FixedMul(477<<FRACBITS, aspect);
V_DrawSciencePatch(x, y, V_SNAPTOBOTTOM, background, aspect);
}
else if (finalecount-50 < 30) { // Zoom out
fixed_t scale = FixedDiv(aspect, FixedDiv((finalecount-50)<<FRACBITS, (15<<FRACBITS))+FRACUNIT);
- background = W_CachePatchName("FEEDIN", PU_CACHE);
+ background = W_CachePatchName("FEEDIN", PU_PATCH);
x = (BASEVIDWIDTH<<FRACBITS)/2 - FixedMul(560<<FRACBITS, aspect)/2 + (FixedMul(560<<FRACBITS, aspect) - FixedMul(560<<FRACBITS, scale));
y = (BASEVIDHEIGHT<<FRACBITS) - FixedMul(477<<FRACBITS, scale);
V_DrawSciencePatch(x, y, V_SNAPTOBOTTOM, background, scale);
@@ -664,7 +664,7 @@ static void F_IntroDrawScene(void)
{
// Draw tiny eggy
fixed_t scale = FixedMul(FRACUNIT/3, aspect);
- background = W_CachePatchName("FEEDIN", PU_CACHE);
+ background = W_CachePatchName("FEEDIN", PU_PATCH);
x = (BASEVIDWIDTH<<FRACBITS)/2 - FixedMul(560<<FRACBITS, aspect)/2 + (FixedMul(560<<FRACBITS, aspect) - FixedMul(560<<FRACBITS, scale));
y = (BASEVIDHEIGHT<<FRACBITS) - FixedMul(477<<FRACBITS, scale);
V_DrawSciencePatch(x, y, V_SNAPTOBOTTOM, background, scale);
@@ -675,34 +675,34 @@ static void F_IntroDrawScene(void)
x = (-189*FRACUNIT) + (FixedMul((6<<FRACBITS)+FRACUNIT/3, ftime<<FRACBITS) - FixedMul((6<<FRACBITS)+FRACUNIT/3, FixedDiv(FixedMul(ftime<<FRACBITS, ftime<<FRACBITS), 120<<FRACBITS)));
y = (BASEVIDHEIGHT<<FRACBITS) - FixedMul(417<<FRACBITS, aspect);
// Draw the body
- V_DrawSciencePatch(x, y, V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT1", PU_CACHE)), aspect);
+ V_DrawSciencePatch(x, y, V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT1", PU_PATCH)), aspect);
W_UnlockCachedPatch(patch);
// Draw the door
- V_DrawSciencePatch(x+FixedMul(344<<FRACBITS, aspect), y+FixedMul(292<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT2", PU_CACHE)), aspect);
+ V_DrawSciencePatch(x+FixedMul(344<<FRACBITS, aspect), y+FixedMul(292<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT2", PU_PATCH)), aspect);
W_UnlockCachedPatch(patch);
// Draw the wheel
- V_DrawSciencePatch(x+FixedMul(178<<FRACBITS, aspect), y+FixedMul(344<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName(va("TYRE%02u",(abs(finalecount-144)/3)%16), PU_CACHE)), aspect);
+ V_DrawSciencePatch(x+FixedMul(178<<FRACBITS, aspect), y+FixedMul(344<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName(va("TYRE%02u",(abs(finalecount-144)/3)%16), PU_PATCH)), aspect);
W_UnlockCachedPatch(patch);
// Draw the wheel cover
- V_DrawSciencePatch(x+FixedMul(88<<FRACBITS, aspect), y+FixedMul(238<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT3", PU_CACHE)), aspect);
+ V_DrawSciencePatch(x+FixedMul(88<<FRACBITS, aspect), y+FixedMul(238<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT3", PU_PATCH)), aspect);
W_UnlockCachedPatch(patch);
} else { // Pure Fat has stopped!
y = (BASEVIDHEIGHT<<FRACBITS) - FixedMul(417<<FRACBITS, aspect);
// Draw the body
- V_DrawSciencePatch(0, y, V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT1", PU_CACHE)), aspect);
+ V_DrawSciencePatch(0, y, V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT1", PU_PATCH)), aspect);
W_UnlockCachedPatch(patch);
// Draw the wheel
- V_DrawSciencePatch(FixedMul(178<<FRACBITS, aspect), y+FixedMul(344<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("TYRE00", PU_CACHE)), aspect);
+ V_DrawSciencePatch(FixedMul(178<<FRACBITS, aspect), y+FixedMul(344<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("TYRE00", PU_PATCH)), aspect);
W_UnlockCachedPatch(patch);
// Draw the wheel cover
- V_DrawSciencePatch(FixedMul(88<<FRACBITS, aspect), y+FixedMul(238<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT3", PU_CACHE)), aspect);
+ V_DrawSciencePatch(FixedMul(88<<FRACBITS, aspect), y+FixedMul(238<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT3", PU_PATCH)), aspect);
W_UnlockCachedPatch(patch);
// Draw the door
if (finalecount-TICRATE/2 > 4*TICRATE) { // Door is being raised!
int ftime = (finalecount-TICRATE/2-4*TICRATE);
y -= FixedDiv((ftime*ftime)<<FRACBITS, 23<<FRACBITS);
}
- V_DrawSciencePatch(FixedMul(344<<FRACBITS, aspect), y+FixedMul(292<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT2", PU_CACHE)), aspect);
+ V_DrawSciencePatch(FixedMul(344<<FRACBITS, aspect), y+FixedMul(292<<FRACBITS, aspect), V_SNAPTOLEFT|V_SNAPTOBOTTOM, (patch = W_CachePatchName("PUREFAT2", PU_PATCH)), aspect);
W_UnlockCachedPatch(patch);
}
}
@@ -716,27 +716,27 @@ static void F_IntroDrawScene(void)
if (timetonext > 5*TICRATE && timetonext < 6*TICRATE)
{
if (!(finalecount & 3))
- background = W_CachePatchName("BRITEGG1", PU_CACHE);
+ background = W_CachePatchName("BRITEGG1", PU_PATCH);
else
- background = W_CachePatchName("DARKEGG1", PU_CACHE);
+ background = W_CachePatchName("DARKEGG1", PU_PATCH);
V_DrawSmallScaledPatch(0, 0, 0, background);
}
else if (timetonext > 3*TICRATE && timetonext < 4*TICRATE)
{
if (!(finalecount & 3))
- background = W_CachePatchName("BRITEGG2", PU_CACHE);
+ background = W_CachePatchName("BRITEGG2", PU_PATCH);
else
- background = W_CachePatchName("DARKEGG2", PU_CACHE);
+ background = W_CachePatchName("DARKEGG2", PU_PATCH);
V_DrawSmallScaledPatch(0, 0, 0, background);
}
else if (timetonext > 1*TICRATE && timetonext < 2*TICRATE)
{
if (!(finalecount & 3))
- background = W_CachePatchName("BRITEGG3", PU_CACHE);
+ background = W_CachePatchName("BRITEGG3", PU_PATCH);
else
- background = W_CachePatchName("DARKEGG3", PU_CACHE);
+ background = W_CachePatchName("DARKEGG3", PU_PATCH);
V_DrawSmallScaledPatch(0, 0, 0, background);
}
@@ -768,79 +768,79 @@ static void F_IntroDrawScene(void)
knucklesx += sonicx;
sonicx += P_ReturnThrustX(NULL, finalecount * ANG10, 3);
- V_DrawSmallScaledPatch(skyx, 0, 0, (patch = W_CachePatchName("INTROSKY", PU_CACHE)));
+ V_DrawSmallScaledPatch(skyx, 0, 0, (patch = W_CachePatchName("INTROSKY", PU_PATCH)));
V_DrawSmallScaledPatch(skyx - 320, 0, 0, patch);
W_UnlockCachedPatch(patch);
- V_DrawSmallScaledPatch(grassx, 0, 0, (patch = W_CachePatchName("INTROGRS", PU_CACHE)));
+ V_DrawSmallScaledPatch(grassx, 0, 0, (patch = W_CachePatchName("INTROGRS", PU_PATCH)));
V_DrawSmallScaledPatch(grassx - 320, 0, 0, patch);
W_UnlockCachedPatch(patch);
if (finalecount & 1)
{
// Sonic
- V_DrawSmallScaledPatch(sonicx, 54, 0, (patch = W_CachePatchName("RUN2", PU_CACHE)));
+ V_DrawSmallScaledPatch(sonicx, 54, 0, (patch = W_CachePatchName("RUN2", PU_PATCH)));
W_UnlockCachedPatch(patch);
// Appendages
if (finalecount & 2)
{
// Sonic's feet
- V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT4", PU_CACHE)));
+ V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT4", PU_PATCH)));
W_UnlockCachedPatch(patch);
// Tails' tails
- V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP2", PU_CACHE)));
+ V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP2", PU_PATCH)));
W_UnlockCachedPatch(patch);
}
else
{
// Sonic's feet
- V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT2", PU_CACHE)));
+ V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT2", PU_PATCH)));
W_UnlockCachedPatch(patch);
// Tails' tails
- V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP1", PU_CACHE)));
+ V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP1", PU_PATCH)));
W_UnlockCachedPatch(patch);
}
// Tails
- V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("FLY2", PU_CACHE)));
+ V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("FLY2", PU_PATCH)));
W_UnlockCachedPatch(patch);
// Knuckles
- V_DrawSmallScaledPatch(knucklesx, knucklesy, 0, (patch = W_CachePatchName("GLIDE2", PU_CACHE)));
+ V_DrawSmallScaledPatch(knucklesx, knucklesy, 0, (patch = W_CachePatchName("GLIDE2", PU_PATCH)));
W_UnlockCachedPatch(patch);
}
else
{
// Sonic
- V_DrawSmallScaledPatch(sonicx, 54, 0, (patch = W_CachePatchName("RUN1", PU_CACHE)));
+ V_DrawSmallScaledPatch(sonicx, 54, 0, (patch = W_CachePatchName("RUN1", PU_PATCH)));
W_UnlockCachedPatch(patch);
// Appendages
if (finalecount & 2)
{
// Sonic's feet
- V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT3", PU_CACHE)));
+ V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT3", PU_PATCH)));
W_UnlockCachedPatch(patch);
// Tails' tails
- V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP2", PU_CACHE)));
+ V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP2", PU_PATCH)));
W_UnlockCachedPatch(patch);
}
else
{
// Sonic's feet
- V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT1", PU_CACHE)));
+ V_DrawSmallScaledPatch(sonicx - 8, 92, 0, (patch = W_CachePatchName("PEELOUT1", PU_PATCH)));
W_UnlockCachedPatch(patch);
// Tails' tails
- V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP1", PU_CACHE)));
+ V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("HELICOP1", PU_PATCH)));
W_UnlockCachedPatch(patch);
}
// Tails
- V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("FLY1", PU_CACHE)));
+ V_DrawSmallScaledPatch(tailsx, tailsy, 0, (patch = W_CachePatchName("FLY1", PU_PATCH)));
W_UnlockCachedPatch(patch);
// Knuckles
- V_DrawSmallScaledPatch(knucklesx, knucklesy, 0, (patch = W_CachePatchName("GLIDE1", PU_CACHE)));
+ V_DrawSmallScaledPatch(knucklesx, knucklesy, 0, (patch = W_CachePatchName("GLIDE1", PU_PATCH)));
W_UnlockCachedPatch(patch);
}
@@ -873,8 +873,8 @@ static void F_IntroDrawScene(void)
y += (30*(FRACUNIT-scale));
}
- rockpat = W_CachePatchName(va("ROID00%.2d", 34 - (worktics % 35)), PU_LEVEL);
- glow = W_CachePatchName(va("ENDGLOW%.1d", 2+(worktics & 1)), PU_LEVEL);
+ rockpat = W_CachePatchName(va("ROID00%.2d", 34 - (worktics % 35)), PU_PATCH);
+ glow = W_CachePatchName(va("ENDGLOW%.1d", 2+(worktics & 1)), PU_PATCH);
if (worktics >= 5)
trans = (worktics-5)>>1;
@@ -988,7 +988,7 @@ void F_IntroDrawer(void)
{
if (intro_scenenum == 5 && intro_curtime == 5*TICRATE)
{
- patch_t *radar = W_CachePatchName("RADAR", PU_CACHE);
+ patch_t *radar = W_CachePatchName("RADAR", PU_PATCH);
F_WipeStartScreen();
F_WipeColorFill(31);
@@ -1001,7 +1001,7 @@ void F_IntroDrawer(void)
}
else if (intro_scenenum == 7 && intro_curtime == 6*TICRATE) // Force a wipe here
{
- patch_t *grass = W_CachePatchName("SGRASS2", PU_CACHE);
+ patch_t *grass = W_CachePatchName("SGRASS2", PU_PATCH);
F_WipeStartScreen();
F_WipeColorFill(31);
@@ -1014,7 +1014,7 @@ void F_IntroDrawer(void)
}
/*else if (intro_scenenum == 12 && intro_curtime == 7*TICRATE)
{
- patch_t *confront = W_CachePatchName("CONFRONT", PU_CACHE);
+ patch_t *confront = W_CachePatchName("CONFRONT", PU_PATCH);
F_WipeStartScreen();
F_WipeColorFill(31);
@@ -1027,7 +1027,7 @@ void F_IntroDrawer(void)
}*/
if (intro_scenenum == 15 && intro_curtime == 7*TICRATE)
{
- patch_t *sdo = W_CachePatchName("SONICDO2", PU_CACHE);
+ patch_t *sdo = W_CachePatchName("SONICDO2", PU_PATCH);
F_WipeStartScreen();
F_WipeColorFill(31);
@@ -1359,14 +1359,14 @@ void F_CreditDrawer(void)
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
// Zig Zagz
- V_DrawScaledPatch(-16, zagpos, V_SNAPTOLEFT, W_CachePatchName("LTZIGZAG", PU_CACHE));
- V_DrawScaledPatch(-16, zagpos - 320, V_SNAPTOLEFT, W_CachePatchName("LTZIGZAG", PU_CACHE));
- V_DrawScaledPatch(BASEVIDWIDTH + 16, zagpos, V_SNAPTORIGHT|V_FLIP, W_CachePatchName("LTZIGZAG", PU_CACHE));
- V_DrawScaledPatch(BASEVIDWIDTH + 16, zagpos - 320, V_SNAPTORIGHT|V_FLIP, W_CachePatchName("LTZIGZAG", PU_CACHE));
+ V_DrawScaledPatch(-16, zagpos, V_SNAPTOLEFT, W_CachePatchName("LTZIGZAG", PU_PATCH));
+ V_DrawScaledPatch(-16, zagpos - 320, V_SNAPTOLEFT, W_CachePatchName("LTZIGZAG", PU_PATCH));
+ V_DrawScaledPatch(BASEVIDWIDTH + 16, zagpos, V_SNAPTORIGHT|V_FLIP, W_CachePatchName("LTZIGZAG", PU_PATCH));
+ V_DrawScaledPatch(BASEVIDWIDTH + 16, zagpos - 320, V_SNAPTORIGHT|V_FLIP, W_CachePatchName("LTZIGZAG", PU_PATCH));
// Draw background pictures first
for (i = 0; credits_pics[i].patch; i++)
- V_DrawSciencePatch(credits_pics[i].x<<FRACBITS, (280<<FRACBITS) + (((i*credits_height)<<FRACBITS)/(credits_numpics)) - 4*(animtimer<<FRACBITS)/5, 0, W_CachePatchName(credits_pics[i].patch, PU_CACHE), FRACUNIT>>1);
+ V_DrawSciencePatch(credits_pics[i].x<<FRACBITS, (280<<FRACBITS) + (((i*credits_height)<<FRACBITS)/(credits_numpics)) - 4*(animtimer<<FRACBITS)/5, 0, W_CachePatchName(credits_pics[i].patch, PU_PATCH), FRACUNIT>>1);
// Dim the background
V_DrawFadeScreen(0xFF00, 16);
@@ -1574,14 +1574,14 @@ void F_GameEvaluationDrawer(void)
if (goodending)
{
- rockpat = W_CachePatchName(va("ROID00%.2d", 34 - (finalecount % 35)), PU_LEVEL);
- glow = W_CachePatchName(va("ENDGLOW%.1d", 2+(finalecount & 1)), PU_LEVEL);
+ rockpat = W_CachePatchName(va("ROID00%.2d", 34 - (finalecount % 35)), PU_PATCH);
+ glow = W_CachePatchName(va("ENDGLOW%.1d", 2+(finalecount & 1)), PU_PATCH);
x -= FRACUNIT;
}
else
{
rockpat = W_CachePatchName("ROID0000", PU_LEVEL);
- glow = W_CachePatchName(va("ENDGLOW%.1d", (finalecount & 1)), PU_LEVEL);
+ glow = W_CachePatchName(va("ENDGLOW%.1d", (finalecount & 1)), PU_PATCH);
}
if (finalecount >= 5)
@@ -1613,20 +1613,20 @@ void F_GameEvaluationDrawer(void)
// if j == 0 - alternate between 0 and 1
// 1 - 1 and 2
// 2 - 2 and not rendered
- V_DrawFixedPatch(x+sparkloffs[j-1][0], y+sparkloffs[j-1][1], FRACUNIT, 0, W_CachePatchName(va("ENDSPKL%.1d", (j - ((sparklloop & 1) ? 0 : 1))), PU_LEVEL), R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_AQUA, GTC_CACHE));
+ V_DrawFixedPatch(x+sparkloffs[j-1][0], y+sparkloffs[j-1][1], FRACUNIT, 0, W_CachePatchName(va("ENDSPKL%.1d", (j - ((sparklloop & 1) ? 0 : 1))), PU_PATCH), R_GetTranslationColormap(TC_DEFAULT, SKINCOLOR_AQUA, GTC_CACHE));
}
j--;
}
}
else
{
- patch_t *eggrock = W_CachePatchName("ENDEGRK5", PU_LEVEL);
+ patch_t *eggrock = W_CachePatchName("ENDEGRK5", PU_PATCH);
V_DrawFixedPatch(x, y, scale, 0, eggrock, colormap[0]);
if (trans < 10)
V_DrawFixedPatch(x, y, scale, trans<<V_ALPHASHIFT, eggrock, colormap[1]);
else if (sparklloop)
V_DrawFixedPatch(x, y, scale, (10-sparklloop)<<V_ALPHASHIFT,
- W_CachePatchName("ENDEGRK0", PU_LEVEL), colormap[1]);
+ W_CachePatchName("ENDEGRK0", PU_PATCH), colormap[1]);
}
}
@@ -1640,7 +1640,7 @@ void F_GameEvaluationDrawer(void)
eemeralds_cur += (360<<FRACBITS)/7;
patchname[4] = 'A'+(char)i;
- V_DrawFixedPatch(x, y, FRACUNIT, ((emeralds & (1<<i)) ? 0 : V_80TRANS), W_CachePatchName(patchname, PU_LEVEL), NULL);
+ V_DrawFixedPatch(x, y, FRACUNIT, ((emeralds & (1<<i)) ? 0 : V_80TRANS), W_CachePatchName(patchname, PU_PATCH), NULL);
}
V_DrawCreditString((BASEVIDWIDTH - V_CreditStringWidth(endingtext))<<(FRACBITS-1), (BASEVIDHEIGHT-100)<<(FRACBITS-1), 0, endingtext);
@@ -1753,55 +1753,34 @@ void F_GameEvaluationTicker(void)
#define STOPPINGPOINT (14*TICRATE)
#define SPARKLLOOPTIME 15 // must be odd
-void F_StartEnding(void)
+static void F_CacheEnding(void)
{
- G_SetGamestate(GS_ENDING);
- wipetypepost = INT16_MAX;
-
- // Just in case they're open ... somehow
- M_ClearMenus(true);
-
- // Save before the credits sequence.
- if ((!modifiedgame || savemoddata) && !(netgame || multiplayer) && cursaveslot > 0)
- G_SaveGame((UINT32)cursaveslot);
-
- gameaction = ga_nothing;
- paused = false;
- CON_ToggleOff();
- S_StopMusic();
- S_StopSounds();
-
- finalecount = -10; // what? this totally isn't a hack. why are you asking?
-
- memset(sparkloffs, 0, sizeof(INT32)*3*2);
- sparklloop = 0;
-
- endbrdr[1] = W_CachePatchName("ENDBRDR1", PU_LEVEL);
+ endbrdr[1] = W_CachePatchName("ENDBRDR1", PU_PATCH);
- endegrk[0] = W_CachePatchName("ENDEGRK0", PU_LEVEL);
- endegrk[1] = W_CachePatchName("ENDEGRK1", PU_LEVEL);
+ endegrk[0] = W_CachePatchName("ENDEGRK0", PU_PATCH);
+ endegrk[1] = W_CachePatchName("ENDEGRK1", PU_PATCH);
- endglow[0] = W_CachePatchName("ENDGLOW0", PU_LEVEL);
- endglow[1] = W_CachePatchName("ENDGLOW1", PU_LEVEL);
+ endglow[0] = W_CachePatchName("ENDGLOW0", PU_PATCH);
+ endglow[1] = W_CachePatchName("ENDGLOW1", PU_PATCH);
- endbgsp[0] = W_CachePatchName("ENDBGSP0", PU_LEVEL);
- endbgsp[1] = W_CachePatchName("ENDBGSP1", PU_LEVEL);
- endbgsp[2] = W_CachePatchName("ENDBGSP2", PU_LEVEL);
+ endbgsp[0] = W_CachePatchName("ENDBGSP0", PU_PATCH);
+ endbgsp[1] = W_CachePatchName("ENDBGSP1", PU_PATCH);
+ endbgsp[2] = W_CachePatchName("ENDBGSP2", PU_PATCH);
- endspkl[0] = W_CachePatchName("ENDSPKL0", PU_LEVEL);
- endspkl[1] = W_CachePatchName("ENDSPKL1", PU_LEVEL);
- endspkl[2] = W_CachePatchName("ENDSPKL2", PU_LEVEL);
+ endspkl[0] = W_CachePatchName("ENDSPKL0", PU_PATCH);
+ endspkl[1] = W_CachePatchName("ENDSPKL1", PU_PATCH);
+ endspkl[2] = W_CachePatchName("ENDSPKL2", PU_PATCH);
- endxpld[0] = W_CachePatchName("ENDXPLD0", PU_LEVEL);
- endxpld[1] = W_CachePatchName("ENDXPLD1", PU_LEVEL);
- endxpld[2] = W_CachePatchName("ENDXPLD2", PU_LEVEL);
- endxpld[3] = W_CachePatchName("ENDXPLD3", PU_LEVEL);
+ endxpld[0] = W_CachePatchName("ENDXPLD0", PU_PATCH);
+ endxpld[1] = W_CachePatchName("ENDXPLD1", PU_PATCH);
+ endxpld[2] = W_CachePatchName("ENDXPLD2", PU_PATCH);
+ endxpld[3] = W_CachePatchName("ENDXPLD3", PU_PATCH);
- endescp[0] = W_CachePatchName("ENDESCP0", PU_LEVEL);
- endescp[1] = W_CachePatchName("ENDESCP1", PU_LEVEL);
- endescp[2] = W_CachePatchName("ENDESCP2", PU_LEVEL);
- endescp[3] = W_CachePatchName("ENDESCP3", PU_LEVEL);
- endescp[4] = W_CachePatchName("ENDESCP4", PU_LEVEL);
+ endescp[0] = W_CachePatchName("ENDESCP0", PU_PATCH);
+ endescp[1] = W_CachePatchName("ENDESCP1", PU_PATCH);
+ endescp[2] = W_CachePatchName("ENDESCP2", PU_PATCH);
+ endescp[3] = W_CachePatchName("ENDESCP3", PU_PATCH);
+ endescp[4] = W_CachePatchName("ENDESCP4", PU_PATCH);
// so we only need to check once
if ((goodending = ALL7EMERALDS(emeralds)))
@@ -1814,32 +1793,69 @@ void F_StartEnding(void)
sprdef = &skins[skinnum].sprites[SPR2_XTRA];
// character head, skin specific
sprframe = &sprdef->spriteframes[XTRA_ENDING];
- endfwrk[0] = W_CachePatchNum(sprframe->lumppat[0], PU_LEVEL);
+ endfwrk[0] = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
sprframe = &sprdef->spriteframes[XTRA_ENDING+1];
- endfwrk[1] = W_CachePatchNum(sprframe->lumppat[0], PU_LEVEL);
+ endfwrk[1] = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
sprframe = &sprdef->spriteframes[XTRA_ENDING+2];
- endfwrk[2] = W_CachePatchNum(sprframe->lumppat[0], PU_LEVEL);
+ 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)
{
- endfwrk[0] = W_CachePatchName("ENDFWRK3", PU_LEVEL);
- endfwrk[1] = W_CachePatchName("ENDFWRK4", PU_LEVEL);
- endfwrk[2] = W_CachePatchName("ENDFWRK5", PU_LEVEL);
+ endfwrk[0] = W_CachePatchName("ENDFWRK3", PU_PATCH);
+ endfwrk[1] = W_CachePatchName("ENDFWRK4", PU_PATCH);
+ endfwrk[2] = W_CachePatchName("ENDFWRK5", PU_PATCH);
}
- endbrdr[0] = W_CachePatchName("ENDBRDR2", PU_LEVEL);
+ endbrdr[0] = W_CachePatchName("ENDBRDR2", PU_PATCH);
}
else
{
// eggman, skin nonspecific
- endfwrk[0] = W_CachePatchName("ENDFWRK0", PU_LEVEL);
- endfwrk[1] = W_CachePatchName("ENDFWRK1", PU_LEVEL);
- endfwrk[2] = W_CachePatchName("ENDFWRK2", PU_LEVEL);
+ endfwrk[0] = W_CachePatchName("ENDFWRK0", PU_PATCH);
+ endfwrk[1] = W_CachePatchName("ENDFWRK1", PU_PATCH);
+ endfwrk[2] = W_CachePatchName("ENDFWRK2", PU_PATCH);
endbrdr[0] = W_CachePatchName("ENDBRDR0", PU_LEVEL);
}
}
+static void F_CacheGoodEnding(void)
+{
+ endegrk[0] = W_CachePatchName("ENDEGRK2", PU_PATCH);
+ endegrk[1] = W_CachePatchName("ENDEGRK3", PU_PATCH);
+
+ endglow[0] = W_CachePatchName("ENDGLOW2", PU_PATCH);
+ endglow[1] = W_CachePatchName("ENDGLOW3", PU_PATCH);
+
+ endxpld[0] = W_CachePatchName("ENDEGRK4", PU_PATCH);
+}
+
+void F_StartEnding(void)
+{
+ G_SetGamestate(GS_ENDING);
+ wipetypepost = INT16_MAX;
+
+ // Just in case they're open ... somehow
+ M_ClearMenus(true);
+
+ // Save before the credits sequence.
+ if ((!modifiedgame || savemoddata) && !(netgame || multiplayer) && cursaveslot > 0)
+ G_SaveGame((UINT32)cursaveslot);
+
+ gameaction = ga_nothing;
+ paused = false;
+ CON_ToggleOff();
+ S_StopMusic(); // todo: placeholder
+ S_StopSounds();
+
+ finalecount = -10; // what? this totally isn't a hack. why are you asking?
+
+ memset(sparkloffs, 0, sizeof(INT32)*3*2);
+ sparklloop = 0;
+
+ F_CacheEnding();
+}
+
void F_EndingTicker(void)
{
if (++finalecount > STOPPINGPOINT)
@@ -1853,15 +1869,7 @@ void F_EndingTicker(void)
S_ChangeMusicInternal((goodending ? "_endg" : "_endb"), false);
if (goodending && finalecount == INFLECTIONPOINT) // time to swap some assets
- {
- endegrk[0] = W_CachePatchName("ENDEGRK2", PU_LEVEL);
- endegrk[1] = W_CachePatchName("ENDEGRK3", PU_LEVEL);
-
- endglow[0] = W_CachePatchName("ENDGLOW2", PU_LEVEL);
- endglow[1] = W_CachePatchName("ENDGLOW3", PU_LEVEL);
-
- endxpld[0] = W_CachePatchName("ENDEGRK4", PU_LEVEL);
- }
+ F_CacheGoodEnding();
if (++sparklloop == SPARKLLOOPTIME) // time to roll the randomisation again
{
@@ -1880,10 +1888,17 @@ void F_EndingDrawer(void)
INT32 x, y, i, j, parallaxticker;
patch_t *rockpat;
+ if (needpatchrecache)
+ {
+ F_CacheEnding();
+ if (goodending && finalecount >= INFLECTIONPOINT) // time to swap some assets
+ F_CacheGoodEnding();
+ }
+
if (!goodending || finalecount < INFLECTIONPOINT)
- rockpat = W_CachePatchName("ROID0000", PU_LEVEL);
+ rockpat = W_CachePatchName("ROID0000", PU_PATCH);
else
- rockpat = W_CachePatchName(va("ROID00%.2d", 34 - ((finalecount - INFLECTIONPOINT) % 35)), PU_LEVEL);
+ rockpat = W_CachePatchName(va("ROID00%.2d", 34 - ((finalecount - INFLECTIONPOINT) % 35)), PU_PATCH);
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
@@ -2367,11 +2382,11 @@ void F_SkyScroll(INT32 scrollxspeed, INT32 scrollyspeed, const char *patchname)
if (!scrollxspeed && !scrollyspeed)
{
- V_DrawPatchFill(W_CachePatchName(patchname, PU_CACHE));
+ V_DrawPatchFill(W_CachePatchName(patchname, PU_PATCH));
return;
}
- pat = W_CachePatchName(patchname, PU_CACHE);
+ pat = W_CachePatchName(patchname, PU_PATCH);
patwidth = SHORT(pat->width);
patheight = SHORT(pat->height);
@@ -2432,6 +2447,45 @@ else if (strlen(name) <= 6) \
else \
arr[0] = 0;
+static void F_CacheTitleScreen(void)
+{
+ 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)
{
if (menupres[MN_MAIN].musname[0])
@@ -2493,7 +2547,7 @@ void F_StartTitleScreen(void)
camera.x = startpos->x << FRACBITS;
camera.y = startpos->y << FRACBITS;
camera.subsector = R_PointInSubsector(camera.x, camera.y);
- camera.z = camera.subsector->sector->floorheight + ((startpos->options >> ZSHIFT) << FRACBITS);
+ camera.z = camera.subsector->sector->floorheight + (startpos->z << FRACBITS);
camera.angle = (startpos->angle % 360)*ANG1;
camera.aiming = 0;
}
@@ -2528,41 +2582,7 @@ void F_StartTitleScreen(void)
demoDelayLeft = demoDelayTime;
demoIdleLeft = demoIdleTime;
- 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;
- }
- }
+ F_CacheTitleScreen();
}
static void F_UnloadAlacroixGraphics(SINT8 oldttscale)
@@ -2711,6 +2731,9 @@ void F_TitleScreenDrawer(void)
if (modeattacking)
return; // We likely came here from retrying. Don't do a damn thing.
+ if (needpatchrecache && (curttmode != TTMODE_ALACROIX))
+ F_CacheTitleScreen();
+
// Draw that sky!
if (curbgcolor >= 0)
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, curbgcolor);
@@ -2734,6 +2757,12 @@ void F_TitleScreenDrawer(void)
return;
#endif
+ if (needpatchrecache && (curttmode == TTMODE_ALACROIX))
+ {
+ ttloaded[0] = ttloaded[1] = ttloaded[2] = ttloaded[3] = ttloaded[4] = ttloaded[5] = 0;
+ F_LoadAlacroixGraphics(activettscale);
+ }
+
switch(curttmode)
{
case TTMODE_OLD:
@@ -3681,7 +3710,7 @@ void F_ContinueDrawer(void)
V_DrawLevelTitle(x - (V_LevelNameWidth("Continue?")>>1), 16, 0, "Continue?");
// Two stars...
- patch = W_CachePatchName("CONTSTAR", PU_CACHE);
+ patch = W_CachePatchName("CONTSTAR", PU_PATCH);
V_DrawScaledPatch(x-32, 160, 0, patch);
V_DrawScaledPatch(x+32, 160, 0, patch);
@@ -3689,14 +3718,14 @@ void F_ContinueDrawer(void)
if (timeleft > 9)
{
numbuf[7] = '1';
- V_DrawScaledPatch(x - 10, 160, 0, W_CachePatchName(numbuf, PU_CACHE));
+ V_DrawScaledPatch(x - 10, 160, 0, W_CachePatchName(numbuf, PU_PATCH));
numbuf[7] = '0';
- V_DrawScaledPatch(x + 10, 160, 0, W_CachePatchName(numbuf, PU_CACHE));
+ V_DrawScaledPatch(x + 10, 160, 0, W_CachePatchName(numbuf, PU_PATCH));
}
else
{
numbuf[7] = '0'+timeleft;
- V_DrawScaledPatch(x, 160, 0, W_CachePatchName(numbuf, PU_CACHE));
+ V_DrawScaledPatch(x, 160, 0, W_CachePatchName(numbuf, PU_PATCH));
}
// Draw the continue markers! Show continues.
@@ -3723,7 +3752,7 @@ void F_ContinueDrawer(void)
}
// Spotlight
- V_DrawScaledPatch(x, 140, 0, W_CachePatchName("CONTSPOT", PU_CACHE));
+ V_DrawScaledPatch(x, 140, 0, W_CachePatchName("CONTSPOT", PU_PATCH));
// warping laser
if (continuetime)
@@ -3760,7 +3789,7 @@ void F_ContinueDrawer(void)
#define drawchar(dx, dy, n) {\
sprdef = &contskins[n]->sprites[cont_spr2[n][0]];\
sprframe = &sprdef->spriteframes[cont_spr2[n][1]];\
- patch = W_CachePatchNum(sprframe->lumppat[cont_spr2[n][2]], PU_CACHE);\
+ patch = W_CachePatchNum(sprframe->lumppat[cont_spr2[n][2]], PU_PATCH);\
V_DrawFixedPatch((dx), (dy), FRACUNIT, (sprframe->flip & (1<<cont_spr2[n][2])) ? V_FLIP : 0, patch, contcolormaps[n]);\
}
@@ -4024,10 +4053,10 @@ void F_CutsceneDrawer(void)
{
if (cutscenes[cutnum]->scene[scenenum].pichires[picnum])
V_DrawSmallScaledPatch(picxpos, picypos, 0,
- W_CachePatchName(cutscenes[cutnum]->scene[scenenum].picname[picnum], PU_CACHE));
+ W_CachePatchName(cutscenes[cutnum]->scene[scenenum].picname[picnum], PU_PATCH));
else
V_DrawScaledPatch(picxpos,picypos, 0,
- W_CachePatchName(cutscenes[cutnum]->scene[scenenum].picname[picnum], PU_CACHE));
+ W_CachePatchName(cutscenes[cutnum]->scene[scenenum].picname[picnum], PU_PATCH));
}
if (dofadenow && rendermode != render_none)
@@ -4513,10 +4542,10 @@ void F_TextPromptDrawer(void)
{
if (textprompts[cutnum]->page[scenenum].pichires[picnum])
V_DrawSmallScaledPatch(picxpos, picypos, 0,
- W_CachePatchName(textprompts[cutnum]->page[scenenum].picname[picnum], PU_CACHE));
+ W_CachePatchName(textprompts[cutnum]->page[scenenum].picname[picnum], PU_PATCH));
else
V_DrawScaledPatch(picxpos,picypos, 0,
- W_CachePatchName(textprompts[cutnum]->page[scenenum].picname[picnum], PU_CACHE));
+ W_CachePatchName(textprompts[cutnum]->page[scenenum].picname[picnum], PU_PATCH));
}
// Draw background
@@ -4526,7 +4555,7 @@ void F_TextPromptDrawer(void)
if (iconlump != LUMPERROR)
{
INT32 iconx, icony, scale, scaledsize;
- patch = W_CachePatchName(textprompts[cutnum]->page[scenenum].iconname, PU_CACHE);
+ patch = W_CachePatchName(textprompts[cutnum]->page[scenenum].iconname, PU_PATCH);
// scale and center
if (patch->width > patch->height)
diff --git a/src/g_game.c b/src/g_game.c
index f73b6cffde53a42f4fe003df7f799790ae8c2d4a..0a37539728008a0316344555d64833e434c6d660 100644
--- a/src/g_game.c
+++ b/src/g_game.c
@@ -79,7 +79,7 @@ UINT16 mapmusflags; // Track and reset bit
UINT32 mapmusposition; // Position to jump to
INT16 gamemap = 1;
-INT16 maptol;
+UINT32 maptol;
UINT8 globalweather = 0;
INT32 curWeather = PRECIP_NONE;
INT32 cursaveslot = 0; // Auto-save 1p savegame slot
@@ -1190,7 +1190,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
// why build a ticcmd if we're paused?
// Or, for that matter, if we're being reborn.
// ...OR if we're blindfolded. No looking into the floor.
- if (paused || P_AutoPause() || (gamestate == GS_LEVEL && (player->playerstate == PST_REBORN || ((gametype == GT_TAG || gametype == GT_HIDEANDSEEK)
+ if (paused || P_AutoPause() || (gamestate == GS_LEVEL && (player->playerstate == PST_REBORN || ((gametyperules & GTR_TAG)
&& (leveltime < hidetime * TICRATE) && (player->pflags & PF_TAGIT)))))
{//@TODO splitscreen player
cmd->angleturn = (INT16)(*myangle >> 16);
@@ -1709,7 +1709,14 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
//Reset away view if a command is given.
if (ssplayer == 1 && (cmd->forwardmove || cmd->sidemove || cmd->buttons)
&& displayplayer != consoleplayer)
+ {
+#ifdef HAVE_BLUA
+ // Call ViewpointSwitch hooks here.
+ // The viewpoint was forcibly changed.
+ LUAh_ViewpointSwitch(player, &players[displayplayer], true);
+#endif
displayplayer = consoleplayer;
+ }
}
// User has designated that they want
@@ -1826,15 +1833,14 @@ void G_DoLoadLevel(boolean resetplayer)
}
// Setup the level.
- if (!P_SetupLevel(false)) // this never returns false?
+ if (!P_LoadLevel(false)) // this never returns false?
{
// fail so reset game stuff
Command_ExitGame_f();
return;
}
- if (!resetplayer)
- P_FindEmerald();
+ P_FindEmerald();
displayplayer = consoleplayer; // view the guy you are playing
if (!splitscreen && !botingame)
@@ -1871,7 +1877,7 @@ void G_StartTitleCard(void)
{
// The title card has been disabled for this map.
// Oh well.
- if (mapheaderinfo[gamemap-1]->levelflags & LF_NOTITLECARD)
+ if (!G_IsTitleCardAvailable())
{
WipeStageTitle = false;
return;
@@ -1916,6 +1922,23 @@ void G_PreLevelTitleCard(void)
wipestyleflags = WSF_CROSSFADE;
}
+//
+// Returns true if the current level has a title card.
+//
+boolean G_IsTitleCardAvailable(void)
+{
+ // The current level header explicitly disabled the title card.
+ if (mapheaderinfo[gamemap-1]->levelflags & LF_NOTITLECARD)
+ return false;
+
+ // The current gametype doesn't have a title card.
+ if (gametyperules & GTR_NOTITLECARD)
+ return false;
+
+ // The title card is available.
+ return true;
+}
+
INT32 pausedelay = 0;
boolean pausebreakkey = false;
static INT32 camtoggledelay, camtoggledelay2 = 0;
@@ -2006,6 +2029,11 @@ boolean G_Responder(event_t *ev)
if (gamestate == GS_LEVEL && ev->type == ev_keydown
&& (ev->data1 == KEY_F12 || ev->data1 == gamecontrol[gc_viewpoint][0] || ev->data1 == gamecontrol[gc_viewpoint][1]))
{
+ // ViewpointSwitch Lua hook.
+#ifdef HAVE_BLUA
+ UINT8 canSwitchView = 0;
+#endif
+
if (splitscreen || !netgame)
displayplayer = consoleplayer;
else
@@ -2020,6 +2048,15 @@ boolean G_Responder(event_t *ev)
if (!playeringame[displayplayer])
continue;
+#ifdef HAVE_BLUA
+ // Call ViewpointSwitch hooks here.
+ canSwitchView = LUAh_ViewpointSwitch(&players[consoleplayer], &players[displayplayer], false);
+ if (canSwitchView == 1) // Set viewpoint to this player
+ break;
+ else if (canSwitchView == 2) // Skip this player
+ continue;
+#endif
+
if (players[displayplayer].spectator)
continue;
@@ -2628,7 +2665,7 @@ void G_SpawnPlayer(INT32 playernum, boolean starpost)
// -- CTF --
// Order: CTF->DM->Coop
- if (gametype == GT_CTF && players[playernum].ctfteam)
+ if ((gametyperules & (GTR_TEAMFLAGS|GTR_TEAMS)) && players[playernum].ctfteam)
{
if (!(spawnpoint = G_FindCTFStart(playernum)) // find a CTF start
&& !(spawnpoint = G_FindMatchStart(playernum))) // find a DM start
@@ -2637,7 +2674,7 @@ void G_SpawnPlayer(INT32 playernum, boolean starpost)
// -- DM/Tag/CTF-spectator/etc --
// Order: DM->CTF->Coop
- else if (gametype == GT_MATCH || gametype == GT_TEAMMATCH || gametype == GT_CTF
+ else if ((gametyperules & GTR_DEATHMATCHSTARTS) || gametype == GT_MATCH || gametype == GT_TEAMMATCH || gametype == GT_CTF
|| ((gametype == GT_TAG || gametype == GT_HIDEANDSEEK) && !(players[playernum].pflags & PF_TAGIT)))
{
if (!(spawnpoint = G_FindMatchStart(playernum)) // find a DM start
@@ -2684,7 +2721,7 @@ mapthing_t *G_FindCTFStart(INT32 playernum)
if (!numredctfstarts && !numbluectfstarts) //why even bother, eh?
{
- if (playernum == consoleplayer || (splitscreen && playernum == secondarydisplayplayer))
+ if ((gametyperules & GTR_TEAMFLAGS) && (playernum == consoleplayer || (splitscreen && playernum == secondarydisplayplayer)))
CONS_Alert(CONS_WARNING, M_GetText("No CTF starts in this map!\n"));
return NULL;
}
@@ -2913,7 +2950,7 @@ void G_DoReborn(INT32 playernum)
}
if (!countdowntimeup && (mapheaderinfo[gamemap-1]->levelflags & LF_NORELOAD))
{
- P_LoadThingsOnly();
+ P_RespawnThings();
for (i = 0; i < MAXPLAYERS; i++)
{
@@ -3090,7 +3127,7 @@ void G_ExitLevel(void)
CV_SetValue(&cv_teamscramble, cv_scrambleonchange.value);
}
- if (gametype != GT_COOP)
+ if (!(gametyperules & GTR_CAMPAIGN))
CONS_Printf(M_GetText("The round has ended.\n"));
// Remove CEcho text on round end.
@@ -3122,6 +3159,221 @@ const char *Gametype_Names[NUMGAMETYPES] =
"CTF" // GT_CTF
};
+// For dehacked
+const char *Gametype_ConstantNames[NUMGAMETYPES] =
+{
+ "GT_COOP", // GT_COOP
+ "GT_COMPETITION", // GT_COMPETITION
+ "GT_RACE", // GT_RACE
+
+ "GT_MATCH", // GT_MATCH
+ "GT_TEAMMATCH", // GT_TEAMMATCH
+
+ "GT_TAG", // GT_TAG
+ "GT_HIDEANDSEEK", // GT_HIDEANDSEEK
+
+ "GT_CTF" // GT_CTF
+};
+
+// Gametype rules
+UINT32 gametypedefaultrules[NUMGAMETYPES] =
+{
+ // Co-op
+ GTR_CAMPAIGN|GTR_LIVES|GTR_SPAWNENEMIES|GTR_ALLOWEXIT|GTR_EMERALDHUNT|GTR_EMERALDTOKENS|GTR_SPECIALSTAGES,
+ // Competition
+ GTR_RACE|GTR_LIVES|GTR_SPAWNENEMIES|GTR_EMERALDTOKENS|GTR_SPAWNINVUL|GTR_ALLOWEXIT,
+ // Race
+ GTR_RACE|GTR_SPAWNENEMIES|GTR_SPAWNINVUL|GTR_ALLOWEXIT,
+
+ // Match
+ GTR_RINGSLINGER|GTR_FIRSTPERSON|GTR_SPECTATORS|GTR_POINTLIMIT|GTR_TIMELIMIT|GTR_MATCHEMERALDS|GTR_SPAWNINVUL|GTR_PITYSHIELD|GTR_DEATHPENALTY,
+ // Team Match
+ GTR_RINGSLINGER|GTR_FIRSTPERSON|GTR_SPECTATORS|GTR_TEAMS|GTR_POINTLIMIT|GTR_TIMELIMIT|GTR_SPAWNINVUL|GTR_PITYSHIELD,
+
+ // Tag
+ GTR_RINGSLINGER|GTR_FIRSTPERSON|GTR_TAG|GTR_SPECTATORS|GTR_POINTLIMIT|GTR_TIMELIMIT|GTR_HIDETIME|GTR_BLINDFOLDED|GTR_SPAWNINVUL,
+ // Hide and Seek
+ GTR_RINGSLINGER|GTR_FIRSTPERSON|GTR_TAG|GTR_SPECTATORS|GTR_POINTLIMIT|GTR_TIMELIMIT|GTR_HIDETIME|GTR_BLINDFOLDED|GTR_SPAWNINVUL,
+
+ // CTF
+ GTR_RINGSLINGER|GTR_FIRSTPERSON|GTR_SPECTATORS|GTR_TEAMS|GTR_TEAMFLAGS|GTR_POINTLIMIT|GTR_TIMELIMIT|GTR_MATCHEMERALDS|GTR_SPAWNINVUL|GTR_PITYSHIELD,
+};
+
+//
+// G_SetGametype
+//
+// Set a new gametype, also setting gametype rules accordingly. Yay!
+//
+void G_SetGametype(INT16 gtype)
+{
+ gametype = gtype;
+ gametyperules = gametypedefaultrules[gametype];
+}
+
+//
+// G_AddGametype
+//
+// Add a gametype. Returns the new gametype number.
+//
+INT16 G_AddGametype(UINT32 rules)
+{
+ INT16 newgtype = gametypecount;
+ gametypecount++;
+
+ // Set gametype rules.
+ gametypedefaultrules[newgtype] = rules;
+ Gametype_Names[newgtype] = "???";
+
+ // Update gametype_cons_t accordingly.
+ G_UpdateGametypeSelections();
+
+ return newgtype;
+}
+
+//
+// G_AddGametypeConstant
+//
+// Self-explanatory. Filters out "bad" characters.
+//
+void G_AddGametypeConstant(INT16 gtype, const char *newgtconst)
+{
+ char *gtconst = Z_Malloc(strlen(newgtconst) + 3, PU_STATIC, NULL);
+ // Copy GT_ and the gametype name.
+ strcpy(gtconst, "GT_");
+ strcat(gtconst, newgtconst);
+ // Make uppercase.
+ strupr(gtconst);
+ // Remove characters.
+#define REMOVECHAR(chr) \
+ { \
+ char *chrfind = strchr(gtconst, chr); \
+ while (chrfind) \
+ { \
+ *chrfind = '_'; \
+ chrfind = strchr(chrfind, chr); \
+ } \
+ }
+
+ // Space
+ REMOVECHAR(' ')
+ // Used for operations
+ REMOVECHAR('+')
+ REMOVECHAR('-')
+ REMOVECHAR('*')
+ REMOVECHAR('/')
+ REMOVECHAR('%')
+ REMOVECHAR('^')
+ // Part of Lua's syntax
+ REMOVECHAR('#')
+ REMOVECHAR('=')
+ REMOVECHAR('~')
+ REMOVECHAR('<')
+ REMOVECHAR('>')
+ REMOVECHAR('(')
+ REMOVECHAR(')')
+ REMOVECHAR('{')
+ REMOVECHAR('}')
+ REMOVECHAR('[')
+ REMOVECHAR(']')
+ REMOVECHAR(':')
+ REMOVECHAR(';')
+ REMOVECHAR(',')
+ REMOVECHAR('.')
+
+#undef REMOVECHAR
+
+ // Finally, set the constant string.
+ Gametype_ConstantNames[gtype] = gtconst;
+}
+
+//
+// G_UpdateGametypeSelections
+//
+// Updates gametype_cons_t.
+//
+void G_UpdateGametypeSelections(void)
+{
+ INT32 i;
+ for (i = 0; i < gametypecount; i++)
+ {
+ gametype_cons_t[i].value = i;
+ gametype_cons_t[i].strvalue = Gametype_Names[i];
+ }
+ gametype_cons_t[NUMGAMETYPES].value = 0;
+ gametype_cons_t[NUMGAMETYPES].strvalue = NULL;
+}
+
+//
+// G_SetGametypeDescription
+//
+// Set a description for the specified gametype.
+// (Level platter)
+//
+void G_SetGametypeDescription(INT16 gtype, char *descriptiontext, UINT8 leftcolor, UINT8 rightcolor)
+{
+ if (descriptiontext != NULL)
+ strncpy(gametypedesc[gtype].notes, descriptiontext, 441);
+ gametypedesc[gtype].col[0] = leftcolor;
+ gametypedesc[gtype].col[1] = rightcolor;
+}
+
+// Gametype rankings
+INT16 gametyperankings[NUMGAMETYPES] =
+{
+ GT_COOP,
+ GT_COMPETITION,
+ GT_RACE,
+
+ GT_MATCH,
+ GT_TEAMMATCH,
+
+ GT_TAG,
+ GT_HIDEANDSEEK,
+
+ GT_CTF,
+};
+
+// Gametype to TOL (Type Of Level)
+UINT32 gametypetol[NUMGAMETYPES] =
+{
+ TOL_COOP, // Co-op
+ TOL_COMPETITION, // Competition
+ TOL_RACE, // Race
+
+ TOL_MATCH, // Match
+ TOL_MATCH, // Team Match
+
+ TOL_TAG, // Tag
+ TOL_TAG, // Hide and Seek
+
+ TOL_CTF, // CTF
+};
+
+//
+// G_AddTOL
+//
+// Adds a type of level.
+//
+void G_AddTOL(UINT32 newtol, const char *tolname)
+{
+ TYPEOFLEVEL[numtolinfo].name = Z_StrDup(tolname);
+ TYPEOFLEVEL[numtolinfo].flag = newtol;
+ numtolinfo++;
+
+ TYPEOFLEVEL[numtolinfo].name = NULL;
+ TYPEOFLEVEL[numtolinfo].flag = 0;
+}
+
+//
+// G_AddTOL
+//
+// Assigns a type of level to a gametype.
+//
+void G_AddGametypeTOL(INT16 gtype, UINT32 newtol)
+{
+ gametypetol[gtype] = newtol;
+}
+
//
// G_GetGametypeByName
//
@@ -3131,7 +3383,7 @@ INT32 G_GetGametypeByName(const char *gametypestr)
{
INT32 i;
- for (i = 0; i < NUMGAMETYPES; i++)
+ for (i = 0; i < gametypecount; i++)
if (!stricmp(gametypestr, Gametype_Names[i]))
return i;
@@ -3164,8 +3416,8 @@ boolean G_IsSpecialStage(INT32 mapnum)
//
boolean G_GametypeUsesLives(void)
{
- // Coop, Competitive
- if ((gametype == GT_COOP || gametype == GT_COMPETITION)
+ // Coop, Competitive
+ if ((gametyperules & GTR_LIVES)
&& !(modeattacking || metalrecording) // No lives in Time Attack
&& !G_IsSpecialStage(gamemap)
&& !(maptol & TOL_NIGHTS)) // No lives in NiGHTS
@@ -3181,7 +3433,7 @@ boolean G_GametypeUsesLives(void)
//
boolean G_GametypeHasTeams(void)
{
- return (gametype == GT_TEAMMATCH || gametype == GT_CTF);
+ return (gametyperules & GTR_TEAMS);
}
//
@@ -3192,7 +3444,7 @@ boolean G_GametypeHasTeams(void)
//
boolean G_GametypeHasSpectators(void)
{
- return (gametype != GT_COOP && gametype != GT_COMPETITION && gametype != GT_RACE);
+ return (gametyperules & GTR_SPECTATORS);
}
//
@@ -3203,7 +3455,7 @@ boolean G_GametypeHasSpectators(void)
//
boolean G_RingSlingerGametype(void)
{
- return ((gametype != GT_COOP && gametype != GT_COMPETITION && gametype != GT_RACE) || (cv_ringslinger.value));
+ return ((gametyperules & GTR_RINGSLINGER) || (cv_ringslinger.value));
}
//
@@ -3213,7 +3465,7 @@ boolean G_RingSlingerGametype(void)
//
boolean G_PlatformGametype(void)
{
- return (gametype == GT_COOP || gametype == GT_RACE || gametype == GT_COMPETITION);
+ return (!(gametyperules & GTR_RINGSLINGER));
}
//
@@ -3223,7 +3475,7 @@ boolean G_PlatformGametype(void)
//
boolean G_TagGametype(void)
{
- return (gametype == GT_TAG || gametype == GT_HIDEANDSEEK);
+ return (gametyperules & GTR_TAG);
}
/** Get the typeoflevel flag needed to indicate support of a gametype.
@@ -3234,18 +3486,9 @@ boolean G_TagGametype(void)
*/
INT16 G_TOLFlag(INT32 pgametype)
{
- if (!multiplayer) return TOL_SP;
- if (pgametype == GT_COOP) return TOL_COOP;
- if (pgametype == GT_COMPETITION) return TOL_COMPETITION;
- if (pgametype == GT_RACE) return TOL_RACE;
- if (pgametype == GT_MATCH) return TOL_MATCH;
- if (pgametype == GT_TEAMMATCH) return TOL_MATCH;
- if (pgametype == GT_TAG) return TOL_TAG;
- if (pgametype == GT_HIDEANDSEEK) return TOL_TAG;
- if (pgametype == GT_CTF) return TOL_CTF;
-
- CONS_Alert(CONS_ERROR, M_GetText("Unknown gametype! %d\n"), pgametype);
- return INT16_MAX;
+ if (!multiplayer)
+ return TOL_SP;
+ return gametypetol[pgametype];
}
/** Select a random map with the given typeoflevel flags.
@@ -3256,7 +3499,7 @@ INT16 G_TOLFlag(INT32 pgametype)
* has those flags.
* \author Graue <graue@oceanbase.org>
*/
-static INT16 RandMap(INT16 tolflags, INT16 pprevmap)
+static INT16 RandMap(UINT32 tolflags, INT16 pprevmap)
{
INT16 *okmaps = Z_Malloc(NUMMAPS * sizeof(INT16), PU_STATIC, NULL);
INT32 numokmaps = 0;
@@ -3414,10 +3657,10 @@ static void G_DoCompleted(void)
I_Error("Followed map %d to invalid map %d\n", prevmap + 1, nextmap + 1);
// wrap around in race
- if (nextmap >= 1100-1 && nextmap <= 1102-1 && (gametype == GT_RACE || gametype == GT_COMPETITION))
+ if (nextmap >= 1100-1 && nextmap <= 1102-1 && !(gametyperules & GTR_CAMPAIGN))
nextmap = (INT16)(spstage_start-1);
- if ((gottoken = (gametype == GT_COOP && token)))
+ if ((gottoken = ((gametyperules & GTR_SPECIALSTAGES) && token)))
{
token--;
@@ -3437,7 +3680,7 @@ static void G_DoCompleted(void)
automapactive = false;
- if (gametype != GT_COOP)
+ if (!(gametyperules & GTR_CAMPAIGN))
{
if (cv_advancemap.value == 0) // Stay on same map.
nextmap = prevmap;
@@ -6615,23 +6858,20 @@ void G_AddGhost(char *defdemoname)
I_Assert(mthing);
{ // A bit more complex than P_SpawnPlayer because ghosts aren't solid and won't just push themselves out of the ceiling.
fixed_t z,f,c;
+ fixed_t offset = mthing->z << FRACBITS;
gh->mo = P_SpawnMobj(mthing->x << FRACBITS, mthing->y << FRACBITS, 0, MT_GHOST);
- gh->mo->angle = FixedAngle(mthing->angle*FRACUNIT);
+ gh->mo->angle = FixedAngle(mthing->angle << FRACBITS);
f = gh->mo->floorz;
c = gh->mo->ceilingz - mobjinfo[MT_PLAYER].height;
if (!!(mthing->options & MTF_AMBUSH) ^ !!(mthing->options & MTF_OBJECTFLIP))
{
- z = c;
- if (mthing->options >> ZSHIFT)
- z -= ((mthing->options >> ZSHIFT) << FRACBITS);
+ z = c - offset;
if (z < f)
z = f;
}
else
{
- z = f;
- if (mthing->options >> ZSHIFT)
- z += ((mthing->options >> ZSHIFT) << FRACBITS);
+ z = f + offset;
if (z > c)
z = c;
}
diff --git a/src/g_game.h b/src/g_game.h
index de814109ecc668f9b16401af51a9f69a1e804b8d..b8861c0da97f1846be8552e1578ce1b47c45fae5 100644
--- a/src/g_game.h
+++ b/src/g_game.h
@@ -167,6 +167,7 @@ void G_DeferedInitNew(boolean pultmode, const char *mapname, INT32 pickedchar,
void G_DoLoadLevel(boolean resetplayer);
void G_StartTitleCard(void);
void G_PreLevelTitleCard(void);
+boolean G_IsTitleCardAvailable(void);
void G_DeferedPlayDemo(const char *demo);
// Can be called by the startup code or M_Responder, calls P_SetupLevel.
@@ -226,6 +227,18 @@ ATTRNORETURN void FUNCNORETURN G_StopMetalRecording(boolean kill);
void G_StopDemo(void);
boolean G_CheckDemoStatus(void);
+extern UINT32 gametypedefaultrules[NUMGAMETYPES];
+extern UINT32 gametypetol[NUMGAMETYPES];
+extern INT16 gametyperankings[NUMGAMETYPES];
+
+void G_SetGametype(INT16 gametype);
+INT16 G_AddGametype(UINT32 rules);
+void G_AddGametypeConstant(INT16 gtype, const char *newgtconst);
+void G_UpdateGametypeSelections(void);
+void G_AddTOL(UINT32 newtol, const char *tolname);
+void G_AddGametypeTOL(INT16 gtype, UINT32 newtol);
+void G_SetGametypeDescription(INT16 gtype, char *descriptiontext, UINT8 leftcolor, UINT8 rightcolor);
+
INT32 G_GetGametypeByName(const char *gametypestr);
boolean G_IsSpecialStage(INT32 mapnum);
boolean G_GametypeUsesLives(void);
diff --git a/src/hardware/hw_bsp.c b/src/hardware/hw_bsp.c
index 9e454bcd5275dd28150e33f053fc5ee20c79ddb0..f8d4f43d9b285197c3b43743eb5bfdd83e0ce4be 100644
--- a/src/hardware/hw_bsp.c
+++ b/src/hardware/hw_bsp.c
@@ -836,8 +836,10 @@ static INT32 SolveTProblem(void)
return 0;
CONS_Debug(DBG_RENDER, "Solving T-joins. This may take a while. Please wait...\n");
+#ifdef HWR_LOADING_SCREEN
CON_Drawer(); //let the user know what we are doing
I_FinishUpdate(); // page flip or blit buffer
+#endif
numsplitpoly = 0;
@@ -964,9 +966,9 @@ void HWR_CreatePlanePolygons(INT32 bspnum)
CONS_Debug(DBG_RENDER, "Creating polygons, please wait...\n");
#ifdef HWR_LOADING_SCREEN
ls_count = ls_percent = 0; // reset the loading status
-#endif
CON_Drawer(); //let the user know what we are doing
I_FinishUpdate(); // page flip or blit buffer
+#endif
HWR_ClearPolys();
diff --git a/src/hardware/hw_cache.c b/src/hardware/hw_cache.c
index ea16fb6d740626aa1f97a67be7d76041fa011d95..c47833187b1af03f7308d3844fbcce51baa22bd0 100644
--- a/src/hardware/hw_cache.c
+++ b/src/hardware/hw_cache.c
@@ -764,13 +764,12 @@ void HWR_MakePatch (const patch_t *patch, GLPatch_t *grPatch, GLMipmap_t *grMipm
// CACHING HANDLING
// =================================================
-static size_t gr_numtextures; // Texture count
+static size_t gr_numtextures = 0; // Texture count
static GLTexture_t *gr_textures; // For all textures
static GLTexture_t *gr_flats; // For all (texture) flats, as normal flats don't need to be cached
void HWR_InitTextureCache(void)
{
- gr_numtextures = 0;
gr_textures = NULL;
gr_flats = NULL;
}
@@ -958,6 +957,9 @@ static void HWR_CacheTextureAsFlat(GLMipmap_t *grMipmap, INT32 texturenum)
{
UINT8 *flat;
+ if (needpatchflush)
+ W_FlushCachedPatches();
+
// setup the texture info
#ifdef GLIDE_API_COMPATIBILITY
grMipmap->grInfo.smallLodLog2 = GR_LOD_LOG2_64;
@@ -983,6 +985,9 @@ void HWR_LiterallyGetFlat(lumpnum_t flatlumpnum)
if (flatlumpnum == LUMPERROR)
return;
+ if (needpatchflush)
+ W_FlushCachedPatches();
+
grmip = HWR_GetCachedGLPatch(flatlumpnum)->mipmap;
if (!grmip->downloaded && !grmip->grInfo.data)
HWR_CacheFlat(grmip, flatlumpnum);
@@ -1061,6 +1066,9 @@ static void HWR_LoadMappedPatch(GLMipmap_t *grmip, GLPatch_t *gpatch)
// -----------------+
void HWR_GetPatch(GLPatch_t *gpatch)
{
+ if (needpatchflush)
+ W_FlushCachedPatches();
+
// is it in hardware cache
if (!gpatch->mipmap->downloaded && !gpatch->mipmap->grInfo.data)
{
@@ -1091,6 +1099,9 @@ void HWR_GetMappedPatch(GLPatch_t *gpatch, const UINT8 *colormap)
{
GLMipmap_t *grmip, *newmip;
+ if (needpatchflush)
+ W_FlushCachedPatches();
+
if (colormap == colormaps || colormap == NULL)
{
// Load the default (green) color in doom cache (temporary?) AND hardware cache
@@ -1216,6 +1227,9 @@ GLPatch_t *HWR_GetPic(lumpnum_t lumpnum)
{
GLPatch_t *grpatch;
+ if (needpatchflush)
+ W_FlushCachedPatches();
+
grpatch = HWR_GetCachedGLPatch(lumpnum);
if (!grpatch->mipmap->downloaded && !grpatch->mipmap->grInfo.data)
@@ -1419,6 +1433,9 @@ void HWR_GetFadeMask(lumpnum_t fademasklumpnum)
{
GLMipmap_t *grmip;
+ if (needpatchflush)
+ W_FlushCachedPatches();
+
grmip = HWR_GetCachedGLPatch(fademasklumpnum)->mipmap;
if (!grmip->downloaded && !grmip->grInfo.data)
diff --git a/src/hardware/hw_defs.h b/src/hardware/hw_defs.h
index 5f2d907bdee607d0b74051bad5f99baf5d0da823..95882b03eb93bb57fc429a12c648fdd8f5167c7b 100644
--- a/src/hardware/hw_defs.h
+++ b/src/hardware/hw_defs.h
@@ -115,13 +115,11 @@ typedef struct
FLOAT fovxangle, fovyangle;
UINT8 splitscreen;
boolean flip; // screenflip
-#ifdef ROTSPRITE
boolean roll;
SINT8 rollflip;
FLOAT rollangle; // done to not override USE_FTRANSFORM_ANGLEZ
UINT8 rotaxis;
FLOAT centerx, centery;
-#endif
#ifdef USE_FTRANSFORM_MIRROR
boolean mirror; // SRB2Kart: Encore Mode
#endif
diff --git a/src/hardware/hw_draw.c b/src/hardware/hw_draw.c
index 4519e1280018d4f69015cba9e32b4df015d190bb..598a635aa47c18b4b79697efdc131e601ab97607 100644
--- a/src/hardware/hw_draw.c
+++ b/src/hardware/hw_draw.c
@@ -992,7 +992,7 @@ void HWR_DrawViewBorder(INT32 clearlines)
// top edge
if (clearlines > basewindowy - 8)
{
- patch = W_CachePatchNum(viewborderlump[BRDR_T], PU_CACHE);
+ patch = W_CachePatchNum(viewborderlump[BRDR_T], PU_PATCH);
for (x = 0; x < baseviewwidth; x += 8)
HWR_DrawPatch(patch, basewindowx + x, basewindowy - 8,
0);
@@ -1001,7 +1001,7 @@ void HWR_DrawViewBorder(INT32 clearlines)
// bottom edge
if (clearlines > basewindowy + baseviewheight)
{
- patch = W_CachePatchNum(viewborderlump[BRDR_B], PU_CACHE);
+ patch = W_CachePatchNum(viewborderlump[BRDR_B], PU_PATCH);
for (x = 0; x < baseviewwidth; x += 8)
HWR_DrawPatch(patch, basewindowx + x,
basewindowy + baseviewheight, 0);
@@ -1010,7 +1010,7 @@ void HWR_DrawViewBorder(INT32 clearlines)
// left edge
if (clearlines > basewindowy)
{
- patch = W_CachePatchNum(viewborderlump[BRDR_L], PU_CACHE);
+ patch = W_CachePatchNum(viewborderlump[BRDR_L], PU_PATCH);
for (y = 0; y < baseviewheight && basewindowy + y < clearlines;
y += 8)
{
@@ -1022,7 +1022,7 @@ void HWR_DrawViewBorder(INT32 clearlines)
// right edge
if (clearlines > basewindowy)
{
- patch = W_CachePatchNum(viewborderlump[BRDR_R], PU_CACHE);
+ patch = W_CachePatchNum(viewborderlump[BRDR_R], PU_PATCH);
for (y = 0; y < baseviewheight && basewindowy+y < clearlines;
y += 8)
{
@@ -1034,22 +1034,22 @@ void HWR_DrawViewBorder(INT32 clearlines)
// Draw beveled corners.
if (clearlines > basewindowy - 8)
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_TL],
- PU_CACHE),
+ PU_PATCH),
basewindowx - 8, basewindowy - 8, 0);
if (clearlines > basewindowy - 8)
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_TR],
- PU_CACHE),
+ PU_PATCH),
basewindowx + baseviewwidth, basewindowy - 8, 0);
if (clearlines > basewindowy+baseviewheight)
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_BL],
- PU_CACHE),
+ PU_PATCH),
basewindowx - 8, basewindowy + baseviewheight, 0);
if (clearlines > basewindowy + baseviewheight)
HWR_DrawPatch(W_CachePatchNum(viewborderlump[BRDR_BR],
- PU_CACHE),
+ PU_PATCH),
basewindowx + baseviewwidth,
basewindowy + baseviewheight, 0);
}
diff --git a/src/hardware/hw_main.c b/src/hardware/hw_main.c
index 6ef48f222cede2019b1f7be09f261fb234e62f9a..276a666704ccf3de09b431fbc4303d7536006457 100644
--- a/src/hardware/hw_main.c
+++ b/src/hardware/hw_main.c
@@ -832,7 +832,7 @@ static void HWR_DrawSegsSplats(FSurfaceInfo * pSurf)
if (!M_PointInBox(segbbox,splat->v1.x,splat->v1.y) && !M_PointInBox(segbbox,splat->v2.x,splat->v2.y))
continue;
- gpatch = W_CachePatchNum(splat->patch, PU_CACHE);
+ gpatch = W_CachePatchNum(splat->patch, PU_PATCH);
HWR_GetPatch(gpatch);
wallVerts[0].x = wallVerts[3].x = FIXED_TO_FLOAT(splat->v1.x);
@@ -2714,6 +2714,8 @@ static void HWR_AddLine(seg_t * line)
static sector_t tempsec;
fixed_t v1x, v1y, v2x, v2y; // the seg's vertexes as fixed_t
+ if (line->glseg)
+ return;
#ifdef POLYOBJECTS
if (line->polyseg && !(line->polyseg->flags & POF_RENDERSIDES))
return;
@@ -5501,17 +5503,12 @@ static void HWR_ProjectSprite(mobj_t *thing)
fixed_t spr_offset, spr_topoffset;
#ifdef ROTSPRITE
patch_t *rotsprite = NULL;
- angle_t arollangle;
- UINT32 rollangle;
+ INT32 rollangle = 0;
#endif
if (!thing)
return;
-#ifdef ROTSPRITE
- arollangle = thing->rollangle;
- rollangle = AngleFixed(arollangle)>>FRACBITS;
-#endif
this_scale = FIXED_TO_FLOAT(thing->scale);
// transform the origin point
@@ -5618,11 +5615,11 @@ static void HWR_ProjectSprite(mobj_t *thing)
spr_topoffset = spritecachedinfo[lumpoff].topoffset;
#ifdef ROTSPRITE
- if (rollangle > 0)
+ if (thing->rollangle)
{
+ rollangle = R_GetRollAngle(thing->rollangle);
if (!sprframe->rotsprite.cached[rot])
R_CacheRotSprite(thing->sprite, (thing->frame & FF_FRAMEMASK), sprinfo, sprframe, rot, flip);
- rollangle /= ROTANGDIFF;
rotsprite = sprframe->rotsprite.patch[rot][rollangle];
if (rotsprite != NULL)
{
@@ -6659,7 +6656,13 @@ void HWR_AddCommands(void)
void HWR_AddSessionCommands(void)
{
+ static boolean alreadycalled = false;
+ if (alreadycalled)
+ return;
+
CV_RegisterVar(&cv_granisotropicmode);
+
+ alreadycalled = true;
}
// --------------------------------------------------------------------------
@@ -6695,6 +6698,17 @@ void HWR_Startup(void)
startupdone = true;
}
+// --------------------------------------------------------------------------
+// Called after switching to the hardware renderer
+// --------------------------------------------------------------------------
+void HWR_Switch(void)
+{
+ // Set special states from CVARs
+ HWD.pfnSetSpecialState(HWD_SET_MODEL_LIGHTING, cv_grmodellighting.value);
+ HWD.pfnSetSpecialState(HWD_SET_FOG_DENSITY, cv_grfogdensity.value);
+ HWD.pfnSetSpecialState(HWD_SET_TEXTUREFILTERMODE, cv_grfiltermode.value);
+ HWD.pfnSetSpecialState(HWD_SET_TEXTUREANISOTROPICMODE, cv_granisotropicmode.value);
+}
// --------------------------------------------------------------------------
// Free resources allocated by the hardware renderer
diff --git a/src/hardware/hw_main.h b/src/hardware/hw_main.h
index e46aa9801cdda903ad0ad830dad7fa5de7059c56..5733382263691a6f28d410d023c604b384a9d257 100644
--- a/src/hardware/hw_main.h
+++ b/src/hardware/hw_main.h
@@ -29,6 +29,7 @@
// Startup & Shutdown the hardware mode renderer
void HWR_Startup(void);
+void HWR_Switch(void);
void HWR_Shutdown(void);
void HWR_drawAMline(const fline_t *fl, INT32 color);
diff --git a/src/hardware/hw_md2.c b/src/hardware/hw_md2.c
index 630c1e181df8d6055284569606841af5c71123a8..3800b6ad98ff9b89af7ee38a7c328a87abcbf580 100644
--- a/src/hardware/hw_md2.c
+++ b/src/hardware/hw_md2.c
@@ -1148,10 +1148,8 @@ boolean HWR_DrawModel(gr_vissprite_t *spr)
const UINT8 flip = (UINT8)(!(spr->mobj->eflags & MFE_VERTICALFLIP) != !(spr->mobj->frame & FF_VERTICALFLIP));
spritedef_t *sprdef;
spriteframe_t *sprframe;
-#ifdef ROTSPRITE
spriteinfo_t *sprinfo;
angle_t ang;
-#endif
INT32 mod;
float finalscale;
@@ -1175,16 +1173,12 @@ boolean HWR_DrawModel(gr_vissprite_t *spr)
{
md2 = &md2_playermodels[(skin_t*)spr->mobj->skin-skins];
md2->skin = (skin_t*)spr->mobj->skin-skins;
-#ifdef ROTSPRITE
sprinfo = &((skin_t *)spr->mobj->skin)->sprinfo[spr->mobj->sprite2];
-#endif
}
else
{
md2 = &md2_models[spr->mobj->sprite];
-#ifdef ROTSPRITE
sprinfo = &spriteinfo[spr->mobj->sprite];
-#endif
}
if (md2->error)
@@ -1384,9 +1378,8 @@ boolean HWR_DrawModel(gr_vissprite_t *spr)
p.angley = FIXED_TO_FLOAT(anglef);
}
-#ifdef ROTSPRITE
p.rollangle = 0.0f;
- p.rollflip = 0;
+ p.rollflip = 1;
p.rotaxis = 0;
if (spr->mobj->rollangle)
{
@@ -1409,7 +1402,6 @@ boolean HWR_DrawModel(gr_vissprite_t *spr)
else if ((sprframe->rotate & SRF_LEFT) && (ang >= ANGLE_180)) // See from left
p.rollflip = -1;
}
-#endif
p.anglex = 0.0f;
diff --git a/src/hardware/r_opengl/r_opengl.c b/src/hardware/r_opengl/r_opengl.c
index 129bf5678497aae3d4833fc3f0bed113d164be6c..97b3b98be576753f7b815ce3e49d7c3f825e319e 100644
--- a/src/hardware/r_opengl/r_opengl.c
+++ b/src/hardware/r_opengl/r_opengl.c
@@ -2076,7 +2076,6 @@ static void DrawModelEx(model_t *model, INT32 frameIndex, INT32 duration, INT32
pglRotatef(pos->angley, 0.0f, -1.0f, 0.0f);
pglRotatef(pos->anglex, 1.0f, 0.0f, 0.0f);
-#ifdef ROTSPRITE
if (pos->roll)
{
float roll = (1.0f * pos->rollflip);
@@ -2089,7 +2088,6 @@ static void DrawModelEx(model_t *model, INT32 frameIndex, INT32 duration, INT32
pglRotatef(pos->rollangle, roll, 0.0f, 0.0f);
pglTranslatef(-pos->centerx, -pos->centery, 0);
}
-#endif
pglScalef(scalex, scaley, scalez);
diff --git a/src/hu_stuff.c b/src/hu_stuff.c
index ccfeed4f1abb201a9370e1e1ad55247f1aab3ff5..7a1f71bc5510e2ad22d143526aab5508c170fe85 100644
--- a/src/hu_stuff.c
+++ b/src/hu_stuff.c
@@ -2066,7 +2066,7 @@ static void HU_drawGametype(void)
{
const char *strvalue = NULL;
- if (gametype < 0 || gametype >= NUMGAMETYPES)
+ if (gametype < 0 || gametype >= gametypecount)
return; // not a valid gametype???
strvalue = Gametype_Names[gametype];
@@ -2117,6 +2117,9 @@ static void HU_DrawDemoInfo(void)
//
void HU_Drawer(void)
{
+ if (needpatchrecache)
+ R_ReloadHUDGraphics();
+
#ifndef NONET
// draw chat string plus cursor
if (chat_on)
@@ -2375,7 +2378,7 @@ void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, I
for (i = 0; i < scorelines; i++)
{
- if (players[tab[i].num].spectator && gametype != GT_COOP)
+ if (players[tab[i].num].spectator && gametyperankings[gametype] != GT_COOP)
continue; //ignore them.
greycheck = greycheckdef;
@@ -2438,7 +2441,7 @@ void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, I
}
}
- if (G_GametypeUsesLives() && !(gametype == GT_COOP && (cv_cooplives.value == 0 || cv_cooplives.value == 3)) && (players[tab[i].num].lives != INFLIVES)) //show lives
+ if (G_GametypeUsesLives() && !(gametyperankings[gametype] == GT_COOP && (cv_cooplives.value == 0 || cv_cooplives.value == 3)) && (players[tab[i].num].lives != INFLIVES)) //show lives
V_DrawRightAlignedString(x, y+4, V_ALLOWLOWERCASE|(greycheck ? V_60TRANS : 0), va("%dx", players[tab[i].num].lives));
else if (G_TagGametype() && players[tab[i].num].pflags & PF_TAGIT)
{
@@ -2451,7 +2454,7 @@ void HU_DrawTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scorelines, I
if (players[tab[i].num].exiting || (players[tab[i].num].pflags & PF_FINISHED))
V_DrawSmallScaledPatch(x - SHORT(exiticon->width)/2 - 1, y-3, 0, exiticon);
- if (gametype == GT_RACE)
+ if (gametyperankings[gametype] == GT_RACE)
{
if (circuitmap)
{
@@ -2545,7 +2548,7 @@ static void HU_Draw32TeamTabRankings(playersort_t *tab, INT32 whiteplayer)
| (greycheck ? 0 : V_TRANSLUCENT)
| V_ALLOWLOWERCASE, name);
- if (gametype == GT_CTF)
+ if (gametyperules & GTR_TEAMFLAGS)
{
if (players[tab[i].num].gotflag & GF_REDFLAG) // Red
V_DrawFixedPatch((x-10)*FRACUNIT, (y)*FRACUNIT, FRACUNIT/4, 0, rflagico, 0);
@@ -2673,7 +2676,7 @@ void HU_DrawTeamTabRankings(playersort_t *tab, INT32 whiteplayer)
| (greycheck ? V_TRANSLUCENT : 0)
| V_ALLOWLOWERCASE, name);
- if (gametype == GT_CTF)
+ if (gametyperules & GTR_TEAMFLAGS)
{
if (players[tab[i].num].gotflag & GF_REDFLAG) // Red
V_DrawSmallScaledPatch(x-28, y-4, 0, rflagico);
@@ -2730,7 +2733,7 @@ void HU_DrawDualTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scoreline
for (i = 0; i < scorelines; i++)
{
- if (players[tab[i].num].spectator && gametype != GT_COOP)
+ if (players[tab[i].num].spectator && gametyperankings[gametype] != GT_COOP)
continue; //ignore them.
greycheck = greycheckdef;
@@ -2747,7 +2750,7 @@ void HU_DrawDualTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scoreline
| (greycheck ? V_TRANSLUCENT : 0)
| V_ALLOWLOWERCASE, name);
- if (G_GametypeUsesLives() && !(gametype == GT_COOP && (cv_cooplives.value == 0 || cv_cooplives.value == 3)) && (players[tab[i].num].lives != INFLIVES)) //show lives
+ if (G_GametypeUsesLives() && !(gametyperankings[gametype] == GT_COOP && (cv_cooplives.value == 0 || cv_cooplives.value == 3)) && (players[tab[i].num].lives != INFLIVES)) //show lives
V_DrawRightAlignedString(x, y+4, V_ALLOWLOWERCASE, va("%dx", players[tab[i].num].lives));
else if (G_TagGametype() && players[tab[i].num].pflags & PF_TAGIT)
V_DrawSmallScaledPatch(x-28, y-4, 0, tagico);
@@ -2796,7 +2799,7 @@ void HU_DrawDualTabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scoreline
}
// All data drawn with thin string for space.
- if (gametype == GT_RACE)
+ if (gametyperankings[gametype] == GT_RACE)
{
if (circuitmap)
{
@@ -2836,7 +2839,7 @@ static void HU_Draw32TabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scor
for (i = 0; i < scorelines; i++)
{
- if (players[tab[i].num].spectator && gametype != GT_COOP)
+ if (players[tab[i].num].spectator && gametyperankings[gametype] != GT_COOP)
continue; //ignore them.
greycheck = greycheckdef;
@@ -2906,7 +2909,7 @@ static void HU_Draw32TabRankings(INT32 x, INT32 y, playersort_t *tab, INT32 scor
}
// All data drawn with thin string for space.
- if (gametype == GT_RACE)
+ if (gametyperankings[gametype] == GT_RACE)
{
if (circuitmap)
{
@@ -3030,21 +3033,21 @@ static void HU_DrawRankings(void)
// draw the current gametype in the lower right
HU_drawGametype();
- if (gametype != GT_RACE && gametype != GT_COMPETITION && gametype != GT_COOP)
+ if (gametyperules & (GTR_TIMELIMIT|GTR_POINTLIMIT))
{
- if (cv_timelimit.value && timelimitintics > 0)
+ if ((gametyperules & GTR_TIMELIMIT) && cv_timelimit.value && timelimitintics > 0)
{
V_DrawCenteredString(64, 8, 0, "TIME");
V_DrawCenteredString(64, 16, 0, va("%i:%02i", G_TicsToMinutes(stplyr->realtime, true), G_TicsToSeconds(stplyr->realtime)));
}
- if (cv_pointlimit.value > 0)
+ if ((gametyperules & GTR_POINTLIMIT) && cv_pointlimit.value > 0)
{
V_DrawCenteredString(256, 8, 0, "POINT LIMIT");
V_DrawCenteredString(256, 16, 0, va("%d", cv_pointlimit.value));
}
}
- else if (gametype == GT_COOP)
+ else if (gametyperankings[gametype] == GT_COOP)
{
INT32 totalscore = 0;
for (i = 0; i < MAXPLAYERS; i++)
@@ -3078,7 +3081,7 @@ static void HU_DrawRankings(void)
tab[i].num = -1;
tab[i].name = 0;
- if (gametype == GT_RACE && !circuitmap)
+ if (gametyperankings[gametype] == GT_RACE && !circuitmap)
tab[i].count = INT32_MAX;
}
@@ -3087,7 +3090,7 @@ static void HU_DrawRankings(void)
if (!playeringame[j])
continue;
- if (gametype != GT_COOP && players[j].spectator)
+ if (!G_PlatformGametype() && players[j].spectator)
continue;
for (i = 0; i < MAXPLAYERS; i++)
@@ -3095,10 +3098,10 @@ static void HU_DrawRankings(void)
if (!playeringame[i])
continue;
- if (gametype != GT_COOP && players[i].spectator)
+ if (!G_PlatformGametype() && players[i].spectator)
continue;
- if (gametype == GT_RACE)
+ if (gametyperankings[gametype] == GT_RACE)
{
if (circuitmap)
{
@@ -3121,7 +3124,7 @@ static void HU_DrawRankings(void)
}
}
}
- else if (gametype == GT_COMPETITION)
+ else if (gametyperankings[gametype] == GT_COMPETITION)
{
// todo put something more fitting for the gametype here, such as current
// number of categories led
diff --git a/src/i_video.h b/src/i_video.h
index d8f11fb13750d34e08acfd8295e94c860348c4ba..76b984d252d9463d43f3f66178636af1c3f885b3 100644
--- a/src/i_video.h
+++ b/src/i_video.h
@@ -44,6 +44,7 @@ extern boolean highcolor;
/** \brief setup video mode
*/
void I_StartupGraphics(void);
+void I_StartupHardwareGraphics(void);
/** \brief restore old video mode
*/
@@ -84,6 +85,7 @@ INT32 VID_GetModeForSize(INT32 w, INT32 h);
\return currect video mode
*/
INT32 VID_SetMode(INT32 modenum);
+void VID_CheckRenderer(void);
/** \brief The VID_GetModeName function
diff --git a/src/info.c b/src/info.c
index dd808349e718cd105729a706259db4ce72a50077..30f3e96d097f79017ef30894ea6b6c30e80f55a1 100644
--- a/src/info.c
+++ b/src/info.c
@@ -4492,7 +4492,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
0, // mass
0, // damage
sfx_None, // activesound
- MF_NOTHINK|MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY, // flags
+ MF_SCENERY|MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY, // flags
S_NULL // raisestate
},
@@ -6273,7 +6273,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
0, // mass
0, // damage
sfx_None, // activesound
- MF_NOGRAVITY|MF_NOBLOCKMAP|MF_NOTHINK, // flags
+ MF_NOGRAVITY|MF_NOBLOCKMAP|MF_SCENERY, // flags
S_NULL // raisestate
},
@@ -11992,7 +11992,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
100, // mass
0, // damage
sfx_None, // activesound
- MF_NOTHINK|MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY|MF_SCENERY, // flags
+ MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY|MF_SCENERY, // flags
S_NULL // raisestate
},
@@ -12019,7 +12019,7 @@ mobjinfo_t mobjinfo[NUMMOBJTYPES] =
100, // mass
0, // damage
sfx_None, // activesound
- MF_NOTHINK|MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY|MF_SCENERY, // flags
+ MF_NOBLOCKMAP|MF_NOCLIP|MF_NOCLIPHEIGHT|MF_NOGRAVITY|MF_SCENERY, // flags
S_NULL // raisestate
},
diff --git a/src/info.h b/src/info.h
index 26fb1738ded63abfe1ba0edc08e696f05c192849..261abbac5f9da5812becad7f7a3ddcea35670635 100644
--- a/src/info.h
+++ b/src/info.h
@@ -155,11 +155,9 @@ void A_SpawnObjectAbsolute();
void A_SpawnObjectRelative();
void A_ChangeAngleRelative();
void A_ChangeAngleAbsolute();
-#ifdef ROTSPRITE
void A_RollAngle();
void A_ChangeRollAngleRelative();
void A_ChangeRollAngleAbsolute();
-#endif
void A_PlaySound();
void A_FindTarget();
void A_FindTracer();
diff --git a/src/lua_baselib.c b/src/lua_baselib.c
index b68d16c2afec9cb63bd9af5cd417047d8d9b8743..695e9367e57d2fb972e48f833bae160d94f71744 100644
--- a/src/lua_baselib.c
+++ b/src/lua_baselib.c
@@ -12,6 +12,7 @@
#include "doomdef.h"
#ifdef HAVE_BLUA
+#include "fastcmp.h"
#include "p_local.h"
#include "p_setup.h" // So we can have P_SetupLevelSky
#ifdef ESLOPE
@@ -23,6 +24,8 @@
#include "m_random.h"
#include "s_sound.h"
#include "g_game.h"
+#include "m_menu.h"
+#include "y_inter.h"
#include "hu_stuff.h" // HU_AddChatText
#include "console.h"
#include "d_netcmd.h" // IsPlayerAdmin
@@ -144,10 +147,8 @@ static const struct {
{META_MOBJINFO, "mobjinfo_t"},
{META_SFXINFO, "sfxinfo_t"},
{META_SPRITEINFO, "spriteinfo_t"},
-#ifdef ROTSPRITE
{META_PIVOTLIST, "spriteframepivot_t[]"},
{META_FRAMEPIVOT, "spriteframepivot_t"},
-#endif
{META_MOBJ, "mobj_t"},
{META_MAPTHING, "mapthing_t"},
@@ -2632,6 +2633,145 @@ static int lib_sStartMusicCaption(lua_State *L)
// G_GAME
////////////
+// Copypasted from lib_cvRegisterVar :]
+static int lib_gAddGametype(lua_State *L)
+{
+ const char *k;
+ lua_Integer i;
+
+ const char *gtname = NULL;
+ const char *gtconst = NULL;
+ const char *gtdescription = NULL;
+ INT16 newgtidx = 0;
+ UINT32 newgtrules = 0;
+ UINT32 newgttol = 0;
+ INT32 newgtpointlimit = 0;
+ INT32 newgttimelimit = 0;
+ UINT8 newgtleftcolor = 0;
+ UINT8 newgtrightcolor = 0;
+ INT16 newgtrankingstype = -1;
+ int newgtinttype = 0;
+
+ luaL_checktype(L, 1, LUA_TTABLE);
+ lua_settop(L, 1); // Clear out all other possible arguments, leaving only the first one.
+
+ if (!lua_lumploading)
+ return luaL_error(L, "This function cannot be called from within a hook or coroutine!");
+
+ // Ran out of gametype slots
+ if (gametypecount == NUMGAMETYPEFREESLOTS)
+ return luaL_error(L, "Ran out of free gametype slots!");
+
+#define FIELDERROR(f, e) luaL_error(L, "bad value for " LUA_QL(f) " in table passed to " LUA_QL("G_AddGametype") " (%s)", e);
+#define TYPEERROR(f, t) FIELDERROR(f, va("%s expected, got %s", lua_typename(L, t), luaL_typename(L, -1)))
+
+ lua_pushnil(L);
+ while (lua_next(L, 1)) {
+ // stack: gametype table, key/index, value
+ // 1 2 3
+ i = 0;
+ k = NULL;
+ if (lua_isnumber(L, 2))
+ i = lua_tointeger(L, 2);
+ else if (lua_isstring(L, 2))
+ k = lua_tostring(L, 2);
+
+ // Sorry, no gametype rules as key names.
+ if (i == 1 || (k && fasticmp(k, "name"))) {
+ if (!lua_isstring(L, 3))
+ TYPEERROR("name", LUA_TSTRING)
+ gtname = Z_StrDup(lua_tostring(L, 3));
+ } else if (i == 2 || (k && fasticmp(k, "identifier"))) {
+ if (!lua_isstring(L, 3))
+ TYPEERROR("identifier", LUA_TSTRING)
+ gtconst = Z_StrDup(lua_tostring(L, 3));
+ } else if (i == 3 || (k && fasticmp(k, "rules"))) {
+ if (!lua_isnumber(L, 3))
+ TYPEERROR("rules", LUA_TNUMBER)
+ newgtrules = (UINT32)lua_tointeger(L, 3);
+ } else if (i == 4 || (k && fasticmp(k, "typeoflevel"))) {
+ if (!lua_isnumber(L, 3))
+ TYPEERROR("typeoflevel", LUA_TNUMBER)
+ newgttol = (UINT32)lua_tointeger(L, 3);
+ } else if (i == 5 || (k && fasticmp(k, "rankingtype"))) {
+ if (!lua_isnumber(L, 3))
+ TYPEERROR("rankingtype", LUA_TNUMBER)
+ newgtrankingstype = (INT16)lua_tointeger(L, 3);
+ } else if (i == 6 || (k && fasticmp(k, "intermissiontype"))) {
+ if (!lua_isnumber(L, 3))
+ TYPEERROR("intermissiontype", LUA_TNUMBER)
+ newgtinttype = (int)lua_tointeger(L, 3);
+ } else if (i == 7 || (k && fasticmp(k, "defaultpointlimit"))) {
+ if (!lua_isnumber(L, 3))
+ TYPEERROR("defaultpointlimit", LUA_TNUMBER)
+ newgtpointlimit = (INT32)lua_tointeger(L, 3);
+ } else if (i == 8 || (k && fasticmp(k, "defaulttimelimit"))) {
+ if (!lua_isnumber(L, 3))
+ TYPEERROR("defaulttimelimit", LUA_TNUMBER)
+ newgttimelimit = (INT32)lua_tointeger(L, 3);
+ } else if (i == 9 || (k && fasticmp(k, "description"))) {
+ if (!lua_isstring(L, 3))
+ TYPEERROR("description", LUA_TSTRING)
+ gtdescription = Z_StrDup(lua_tostring(L, 3));
+ } else if (i == 10 || (k && fasticmp(k, "headerleftcolor"))) {
+ if (!lua_isnumber(L, 3))
+ TYPEERROR("headerleftcolor", LUA_TNUMBER)
+ newgtleftcolor = (UINT8)lua_tointeger(L, 3);
+ } else if (i == 11 || (k && fasticmp(k, "headerrightcolor"))) {
+ if (!lua_isnumber(L, 3))
+ TYPEERROR("headerrightcolor", LUA_TNUMBER)
+ newgtrightcolor = (UINT8)lua_tointeger(L, 3);
+ // Key name specified
+ } else if ((!i) && (k && fasticmp(k, "headercolor"))) {
+ if (!lua_isnumber(L, 3))
+ TYPEERROR("headercolor", LUA_TNUMBER)
+ newgtleftcolor = newgtrightcolor = (UINT8)lua_tointeger(L, 3);
+ }
+ lua_pop(L, 1);
+ }
+
+#undef FIELDERROR
+#undef TYPEERROR
+
+ // pop gametype table
+ lua_pop(L, 1);
+
+ // Set defaults
+ if (gtname == NULL)
+ gtname = Z_StrDup("Unnamed gametype");
+ if (gtdescription == NULL)
+ gtdescription = Z_StrDup("???");
+
+ // Add the new gametype
+ newgtidx = G_AddGametype(newgtrules);
+ G_AddGametypeTOL(newgtidx, newgttol);
+ G_SetGametypeDescription(newgtidx, NULL, newgtleftcolor, newgtrightcolor);
+ strncpy(gametypedesc[newgtidx].notes, gtdescription, 441);
+
+ // Not covered by G_AddGametype alone.
+ if (newgtrankingstype == -1)
+ newgtrankingstype = newgtidx;
+ gametyperankings[newgtidx] = newgtrankingstype;
+ intermissiontypes[newgtidx] = newgtinttype;
+ pointlimits[newgtidx] = newgtpointlimit;
+ timelimits[newgtidx] = newgttimelimit;
+
+ // Write the new gametype name.
+ Gametype_Names[newgtidx] = gtname;
+
+ // Write the constant name.
+ if (gtconst == NULL)
+ gtconst = gtname;
+ G_AddGametypeConstant(newgtidx, gtconst);
+
+ // Update gametype_cons_t accordingly.
+ G_UpdateGametypeSelections();
+
+ // done
+ CONS_Printf("Added gametype %s\n", Gametype_Names[newgtidx]);
+ return 0;
+}
+
static int lib_gBuildMapName(lua_State *L)
{
INT32 map = luaL_optinteger(L, 1, gamemap);
@@ -2664,23 +2804,17 @@ static int lib_gSetCustomExitVars(lua_State *L)
// Supported:
// G_SetCustomExitVars(); [reset to defaults]
// G_SetCustomExitVars(int) [nextmap override only]
- // G_SetCustomExitVars(bool) [skipstats only]
- // G_SetCustomExitVars(int, bool) [both of the above]
+ // G_SetCustomExitVars(nil, int) [skipstats only]
+ // G_SetCustomExitVars(int, int) [both of the above]
+
+ nextmapoverride = 0;
+ skipstats = 0;
+
if (n >= 1)
{
- if (lua_isnumber(L, 1) || n >= 2)
- {
- nextmapoverride = (INT16)luaL_checknumber(L, 1);
- lua_remove(L, 1); // remove nextmapoverride; skipstats now 1 if available
- }
- skipstats = luaL_optinteger(L, 2, 0);
- }
- else
- {
- nextmapoverride = 0;
- skipstats = 0;
+ nextmapoverride = (INT16)luaL_optinteger(L, 1, 0);
+ skipstats = (INT16)luaL_optinteger(L, 2, 0);
}
- // ---
return 0;
}
@@ -2997,6 +3131,7 @@ static luaL_Reg lib[] = {
{"S_StartMusicCaption", lib_sStartMusicCaption},
// g_game
+ {"G_AddGametype", lib_gAddGametype},
{"G_BuildMapName",lib_gBuildMapName},
{"G_DoReborn",lib_gDoReborn},
{"G_SetCustomExitVars",lib_gSetCustomExitVars},
diff --git a/src/lua_consolelib.c b/src/lua_consolelib.c
index 58e720c85a35f6cf14dbb6547619f86a50267c75..837612e521f77854a72fb4cd3346fe6a1c2a1bd5 100644
--- a/src/lua_consolelib.c
+++ b/src/lua_consolelib.c
@@ -245,7 +245,7 @@ static int lib_comBufAddText(lua_State *L)
return LUA_ErrInvalid(L, "player_t");
if (plr != &players[consoleplayer])
return 0;
- COM_BufAddText(va("%s\n", luaL_checkstring(L, 2)));
+ COM_BufAddTextEx(va("%s\n", luaL_checkstring(L, 2)), COM_SAFE);
return 0;
}
@@ -262,7 +262,7 @@ static int lib_comBufInsertText(lua_State *L)
return LUA_ErrInvalid(L, "player_t");
if (plr != &players[consoleplayer])
return 0;
- COM_BufInsertText(va("%s\n", luaL_checkstring(L, 2)));
+ COM_BufInsertTextEx(va("%s\n", luaL_checkstring(L, 2)), COM_SAFE);
return 0;
}
diff --git a/src/lua_hook.h b/src/lua_hook.h
index 6617bca93a34c2db6742f40814d74eb079279f32..68efbce93d89a0e81cd0d7cd0ede54e2a5e09b05 100644
--- a/src/lua_hook.h
+++ b/src/lua_hook.h
@@ -51,6 +51,8 @@ enum hook {
hook_PlayerCanDamage,
hook_PlayerQuit,
hook_IntermissionThinker,
+ hook_TeamSwitch,
+ hook_ViewpointSwitch,
hook_MAX // last hook
};
@@ -93,5 +95,7 @@ boolean LUAh_FollowMobj(player_t *player, mobj_t *mobj); // Hook for P_PlayerAft
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
+boolean LUAh_TeamSwitch(player_t *player, int newteam, boolean fromspectators, boolean tryingautobalance, boolean tryingscramble); // Hook for team switching in... uh....
+UINT8 LUAh_ViewpointSwitch(player_t *player, player_t *newdisplayplayer, boolean forced); // Hook for spy mode
#endif
diff --git a/src/lua_hooklib.c b/src/lua_hooklib.c
index ef87d0b6f7a9cc592609be76cbeb59f770710ee1..91b4c699249a77a5103c1b61911aa1de51a223db 100644
--- a/src/lua_hooklib.c
+++ b/src/lua_hooklib.c
@@ -62,6 +62,8 @@ const char *const hookNames[hook_MAX+1] = {
"PlayerCanDamage",
"PlayerQuit",
"IntermissionThinker",
+ "TeamSwitch",
+ "ViewpointSwitch",
NULL
};
@@ -203,6 +205,8 @@ static int lib_addHook(lua_State *L)
case hook_PlayerSpawn:
case hook_FollowMobj:
case hook_PlayerCanDamage:
+ case hook_TeamSwitch:
+ case hook_ViewpointSwitch:
case hook_ShieldSpawn:
case hook_ShieldSpecial:
lastp = &playerhooks;
@@ -657,14 +661,16 @@ UINT8 LUAh_ShouldDamage(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32
LUA_PushUserdata(gL, inflictor, META_MOBJ);
LUA_PushUserdata(gL, source, META_MOBJ);
lua_pushinteger(gL, damage);
+ lua_pushinteger(gL, damagetype);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
- lua_pushvalue(gL, -5);
- lua_pushvalue(gL, -5);
- lua_pushvalue(gL, -5);
- lua_pushvalue(gL, -5);
- if (lua_pcall(gL, 4, 1, 0)) {
+ lua_pushvalue(gL, -6);
+ lua_pushvalue(gL, -6);
+ lua_pushvalue(gL, -6);
+ lua_pushvalue(gL, -6);
+ lua_pushvalue(gL, -6);
+ if (lua_pcall(gL, 5, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
@@ -745,14 +751,16 @@ boolean LUAh_MobjDamage(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32
LUA_PushUserdata(gL, inflictor, META_MOBJ);
LUA_PushUserdata(gL, source, META_MOBJ);
lua_pushinteger(gL, damage);
+ lua_pushinteger(gL, damagetype);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
- lua_pushvalue(gL, -5);
- lua_pushvalue(gL, -5);
- lua_pushvalue(gL, -5);
- lua_pushvalue(gL, -5);
- if (lua_pcall(gL, 4, 1, 0)) {
+ lua_pushvalue(gL, -6);
+ lua_pushvalue(gL, -6);
+ lua_pushvalue(gL, -6);
+ lua_pushvalue(gL, -6);
+ lua_pushvalue(gL, -6);
+ if (lua_pcall(gL, 5, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
@@ -823,13 +831,15 @@ boolean LUAh_MobjDeath(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8
LUA_PushUserdata(gL, target, META_MOBJ);
LUA_PushUserdata(gL, inflictor, META_MOBJ);
LUA_PushUserdata(gL, source, META_MOBJ);
+ lua_pushinteger(gL, damagetype);
}
lua_pushfstring(gL, FMT_HOOKID, hookp->id);
lua_gettable(gL, LUA_REGISTRYINDEX);
- lua_pushvalue(gL, -4);
- lua_pushvalue(gL, -4);
- lua_pushvalue(gL, -4);
- if (lua_pcall(gL, 3, 1, 0)) {
+ lua_pushvalue(gL, -5);
+ lua_pushvalue(gL, -5);
+ lua_pushvalue(gL, -5);
+ lua_pushvalue(gL, -5);
+ if (lua_pcall(gL, 4, 1, 0)) {
if (!hookp->error || cv_debug & DBG_LUA)
CONS_Alert(CONS_WARNING,"%s\n",lua_tostring(gL, -1));
lua_pop(gL, 1);
@@ -1346,4 +1356,101 @@ void LUAh_IntermissionThinker(void)
}
}
+// Hook for team switching
+// It's just an edit of LUAh_ViewpointSwitch.
+boolean LUAh_TeamSwitch(player_t *player, int newteam, boolean fromspectators, boolean tryingautobalance, boolean tryingscramble)
+{
+ hook_p hookp;
+ boolean canSwitchTeam = true;
+ if (!gL || !(hooksAvailable[hook_TeamSwitch/8] & (1<<(hook_TeamSwitch%8))))
+ return true;
+
+ lua_settop(gL, 0);
+
+ for (hookp = playerhooks; hookp; hookp = hookp->next)
+ {
+ if (hookp->type != hook_TeamSwitch)
+ continue;
+
+ if (lua_gettop(gL) == 0)
+ {
+ LUA_PushUserdata(gL, player, META_PLAYER);
+ lua_pushinteger(gL, newteam);
+ lua_pushboolean(gL, fromspectators);
+ lua_pushboolean(gL, tryingautobalance);
+ lua_pushboolean(gL, tryingscramble);
+ }
+ lua_pushfstring(gL, FMT_HOOKID, hookp->id);
+ lua_gettable(gL, LUA_REGISTRYINDEX);
+ lua_pushvalue(gL, -6);
+ lua_pushvalue(gL, -6);
+ lua_pushvalue(gL, -6);
+ lua_pushvalue(gL, -6);
+ lua_pushvalue(gL, -6);
+ if (lua_pcall(gL, 5, 1, 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;
+ continue;
+ }
+ if (!lua_isnil(gL, -1) && !lua_toboolean(gL, -1))
+ canSwitchTeam = false; // Can't switch team
+ lua_pop(gL, 1);
+ }
+
+ lua_settop(gL, 0);
+ return canSwitchTeam;
+}
+
+// Hook for spy mode
+UINT8 LUAh_ViewpointSwitch(player_t *player, player_t *newdisplayplayer, boolean forced)
+{
+ hook_p hookp;
+ UINT8 canSwitchView = 0; // 0 = default, 1 = force yes, 2 = force no.
+ if (!gL || !(hooksAvailable[hook_ViewpointSwitch/8] & (1<<(hook_ViewpointSwitch%8))))
+ return 0;
+
+ lua_settop(gL, 0);
+ hud_running = true;
+
+ for (hookp = playerhooks; hookp; hookp = hookp->next)
+ {
+ if (hookp->type != hook_ViewpointSwitch)
+ continue;
+
+ if (lua_gettop(gL) == 0)
+ {
+ LUA_PushUserdata(gL, player, META_PLAYER);
+ LUA_PushUserdata(gL, newdisplayplayer, META_PLAYER);
+ lua_pushboolean(gL, forced);
+ }
+ lua_pushfstring(gL, FMT_HOOKID, hookp->id);
+ lua_gettable(gL, LUA_REGISTRYINDEX);
+ lua_pushvalue(gL, -4);
+ lua_pushvalue(gL, -4);
+ lua_pushvalue(gL, -4);
+ if (lua_pcall(gL, 3, 1, 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;
+ continue;
+ }
+ if (!lua_isnil(gL, -1))
+ { // if nil, leave canSwitchView = 0.
+ if (lua_toboolean(gL, -1))
+ canSwitchView = 1; // Force viewpoint switch
+ else
+ canSwitchView = 2; // Skip viewpoint switch
+ }
+ lua_pop(gL, 1);
+ }
+
+ lua_settop(gL, 0);
+ hud_running = false;
+
+ return canSwitchView;
+}
+
#endif
diff --git a/src/lua_hud.h b/src/lua_hud.h
index abfbba4413a399471f0b0b9ae93205e41179a920..a00a5cb028bca8f63b1e9349757742e79405b703 100644
--- a/src/lua_hud.h
+++ b/src/lua_hud.h
@@ -21,6 +21,7 @@ enum hud {
// Match / CTF / Tag / Ringslinger
hud_weaponrings,
hud_powerstones,
+ hud_teamscores,
// NiGHTS mode
hud_nightslink,
hud_nightsdrill,
@@ -33,6 +34,9 @@ enum hud {
hud_coopemeralds,
hud_tokens,
hud_tabemblems,
+ // Intermission
+ hud_intermissiontally,
+ hud_intermissionmessages,
hud_MAX
};
@@ -43,4 +47,5 @@ boolean LUA_HudEnabled(enum hud option);
void LUAh_GameHUD(player_t *stplyr);
void LUAh_ScoresHUD(void);
void LUAh_TitleHUD(void);
-void LUAh_TitleCardHUD(player_t *stplyr);
+void LUAh_TitleCardHUD(player_t *stplayr);
+void LUAh_IntermissionHUD(void);
diff --git a/src/lua_hudlib.c b/src/lua_hudlib.c
index a2f48c4ad5d2daced33e46e3f0f830e2a39b8f98..58af64359e00abfbd309565aade645280f68a3b2 100644
--- a/src/lua_hudlib.c
+++ b/src/lua_hudlib.c
@@ -36,6 +36,11 @@ static UINT8 hud_enabled[(hud_MAX/8)+1];
static UINT8 hudAvailable; // hud hooks field
+#ifdef LUA_PATCH_SAFETY
+static patchinfo_t *patchinfo, *patchinfohead;
+static int numluapatches;
+#endif
+
// must match enum hud in lua_hud.h
static const char *const hud_disable_options[] = {
"stagetitle",
@@ -48,6 +53,7 @@ static const char *const hud_disable_options[] = {
"weaponrings",
"powerstones",
+ "teamscores",
"nightslink",
"nightsdrill",
@@ -60,6 +66,9 @@ static const char *const hud_disable_options[] = {
"coopemeralds",
"tokens",
"tabemblems",
+
+ "intermissiontally",
+ "intermissionmessages",
NULL};
enum hudinfo {
@@ -92,12 +101,14 @@ static const char *const patch_opt[] = {
enum hudhook {
hudhook_game = 0,
hudhook_scores,
+ hudhook_intermission,
hudhook_title,
hudhook_titlecard
};
static const char *const hudhook_opt[] = {
"game",
"scores",
+ "intermission",
"title",
"titlecard",
NULL};
@@ -250,12 +261,17 @@ static int colormap_get(lua_State *L)
static int patch_get(lua_State *L)
{
+#ifdef LUA_PATCH_SAFETY
patch_t *patch = *((patch_t **)luaL_checkudata(L, 1, META_PATCH));
+#else
+ patchinfo_t *patch = *((patchinfo_t **)luaL_checkudata(L, 1, META_PATCH));
+#endif
enum patch field = luaL_checkoption(L, 2, NULL, patch_opt);
// patches are CURRENTLY always valid, expected to be cached with PU_STATIC
// this may change in the future, so patch.valid still exists
- I_Assert(patch != NULL);
+ if (!patch)
+ return LUA_ErrInvalid(L, "patch_t");
switch (field)
{
@@ -352,8 +368,59 @@ static int libd_patchExists(lua_State *L)
static int libd_cachePatch(lua_State *L)
{
+#ifdef LUA_PATCH_SAFETY
+ int i;
+ lumpnum_t lumpnum;
+ patchinfo_t *luapat;
+ patch_t *realpatch;
+
HUDONLY
- LUA_PushUserdata(L, W_CachePatchName(luaL_checkstring(L, 1), PU_STATIC), META_PATCH);
+
+ luapat = patchinfohead;
+ lumpnum = W_CheckNumForName(luaL_checkstring(L, 1));
+ if (lumpnum == LUMPERROR)
+ lumpnum = W_GetNumForName("MISSING");
+
+ for (i = 0; i < numluapatches; i++)
+ {
+ // check if already cached
+ if (luapat->wadnum == WADFILENUM(lumpnum) && luapat->lumpnum == LUMPNUM(lumpnum))
+ {
+ LUA_PushUserdata(L, luapat, META_PATCH);
+ return 1;
+ }
+ luapat = luapat->next;
+ if (!luapat)
+ break;
+ }
+
+ if (numluapatches > 0)
+ {
+ patchinfo->next = Z_Malloc(sizeof(patchinfo_t), PU_STATIC, NULL);
+ patchinfo = patchinfo->next;
+ }
+ else
+ {
+ patchinfo = Z_Malloc(sizeof(patchinfo_t), PU_STATIC, NULL);
+ patchinfohead = patchinfo;
+ }
+
+ realpatch = W_CachePatchNum(lumpnum, PU_PATCH);
+
+ patchinfo->width = realpatch->width;
+ patchinfo->height = realpatch->height;
+ patchinfo->leftoffset = realpatch->leftoffset;
+ patchinfo->topoffset = realpatch->topoffset;
+
+ patchinfo->wadnum = WADFILENUM(lumpnum);
+ patchinfo->lumpnum = LUMPNUM(lumpnum);
+
+ LUA_PushUserdata(L, patchinfo, META_PATCH);
+ numluapatches++;
+#else
+ HUDONLY
+ LUA_PushUserdata(L, W_CachePatchName(luaL_checkstring(L, 1), PU_PATCH), META_PATCH);
+#endif
return 1;
}
@@ -409,7 +476,7 @@ static int libd_getSpritePatch(lua_State *L)
return 0;
// push both the patch and it's "flip" value
- LUA_PushUserdata(L, W_CachePatchNum(sprframe->lumppat[angle], PU_STATIC), META_PATCH);
+ LUA_PushUserdata(L, W_CachePatchNum(sprframe->lumppat[angle], PU_PATCH), META_PATCH);
lua_pushboolean(L, (sprframe->flip & (1<<angle)) != 0);
return 2;
}
@@ -504,7 +571,7 @@ static int libd_getSprite2Patch(lua_State *L)
return 0;
// push both the patch and it's "flip" value
- LUA_PushUserdata(L, W_CachePatchNum(sprframe->lumppat[angle], PU_STATIC), META_PATCH);
+ LUA_PushUserdata(L, W_CachePatchNum(sprframe->lumppat[angle], PU_PATCH), META_PATCH);
lua_pushboolean(L, (sprframe->flip & (1<<angle)) != 0);
return 2;
}
@@ -513,12 +580,22 @@ static int libd_draw(lua_State *L)
{
INT32 x, y, flags;
patch_t *patch;
+#ifdef LUA_PATCH_SAFETY
+ patchinfo_t *luapat;
+#endif
const UINT8 *colormap = NULL;
HUDONLY
x = luaL_checkinteger(L, 1);
y = luaL_checkinteger(L, 2);
+#ifdef LUA_PATCH_SAFETY
+ luapat = *((patchinfo_t **)luaL_checkudata(L, 3, META_PATCH));
+ patch = W_CachePatchNum((luapat->wadnum<<16)+luapat->lumpnum, PU_PATCH);
+#else
patch = *((patch_t **)luaL_checkudata(L, 3, META_PATCH));
+ if (!patch)
+ return LUA_ErrInvalid(L, "patch_t");
+#endif
flags = luaL_optinteger(L, 4, 0);
if (!lua_isnoneornil(L, 5))
colormap = *((UINT8 **)luaL_checkudata(L, 5, META_COLORMAP));
@@ -534,6 +611,9 @@ static int libd_drawScaled(lua_State *L)
fixed_t x, y, scale;
INT32 flags;
patch_t *patch;
+#ifdef LUA_PATCH_SAFETY
+ patchinfo_t *luapat;
+#endif
const UINT8 *colormap = NULL;
HUDONLY
@@ -542,7 +622,14 @@ static int libd_drawScaled(lua_State *L)
scale = luaL_checkinteger(L, 3);
if (scale < 0)
return luaL_error(L, "negative scale");
+#ifdef LUA_PATCH_SAFETY
+ luapat = *((patchinfo_t **)luaL_checkudata(L, 4, META_PATCH));
+ patch = W_CachePatchNum((luapat->wadnum<<16)+luapat->lumpnum, PU_PATCH);
+#else
patch = *((patch_t **)luaL_checkudata(L, 4, META_PATCH));
+ if (!patch)
+ return LUA_ErrInvalid(L, "patch_t");
+#endif
flags = luaL_optinteger(L, 5, 0);
if (!lua_isnoneornil(L, 6))
colormap = *((UINT8 **)luaL_checkudata(L, 6, META_COLORMAP));
@@ -1041,6 +1128,10 @@ int LUA_HudLib(lua_State *L)
{
memset(hud_enabled, 0xff, (hud_MAX/8)+1);
+#ifdef LUA_PATCH_SAFETY
+ numluapatches = 0;
+#endif
+
lua_newtable(L); // HUD registry table
lua_newtable(L);
luaL_register(L, NULL, lib_draw);
@@ -1050,13 +1141,16 @@ int LUA_HudLib(lua_State *L)
lua_rawseti(L, -2, 2); // HUD[2] = game rendering functions array
lua_newtable(L);
- lua_rawseti(L, -2, 3); // HUD[2] = scores rendering functions array
+ lua_rawseti(L, -2, 3); // HUD[3] = scores rendering functions array
+
+ lua_newtable(L);
+ lua_rawseti(L, -2, 4); // HUD[4] = intermission rendering functions array
lua_newtable(L);
- lua_rawseti(L, -2, 4); // HUD[3] = title rendering functions array
+ lua_rawseti(L, -2, 5); // HUD[5] = title rendering functions array
lua_newtable(L);
- lua_rawseti(L, -2, 5); // HUD[4] = title card rendering functions array
+ lua_rawseti(L, -2, 6); // HUD[6] = title card rendering functions array
lua_setfield(L, LUA_REGISTRYINDEX, "HUD");
luaL_newmetatable(L, META_HUDINFO);
@@ -1228,4 +1322,29 @@ void LUAh_TitleCardHUD(player_t *stplayr)
hud_running = false;
}
+void LUAh_IntermissionHUD(void)
+{
+ if (!gL || !(hudAvailable & (1<<hudhook_intermission)))
+ return;
+
+ hud_running = true;
+ lua_pop(gL, -1);
+
+ lua_getfield(gL, LUA_REGISTRYINDEX, "HUD");
+ I_Assert(lua_istable(gL, -1));
+ lua_rawgeti(gL, -1, 4); // HUD[4] = rendering funcs
+ I_Assert(lua_istable(gL, -1));
+
+ lua_rawgeti(gL, -2, 1); // HUD[1] = lib_draw
+ I_Assert(lua_istable(gL, -1));
+ lua_remove(gL, -3); // pop HUD
+ lua_pushnil(gL);
+ while (lua_next(gL, -3) != 0) {
+ lua_pushvalue(gL, -3); // graphics library (HUD[1])
+ LUA_Call(gL, 1);
+ }
+ lua_pop(gL, -1);
+ hud_running = false;
+}
+
#endif
diff --git a/src/lua_infolib.c b/src/lua_infolib.c
index b617a7a14d5885c45ddcac5a22c854733991680d..7a2465ef770ad2c36fde2805cb585360bf20d007 100644
--- a/src/lua_infolib.c
+++ b/src/lua_infolib.c
@@ -266,7 +266,6 @@ static int lib_getSpriteInfo(lua_State *L)
#define FIELDERROR(f, e) luaL_error(L, "bad value for " LUA_QL(f) " in table passed to spriteinfo[] (%s)", e);
#define TYPEERROR(f, t1, t2) FIELDERROR(f, va("%s expected, got %s", lua_typename(L, t1), lua_typename(L, t2)))
-#ifdef ROTSPRITE
static int PopPivotSubTable(spriteframepivot_t *pivot, lua_State *L, int stk, int idx)
{
int okcool = 0;
@@ -360,7 +359,6 @@ static int PopPivotTable(spriteinfo_t *info, lua_State *L, int stk)
return 0;
}
-#endif
static int lib_setSpriteInfo(lua_State *L)
{
@@ -393,14 +391,11 @@ static int lib_setSpriteInfo(lua_State *L)
if (lua_isnumber(L, 2))
{
i = lua_tointeger(L, 2);
-#ifndef ROTSPRITE
i++; // shift index in case of missing rotsprite support
-#endif
}
else
str = luaL_checkstring(L, 2);
-#ifdef ROTSPRITE
if (i == 1 || (str && fastcmp(str, "pivot")))
{
// pivot[] is a table
@@ -409,7 +404,6 @@ static int lib_setSpriteInfo(lua_State *L)
else
FIELDERROR("pivot", va("%s expected, got %s", lua_typename(L, LUA_TTABLE), luaL_typename(L, -1)))
}
-#endif
lua_pop(L, 1);
}
@@ -434,7 +428,6 @@ static int spriteinfo_get(lua_State *L)
I_Assert(sprinfo != NULL);
-#ifdef ROTSPRITE
// push spriteframepivot_t userdata
if (fastcmp(field, "pivot"))
{
@@ -448,7 +441,6 @@ static int spriteinfo_get(lua_State *L)
return 1;
}
else
-#endif
return luaL_error(L, LUA_QL("spriteinfo_t") " has no field named " LUA_QS, field);
return 0;
@@ -473,6 +465,7 @@ static int spriteinfo_set(lua_State *L)
#ifdef ROTSPRITE
if (sprites != NULL)
R_FreeSingleRotSprite(&sprites[sprinfo-spriteinfo]);
+#endif
if (fastcmp(field, "pivot"))
{
@@ -488,7 +481,6 @@ static int spriteinfo_set(lua_State *L)
}
}
else
-#endif
return luaL_error(L, va("Field %s does not exist in spriteinfo_t", field));
return 0;
@@ -506,7 +498,6 @@ static int spriteinfo_num(lua_State *L)
}
// framepivot_t
-#ifdef ROTSPRITE
static int pivotlist_get(lua_State *L)
{
void **userdata;
@@ -616,7 +607,6 @@ static int framepivot_num(lua_State *L)
lua_pushinteger(L, 2);
return 1;
}
-#endif
////////////////
// STATE INFO //
@@ -1538,7 +1528,6 @@ int LUA_InfoLib(lua_State *L)
lua_setfield(L, -2, "__len");
lua_pop(L, 1);
-#ifdef ROTSPRITE
luaL_newmetatable(L, META_PIVOTLIST);
lua_pushcfunction(L, pivotlist_get);
lua_setfield(L, -2, "__index");
@@ -1560,7 +1549,6 @@ int LUA_InfoLib(lua_State *L)
lua_pushcfunction(L, framepivot_num);
lua_setfield(L, -2, "__len");
lua_pop(L, 1);
-#endif
lua_newuserdata(L, 0);
lua_createtable(L, 0, 2);
diff --git a/src/lua_libs.h b/src/lua_libs.h
index 104a1e51c0c4338c3ec64e9196180dd5a4f5876a..6a908d03dbc7069990198f3fa3d940e36bf77177 100644
--- a/src/lua_libs.h
+++ b/src/lua_libs.h
@@ -23,10 +23,8 @@ extern lua_State *gL;
#define META_MOBJINFO "MOBJINFO_T*"
#define META_SFXINFO "SFXINFO_T*"
#define META_SPRITEINFO "SPRITEINFO_T*"
-#ifdef ROTSPRITE
#define META_PIVOTLIST "SPRITEFRAMEPIVOT_T[]"
#define META_FRAMEPIVOT "SPRITEFRAMEPIVOT_T*"
-#endif
#define META_MOBJ "MOBJ_T*"
#define META_MAPTHING "MAPTHING_T*"
diff --git a/src/lua_maplib.c b/src/lua_maplib.c
index 0fe1df0b61daf5f9a3bf5a6abec3daeaf591c5dc..8ce6551f7319b9c9179805fda2c181f945c0dab0 100644
--- a/src/lua_maplib.c
+++ b/src/lua_maplib.c
@@ -134,6 +134,7 @@ enum side_e {
side_toptexture,
side_bottomtexture,
side_midtexture,
+ side_line,
side_sector,
side_special,
side_repeatcnt,
@@ -445,7 +446,7 @@ static int sectorlines_get(lua_State *L)
// 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))));
+ numoflines = (size_t)(*(size_t *)(((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
@@ -479,7 +480,7 @@ static int sectorlines_num(lua_State *L)
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))));
+ numoflines = (size_t)(*(size_t *)(((size_t)seclines) - (offsetof(sector_t, lines) - offsetof(sector_t, linecount))));
lua_pushinteger(L, numoflines);
return 1;
}
@@ -869,6 +870,9 @@ static int side_get(lua_State *L)
case side_midtexture:
lua_pushinteger(L, side->midtexture);
return 1;
+ case side_line:
+ LUA_PushUserdata(L, side->line, META_LINE);
+ return 1;
case side_sector:
LUA_PushUserdata(L, side->sector, META_SECTOR);
return 1;
@@ -902,6 +906,7 @@ static int side_set(lua_State *L)
switch(field)
{
case side_valid: // valid
+ case side_line:
case side_sector:
case side_special:
case side_text:
@@ -2071,6 +2076,12 @@ static int mapheaderinfo_get(lua_State *L)
lua_pushinteger(L, header->levelselect);
else if (fastcmp(field,"bonustype"))
lua_pushinteger(L, header->bonustype);
+ else if (fastcmp(field,"ltzzpatch"))
+ lua_pushstring(L, header->ltzzpatch);
+ else if (fastcmp(field,"ltzztext"))
+ lua_pushstring(L, header->ltzztext);
+ else if (fastcmp(field,"ltactdiamond"))
+ lua_pushstring(L, header->ltactdiamond);
else if (fastcmp(field,"maxbonuslives"))
lua_pushinteger(L, header->maxbonuslives);
else if (fastcmp(field,"levelflags"))
diff --git a/src/lua_mobjlib.c b/src/lua_mobjlib.c
index 49f93d29cd4f5180eccf784b5ce01af56795db8e..22248775153b5afd4ce21c61656fc3f3b73a8a50 100644
--- a/src/lua_mobjlib.c
+++ b/src/lua_mobjlib.c
@@ -32,9 +32,7 @@ enum mobj_e {
mobj_snext,
mobj_sprev,
mobj_angle,
-#ifdef ROTSPRITE
mobj_rollangle,
-#endif
mobj_sprite,
mobj_frame,
mobj_sprite2,
@@ -101,9 +99,7 @@ static const char *const mobj_opt[] = {
"snext",
"sprev",
"angle",
-#ifdef ROTSPRITE
"rollangle",
-#endif
"sprite",
"frame",
"sprite2",
@@ -205,11 +201,9 @@ static int mobj_get(lua_State *L)
case mobj_angle:
lua_pushangle(L, mo->angle);
break;
-#ifdef ROTSPRITE
case mobj_rollangle:
lua_pushangle(L, mo->rollangle);
break;
-#endif
case mobj_sprite:
lua_pushinteger(L, mo->sprite);
break;
@@ -462,11 +456,9 @@ static int mobj_set(lua_State *L)
else if (mo->player == &players[secondarydisplayplayer])
localangle2 = mo->angle;
break;
-#ifdef ROTSPRITE
case mobj_rollangle:
mo->rollangle = luaL_checkangle(L, 3);
break;
-#endif
case mobj_sprite:
mo->sprite = luaL_checkinteger(L, 3);
break;
diff --git a/src/lua_script.c b/src/lua_script.c
index fe3c2f10d11f5f5f513fbb0be8003150e1cdf15e..18d9a87c22e70de737351160ca018545c92aa12f 100644
--- a/src/lua_script.c
+++ b/src/lua_script.c
@@ -18,7 +18,9 @@
#include "w_wad.h"
#include "p_setup.h"
#include "r_state.h"
+#include "r_sky.h"
#include "g_game.h"
+#include "f_finale.h"
#include "byteptr.h"
#include "p_saveg.h"
#include "p_local.h"
@@ -79,8 +81,239 @@ FUNCNORETURN static int LUA_Panic(lua_State *L)
#endif
}
+// Moved here from lib_getenum.
+int LUA_PushGlobals(lua_State *L, const char *word)
+{
+ if (fastcmp(word,"gamemap")) {
+ lua_pushinteger(L, gamemap);
+ return 1;
+ } else if (fastcmp(word,"maptol")) {
+ lua_pushinteger(L, maptol);
+ return 1;
+ } else if (fastcmp(word,"ultimatemode")) {
+ lua_pushboolean(L, ultimatemode != 0);
+ return 1;
+ } else if (fastcmp(word,"mariomode")) {
+ lua_pushboolean(L, mariomode != 0);
+ return 1;
+ } else if (fastcmp(word,"twodlevel")) {
+ lua_pushboolean(L, twodlevel != 0);
+ return 1;
+ } else if (fastcmp(word,"circuitmap")) {
+ lua_pushboolean(L, circuitmap);
+ return 1;
+ } else if (fastcmp(word,"netgame")) {
+ lua_pushboolean(L, netgame);
+ return 1;
+ } else if (fastcmp(word,"multiplayer")) {
+ lua_pushboolean(L, multiplayer);
+ return 1;
+ } else if (fastcmp(word,"modeattacking")) {
+ lua_pushboolean(L, modeattacking);
+ return 1;
+ } else if (fastcmp(word,"splitscreen")) {
+ lua_pushboolean(L, splitscreen);
+ return 1;
+ } else if (fastcmp(word,"gamecomplete")) {
+ lua_pushboolean(L, gamecomplete);
+ return 1;
+ } else if (fastcmp(word,"devparm")) {
+ lua_pushboolean(L, devparm);
+ return 1;
+ } else if (fastcmp(word,"modifiedgame")) {
+ lua_pushboolean(L, modifiedgame && !savemoddata);
+ return 1;
+ } else if (fastcmp(word,"menuactive")) {
+ lua_pushboolean(L, menuactive);
+ return 1;
+ } else if (fastcmp(word,"paused")) {
+ lua_pushboolean(L, paused);
+ return 1;
+ } else if (fastcmp(word,"bluescore")) {
+ lua_pushinteger(L, bluescore);
+ return 1;
+ } else if (fastcmp(word,"redscore")) {
+ lua_pushinteger(L, redscore);
+ return 1;
+ } else if (fastcmp(word,"timelimit")) {
+ lua_pushinteger(L, cv_timelimit.value);
+ return 1;
+ } else if (fastcmp(word,"pointlimit")) {
+ lua_pushinteger(L, cv_pointlimit.value);
+ return 1;
+ // begin map vars
+ } else if (fastcmp(word,"spstage_start")) {
+ lua_pushinteger(L, spstage_start);
+ return 1;
+ } else if (fastcmp(word,"sstage_start")) {
+ lua_pushinteger(L, sstage_start);
+ return 1;
+ } else if (fastcmp(word,"sstage_end")) {
+ lua_pushinteger(L, sstage_end);
+ return 1;
+ } else if (fastcmp(word,"smpstage_start")) {
+ lua_pushinteger(L, smpstage_start);
+ return 1;
+ } else if (fastcmp(word,"smpstage_end")) {
+ lua_pushinteger(L, smpstage_end);
+ return 1;
+ } else if (fastcmp(word,"titlemap")) {
+ lua_pushinteger(L, titlemap);
+ return 1;
+ } else if (fastcmp(word,"titlemapinaction")) {
+ lua_pushboolean(L, (titlemapinaction != TITLEMAP_OFF));
+ return 1;
+ } else if (fastcmp(word,"bootmap")) {
+ lua_pushinteger(L, bootmap);
+ return 1;
+ } else if (fastcmp(word,"tutorialmap")) {
+ lua_pushinteger(L, tutorialmap);
+ return 1;
+ } else if (fastcmp(word,"tutorialmode")) {
+ lua_pushboolean(L, tutorialmode);
+ return 1;
+ // end map vars
+ // begin CTF colors
+ } else if (fastcmp(word,"skincolor_redteam")) {
+ lua_pushinteger(L, skincolor_redteam);
+ return 1;
+ } else if (fastcmp(word,"skincolor_blueteam")) {
+ lua_pushinteger(L, skincolor_blueteam);
+ return 1;
+ } else if (fastcmp(word,"skincolor_redring")) {
+ lua_pushinteger(L, skincolor_redring);
+ return 1;
+ } else if (fastcmp(word,"skincolor_bluering")) {
+ lua_pushinteger(L, skincolor_bluering);
+ return 1;
+ // end CTF colors
+ // begin timers
+ } else if (fastcmp(word,"invulntics")) {
+ lua_pushinteger(L, invulntics);
+ return 1;
+ } else if (fastcmp(word,"sneakertics")) {
+ lua_pushinteger(L, sneakertics);
+ return 1;
+ } else if (fastcmp(word,"flashingtics")) {
+ lua_pushinteger(L, flashingtics);
+ return 1;
+ } else if (fastcmp(word,"tailsflytics")) {
+ lua_pushinteger(L, tailsflytics);
+ return 1;
+ } else if (fastcmp(word,"underwatertics")) {
+ lua_pushinteger(L, underwatertics);
+ return 1;
+ } else if (fastcmp(word,"spacetimetics")) {
+ lua_pushinteger(L, spacetimetics);
+ return 1;
+ } else if (fastcmp(word,"extralifetics")) {
+ lua_pushinteger(L, extralifetics);
+ return 1;
+ } else if (fastcmp(word,"nightslinktics")) {
+ lua_pushinteger(L, nightslinktics);
+ return 1;
+ } else if (fastcmp(word,"gameovertics")) {
+ lua_pushinteger(L, gameovertics);
+ return 1;
+ } else if (fastcmp(word,"ammoremovaltics")) {
+ lua_pushinteger(L, ammoremovaltics);
+ return 1;
+ // end timers
+ } else if (fastcmp(word,"gametype")) {
+ lua_pushinteger(L, gametype);
+ return 1;
+ } else if (fastcmp(word,"gametyperules")) {
+ lua_pushinteger(L, gametyperules);
+ return 1;
+ } else if (fastcmp(word,"leveltime")) {
+ lua_pushinteger(L, leveltime);
+ return 1;
+ } else if (fastcmp(word,"sstimer")) {
+ lua_pushinteger(L, sstimer);
+ return 1;
+ } else if (fastcmp(word,"curWeather")) {
+ lua_pushinteger(L, curWeather);
+ return 1;
+ } else if (fastcmp(word,"globalweather")) {
+ lua_pushinteger(L, globalweather);
+ return 1;
+ } else if (fastcmp(word,"levelskynum")) {
+ lua_pushinteger(L, levelskynum);
+ return 1;
+ } else if (fastcmp(word,"globallevelskynum")) {
+ lua_pushinteger(L, globallevelskynum);
+ return 1;
+ } else if (fastcmp(word,"mapmusname")) {
+ lua_pushstring(L, mapmusname);
+ return 1;
+ } else if (fastcmp(word,"mapmusflags")) {
+ lua_pushinteger(L, mapmusflags);
+ return 1;
+ } 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;
+ LUA_PushUserdata(L, &players[serverplayer], META_PLAYER);
+ return 1;
+ } else if (fastcmp(word,"admin")) { // BACKWARDS COMPATIBILITY HACK: This was replaced with IsPlayerAdmin(), but some 2.1 Lua scripts still use the admin variable. It now points to the first admin player in the array.
+ LUA_Deprecated(L, "admin", "IsPlayerAdmin(player)");
+ if (!playeringame[adminplayers[0]] || IsPlayerAdmin(serverplayer))
+ return 0;
+ LUA_PushUserdata(L, &players[adminplayers[0]], META_PLAYER);
+ return 1;
+ } else if (fastcmp(word,"emeralds")) {
+ lua_pushinteger(L, emeralds);
+ return 1;
+ } else if (fastcmp(word,"gravity")) {
+ lua_pushinteger(L, gravity);
+ return 1;
+ } else if (fastcmp(word,"VERSIONSTRING")) {
+ lua_pushstring(L, VERSIONSTRING);
+ return 1;
+ } else if (fastcmp(word, "token")) {
+ lua_pushinteger(L, token);
+ return 1;
+ }
+ return 0;
+}
+
+// See the above.
+int LUA_CheckGlobals(lua_State *L, const char *word)
+{
+ if (fastcmp(word, "gametyperules"))
+ gametyperules = (UINT32)luaL_checkinteger(L, 2);
+ else if (fastcmp(word, "redscore"))
+ redscore = (UINT32)luaL_checkinteger(L, 2);
+ else if (fastcmp(word, "bluescore"))
+ bluescore = (UINT32)luaL_checkinteger(L, 2);
+ else
+ return 0;
+
+ // Global variable set, so return and don't error.
+ return 1;
+}
+
// This function decides which global variables you are allowed to set.
-static int noglobals(lua_State *L)
+static int setglobals(lua_State *L)
{
const char *csname;
char *name;
@@ -106,6 +339,9 @@ static int noglobals(lua_State *L)
return 0;
}
+ if (LUA_CheckGlobals(L, csname))
+ return 0;
+
Z_Free(name);
return luaL_error(L, "Implicit global " LUA_QS " prevented. Create a local variable instead.", csname);
}
@@ -144,7 +380,7 @@ static void LUA_ClearState(void)
// lock the global namespace
lua_getmetatable(L, LUA_GLOBALSINDEX);
- lua_pushcfunction(L, noglobals);
+ lua_pushcfunction(L, setglobals);
lua_setfield(L, -2, "__newindex");
lua_newtable(L);
lua_setfield(L, -2, "__metatable");
diff --git a/src/lua_script.h b/src/lua_script.h
index 4f66d3f8a43ad1d8c94e1ccfa405bde8413dc8ad..8f27dcb4c9b5343095705b9901b7201fc8b854dd 100644
--- a/src/lua_script.h
+++ b/src/lua_script.h
@@ -54,6 +54,8 @@ void LUA_InvalidatePlayer(player_t *player);
void LUA_Step(void);
void LUA_Archive(void);
void LUA_UnArchive(void);
+int LUA_PushGlobals(lua_State *L, const char *word);
+int LUA_CheckGlobals(lua_State *L, const char *word);
void Got_Luacmd(UINT8 **cp, INT32 playernum); // lua_consolelib.c
void LUA_CVarChanged(const char *name); // lua_consolelib.c
int Lua_optoption(lua_State *L, int narg,
diff --git a/src/m_cheat.c b/src/m_cheat.c
index 66d09fabac915123338efb3a075607600c230e3b..c284acf3edb87438c475694a84a7c7618683e03d 100644
--- a/src/m_cheat.c
+++ b/src/m_cheat.c
@@ -517,6 +517,7 @@ void Command_Teleport_f(void)
if (!starpostnum) // spawnpoints...
{
mapthing_t *mt;
+ fixed_t offset;
if (starpostpath >= numcoopstarts)
{
@@ -527,6 +528,7 @@ void Command_Teleport_f(void)
mt = playerstarts[starpostpath]; // Given above check, should never be NULL.
intx = mt->x<<FRACBITS;
inty = mt->y<<FRACBITS;
+ offset = mt->z<<FRACBITS;
ss = R_IsPointInSubsector(intx, inty);
if (!ss || ss->sector->ceilingheight - ss->sector->floorheight < p->mo->height)
@@ -538,17 +540,9 @@ void Command_Teleport_f(void)
// Flagging a player's ambush will make them start on the ceiling
// Objectflip inverts
if (!!(mt->options & MTF_AMBUSH) ^ !!(mt->options & MTF_OBJECTFLIP))
- {
- intz = ss->sector->ceilingheight - p->mo->height;
- if (mt->options >> ZSHIFT)
- intz -= ((mt->options >> ZSHIFT) << FRACBITS);
- }
+ intz = ss->sector->ceilingheight - p->mo->height - offset;
else
- {
- intz = ss->sector->floorheight;
- if (mt->options >> ZSHIFT)
- intz += ((mt->options >> ZSHIFT) << FRACBITS);
- }
+ intz = ss->sector->floorheight + offset;
if (mt->options & MTF_OBJECTFLIP) // flip the player!
{
@@ -778,7 +772,7 @@ void Command_CauseCfail_f(void)
P_SetThingPosition(players[consoleplayer].mo);
// CTF consistency test
- if (gametype == GT_CTF)
+ if (gametyperules & GTR_TEAMFLAGS)
{
if (blueflag) {
P_RemoveMobj(blueflag);
@@ -1106,7 +1100,7 @@ static mapthing_t *OP_CreateNewMapThing(player_t *player, UINT16 type, boolean c
#else
fixed_t cheight = sec->ceilingheight;
#endif
- mt->options = (UINT16)((cheight - player->mo->z - player->mo->height)>>FRACBITS);
+ mt->z = (UINT16)((cheight - player->mo->z - player->mo->height)>>FRACBITS);
}
else
{
@@ -1115,12 +1109,11 @@ static mapthing_t *OP_CreateNewMapThing(player_t *player, UINT16 type, boolean c
#else
fixed_t fheight = sec->floorheight;
#endif
- mt->options = (UINT16)((player->mo->z - fheight)>>FRACBITS);
+ mt->z = (UINT16)((player->mo->z - fheight)>>FRACBITS);
}
- mt->options <<= ZSHIFT;
mt->angle = (INT16)(FixedInt(AngleFixed(player->mo->angle)));
- mt->options |= (UINT16)cv_opflags.value;
+ mt->options = (mt->z << ZSHIFT) | (UINT16)cv_opflags.value;
return mt;
}
@@ -1187,21 +1180,21 @@ void OP_NightsObjectplace(player_t *player)
mt->options = (mt->options & ~(UINT16)cv_opflags.value) | (UINT16)cv_ophoopflags.value;
mt->angle = (INT16)(mt->angle+(INT16)((FixedInt(FixedDiv(temp*FRACUNIT, 360*(FRACUNIT/256))))<<8));
- P_SpawnHoopsAndRings(mt, false);
+ P_SpawnHoop(mt);
}
// This places a bumper!
if (cmd->buttons & BT_TOSSFLAG)
{
UINT16 vertangle = (UINT16)(player->anotherflyangle % 360);
- UINT16 newflags, newz;
+ UINT16 newflags;
player->pflags |= PF_ATTACKDOWN;
if (!OP_HeightOkay(player, false))
return;
mt = OP_CreateNewMapThing(player, (UINT16)mobjinfo[MT_NIGHTSBUMPER].doomednum, false);
- newz = min((mt->options >> ZSHIFT) - (mobjinfo[MT_NIGHTSBUMPER].height/4), 0);
+ mt->z = min(mt->z - (mobjinfo[MT_NIGHTSBUMPER].height/4), 0);
// height offset: from P_TouchSpecialThing case MT_NIGHTSBUMPER
// clockwise
@@ -1232,7 +1225,7 @@ void OP_NightsObjectplace(player_t *player)
else // forward
newflags = 0;
- mt->options = (newz << ZSHIFT) | newflags;
+ mt->options = (mt->z << ZSHIFT) | newflags;
// if NiGHTS is facing backwards, orient the Thing angle forwards so that the sprite angle
// displays correctly. Backwards movement via the Thing flags is unaffected.
@@ -1250,7 +1243,7 @@ void OP_NightsObjectplace(player_t *player)
return;
mt = OP_CreateNewMapThing(player, (UINT16)mobjinfo[MT_BLUESPHERE].doomednum, false);
- P_SpawnHoopsAndRings(mt, false);
+ P_SpawnMapThing(mt);
}
// This places a ring!
@@ -1261,7 +1254,7 @@ void OP_NightsObjectplace(player_t *player)
return;
mt = OP_CreateNewMapThing(player, (UINT16)mobjinfo[MT_RING].doomednum, false);
- P_SpawnHoopsAndRings(mt, false);
+ P_SpawnMapThing(mt);
}
// This places a custom object as defined in the console cv_mapthingnum.
@@ -1293,15 +1286,10 @@ void OP_NightsObjectplace(player_t *player)
mt = OP_CreateNewMapThing(player, (UINT16)cv_mapthingnum.value, false);
mt->angle = angle;
- if (mt->type == 300 // Ring
- || mt->type == 308 || mt->type == 309 // Team Rings
- || mt->type == 1706 // Sphere
- || (mt->type >= 600 && mt->type <= 609) // Placement patterns
- || mt->type == 1705 || mt->type == 1713 // NiGHTS Hoops
- || mt->type == 1800) // Mario Coin
- {
- P_SpawnHoopsAndRings(mt, false);
- }
+ if (mt->type >= 600 && mt->type <= 609) // Placement patterns
+ P_SpawnItemPattern(mt, false);
+ else if (mt->type == 1705 || mt->type == 1713) // NiGHTS Hoops
+ P_SpawnHoop(mt);
else
P_SpawnMapThing(mt);
}
@@ -1438,19 +1426,14 @@ void OP_ObjectplaceMovement(player_t *player)
return;
mt = OP_CreateNewMapThing(player, (UINT16)spawnthing, ceiling);
- if (mt->type == 300 // Ring
- || mt->type == 308 || mt->type == 309 // Team Rings
- || mt->type == 1706 // Nights Wing
- || (mt->type >= 600 && mt->type <= 609) // Placement patterns
- || mt->type == 1705 || mt->type == 1713 // NiGHTS Hoops
- || mt->type == 1800) // Mario Coin
- {
- P_SpawnHoopsAndRings(mt, false);
- }
+ if (mt->type >= 600 && mt->type <= 609) // Placement patterns
+ P_SpawnItemPattern(mt, false);
+ else if (mt->type == 1705 || mt->type == 1713) // NiGHTS Hoops
+ P_SpawnHoop(mt);
else
P_SpawnMapThing(mt);
- CONS_Printf(M_GetText("Placed object type %d at %d, %d, %d, %d\n"), mt->type, mt->x, mt->y, mt->options>>ZSHIFT, mt->angle);
+ CONS_Printf(M_GetText("Placed object type %d at %d, %d, %d, %d\n"), mt->type, mt->x, mt->y, mt->z, mt->angle);
}
}
diff --git a/src/m_menu.c b/src/m_menu.c
index 01baa99631dab0c7ee4ae85e28efc4d6dffdec93..65140cfe7c284d9670e5d0f9d6eb72b66c03f4c7 100644
--- a/src/m_menu.c
+++ b/src/m_menu.c
@@ -312,6 +312,7 @@ static void M_ChangeControl(INT32 choice);
// Video & Sound
menu_t OP_VideoOptionsDef, OP_VideoModeDef, OP_ColorOptionsDef;
#ifdef HWRENDER
+static void M_OpenGLOptionsMenu(void);
menu_t OP_OpenGLOptionsDef, OP_OpenGLFogDef;
#endif
menu_t OP_SoundOptionsDef;
@@ -395,6 +396,7 @@ static void M_ResetCvars(void);
// Consvar onchange functions
static void Newgametype_OnChange(void);
+static void Newrenderer_OnChange(void);
static void Dummymares_OnChange(void);
// ==========================================================================
@@ -419,6 +421,9 @@ CV_PossibleValue_t gametype_cons_t[NUMGAMETYPES+1];
consvar_t cv_newgametype = {"newgametype", "Co-op", CV_HIDEN|CV_CALL, gametype_cons_t, Newgametype_OnChange, 0, NULL, NULL, 0, 0, NULL};
+consvar_t cv_newrenderer = {"newrenderer", "Software", CV_HIDEN|CV_CALL, cv_renderer_t, Newrenderer_OnChange, 0, NULL, NULL, 0, 0, NULL};
+static int newrenderer_set = 1;/* Software doesn't need confirmation! */
+
static CV_PossibleValue_t serversort_cons_t[] = {
{0,"Ping"},
{1,"Modified State"},
@@ -612,7 +617,7 @@ static menuitem_t MISC_ChangeTeamMenu[] =
{IT_WHITESTRING|IT_CALL, NULL, "Confirm", M_ConfirmTeamChange, 90},
};
-static const gtdesc_t gametypedesc[] =
+gtdesc_t gametypedesc[NUMGAMETYPES] =
{
{{ 54, 54}, "Play through the single-player campaign with your friends, teaming up to beat Dr Eggman's nefarious challenges!"},
{{103, 103}, "Speed your way through the main acts, competing in several different categories to see who's the best."},
@@ -1282,10 +1287,7 @@ static menuitem_t OP_VideoOptionsMenu[] =
{IT_STRING|IT_CVAR, NULL, "Fullscreen", &cv_fullscreen, 11},
#endif
{IT_STRING | IT_CVAR, NULL, "Vertical Sync", &cv_vidwait, 16},
-
-#ifdef HWRENDER
- {IT_SUBMENU|IT_STRING, NULL, "OpenGL Options...", &OP_OpenGLOptionsDef, 21},
-#endif
+ {IT_STRING | IT_CVAR, NULL, "Renderer", &cv_newrenderer, 21},
{IT_HEADER, NULL, "Color Profile", NULL, 30},
{IT_STRING | IT_CVAR | IT_CV_SLIDER, NULL, "Brightness (F11)", &cv_globalgamma,36},
@@ -1325,6 +1327,11 @@ static menuitem_t OP_VideoOptionsMenu[] =
{IT_STRING | IT_CVAR, NULL, "Show FPS", &cv_ticrate, 190},
{IT_STRING | IT_CVAR, NULL, "Clear Before Redraw", &cv_homremoval, 195},
{IT_STRING | IT_CVAR, NULL, "Show \"FOCUS LOST\"", &cv_showfocuslost, 200},
+
+#ifdef HWRENDER
+ {IT_HEADER, NULL, "Renderer", NULL, 208},
+ {IT_CALL | IT_STRING, NULL, "OpenGL Options...", M_OpenGLOptionsMenu, 214},
+#endif
};
static menuitem_t OP_VideoModeMenu[] =
@@ -2121,6 +2128,14 @@ menu_t OP_MonitorToggleDef =
};
#ifdef HWRENDER
+static void M_OpenGLOptionsMenu(void)
+{
+ if (rendermode == render_opengl)
+ M_SetupNextMenu(&OP_OpenGLOptionsDef);
+ else
+ M_StartMessage(M_GetText("You must be in OpenGL mode\nto access this menu.\n\n(Press a key)\n"), NULL, MM_NOTHING);
+}
+
menu_t OP_OpenGLOptionsDef = DEFAULTMENUSTYLE(
MN_OP_MAIN + (MN_OP_VIDEO << 6) + (MN_OP_OPENGL << 12),
"M_VIDEO", OP_OpenGLOptionsMenu, &OP_VideoOptionsDef, 30, 30);
@@ -2326,6 +2341,44 @@ static void Newgametype_OnChange(void)
}
}
+static void Newrenderer_AREYOUSURE(INT32 c)
+{
+ int n;
+ switch (c)
+ {
+ case 'y':
+ case KEY_ENTER:
+ n = cv_newrenderer.value;
+ newrenderer_set |= n;
+ CV_SetValue(&cv_renderer, n);
+ break;
+ default:
+ CV_StealthSetValue(&cv_newrenderer, cv_renderer.value);
+ }
+}
+
+static void Newrenderer_OnChange(void)
+{
+ /* Well this works for now because there's only two options. */
+ int n;
+ n = cv_newrenderer.value;
+ newrenderer_set |= cv_renderer.value;
+ if (( newrenderer_set & n ))
+ CV_SetValue(&cv_renderer, n);
+ else
+ {
+ M_StartMessage(
+ "The OpenGL renderer is incomplete.\n"
+ "Some visuals may fail to appear, or\n"
+ "appear incorrectly.\n"
+ "Do you still want to switch to it?\n"
+ "\n"
+ "(Press 'y' or 'n')",
+ Newrenderer_AREYOUSURE, MM_YESNO
+ );
+ }
+}
+
void Screenshot_option_Onchange(void)
{
OP_ScreenshotOptionsMenu[op_screenshot_folder].status =
@@ -3766,14 +3819,6 @@ void M_Init(void)
quitmsg[QUIT3MSG5] = M_GetText("You'll be back to play soon, though...\n......right?\n\n(Press 'Y' to quit)");
quitmsg[QUIT3MSG6] = M_GetText("Aww, is Egg Rock Zone too\ndifficult for you?\n\n(Press 'Y' to quit)");
-#ifdef HWRENDER
- // Permanently hide some options based on render mode
- if (rendermode == render_soft)
- OP_VideoOptionsMenu[4].status = IT_DISABLED;
- else if (rendermode == render_opengl)
- OP_ScreenshotOptionsMenu[op_screenshot_colorprofile].status = IT_GRAYEDOUT;
-#endif
-
/*
Well the menu sucks for forcing us to have an item set
at all if every item just calls the same function, and
@@ -3850,19 +3895,19 @@ static void M_DrawThermo(INT32 x, INT32 y, consvar_t *cv)
centerlump[1] = W_GetNumForName("M_THERMM");
cursorlump = W_GetNumForName("M_THERMO");
- V_DrawScaledPatch(xx, y, 0, p = W_CachePatchNum(leftlump,PU_CACHE));
+ V_DrawScaledPatch(xx, y, 0, p = W_CachePatchNum(leftlump,PU_PATCH));
xx += SHORT(p->width) - SHORT(p->leftoffset);
for (i = 0; i < 16; i++)
{
- V_DrawScaledPatch(xx, y, V_WRAPX, W_CachePatchNum(centerlump[i & 1], PU_CACHE));
+ V_DrawScaledPatch(xx, y, V_WRAPX, W_CachePatchNum(centerlump[i & 1], PU_PATCH));
xx += 8;
}
- V_DrawScaledPatch(xx, y, 0, W_CachePatchNum(rightlump, PU_CACHE));
+ V_DrawScaledPatch(xx, y, 0, W_CachePatchNum(rightlump, PU_PATCH));
xx = (cv->value - cv->PossibleValue[0].value) * (15*8) /
(cv->PossibleValue[1].value - cv->PossibleValue[0].value);
- V_DrawScaledPatch((x + 8) + xx, y, 0, W_CachePatchNum(cursorlump, PU_CACHE));
+ V_DrawScaledPatch((x + 8) + xx, y, 0, W_CachePatchNum(cursorlump, PU_PATCH));
}
// A smaller 'Thermo', with range given as percents (0-100)
@@ -3874,9 +3919,9 @@ static void M_DrawSlider(INT32 x, INT32 y, const consvar_t *cv, boolean ontop)
x = BASEVIDWIDTH - x - SLIDER_WIDTH;
- V_DrawScaledPatch(x, y, 0, W_CachePatchName("M_SLIDEL", PU_CACHE));
+ V_DrawScaledPatch(x, y, 0, W_CachePatchName("M_SLIDEL", PU_PATCH));
- p = W_CachePatchName("M_SLIDEM", PU_CACHE);
+ p = W_CachePatchName("M_SLIDEM", PU_PATCH);
for (i = 1; i < SLIDER_RANGE; i++)
V_DrawScaledPatch (x+i*8, y, 0,p);
@@ -3888,11 +3933,11 @@ static void M_DrawSlider(INT32 x, INT32 y, const consvar_t *cv, boolean ontop)
'\x1D' | V_YELLOWMAP, false);
}
- p = W_CachePatchName("M_SLIDER", PU_CACHE);
+ p = W_CachePatchName("M_SLIDER", PU_PATCH);
V_DrawScaledPatch(x+i*8, y, 0, p);
// draw the slider cursor
- p = W_CachePatchName("M_SLIDEC", PU_CACHE);
+ p = W_CachePatchName("M_SLIDEC", PU_PATCH);
for (i = 0; cv->PossibleValue[i+1].strvalue; i++);
@@ -3945,15 +3990,15 @@ void M_DrawTextBox(INT32 x, INT32 y, INT32 width, INT32 boxlines)
// draw left side
cx = x;
cy = y;
- V_DrawScaledPatch(cx, cy, 0, W_CachePatchNum(viewborderlump[BRDR_TL], PU_CACHE));
+ V_DrawScaledPatch(cx, cy, 0, W_CachePatchNum(viewborderlump[BRDR_TL], PU_PATCH));
cy += boff;
- p = W_CachePatchNum(viewborderlump[BRDR_L], PU_CACHE);
+ p = W_CachePatchNum(viewborderlump[BRDR_L], PU_PATCH);
for (n = 0; n < boxlines; n++)
{
V_DrawScaledPatch(cx, cy, V_WRAPY, p);
cy += step;
}
- V_DrawScaledPatch(cx, cy, 0, W_CachePatchNum(viewborderlump[BRDR_BL], PU_CACHE));
+ V_DrawScaledPatch(cx, cy, 0, W_CachePatchNum(viewborderlump[BRDR_BL], PU_PATCH));
// draw middle
V_DrawFlatFill(x + boff, y + boff, width*step, boxlines*step, st_borderpatchnum);
@@ -3962,23 +4007,23 @@ void M_DrawTextBox(INT32 x, INT32 y, INT32 width, INT32 boxlines)
cy = y;
while (width > 0)
{
- V_DrawScaledPatch(cx, cy, V_WRAPX, W_CachePatchNum(viewborderlump[BRDR_T], PU_CACHE));
- V_DrawScaledPatch(cx, y + boff + boxlines*step, V_WRAPX, W_CachePatchNum(viewborderlump[BRDR_B], PU_CACHE));
+ V_DrawScaledPatch(cx, cy, V_WRAPX, W_CachePatchNum(viewborderlump[BRDR_T], PU_PATCH));
+ V_DrawScaledPatch(cx, y + boff + boxlines*step, V_WRAPX, W_CachePatchNum(viewborderlump[BRDR_B], PU_PATCH));
width--;
cx += step;
}
// draw right side
cy = y;
- V_DrawScaledPatch(cx, cy, 0, W_CachePatchNum(viewborderlump[BRDR_TR], PU_CACHE));
+ V_DrawScaledPatch(cx, cy, 0, W_CachePatchNum(viewborderlump[BRDR_TR], PU_PATCH));
cy += boff;
- p = W_CachePatchNum(viewborderlump[BRDR_R], PU_CACHE);
+ p = W_CachePatchNum(viewborderlump[BRDR_R], PU_PATCH);
for (n = 0; n < boxlines; n++)
{
V_DrawScaledPatch(cx, cy, V_WRAPY, p);
cy += step;
}
- V_DrawScaledPatch(cx, cy, 0, W_CachePatchNum(viewborderlump[BRDR_BR], PU_CACHE));
+ V_DrawScaledPatch(cx, cy, 0, W_CachePatchNum(viewborderlump[BRDR_BR], PU_PATCH));
*/
}
@@ -3989,7 +4034,7 @@ static void M_DrawStaticBox(fixed_t x, fixed_t y, INT32 flags, fixed_t w, fixed_
patch_t *patch;
fixed_t sw, pw;
- patch = W_CachePatchName("LSSTATIC", PU_CACHE);
+ patch = W_CachePatchName("LSSTATIC", PU_PATCH);
pw = SHORT(patch->width) - (sw = w*2); //FixedDiv(w, scale); -- for scale FRACUNIT/2
/*if (pw > 0) -- model code for modders providing weird LSSTATIC
@@ -4018,15 +4063,15 @@ static void M_DrawSaveLoadBorder(INT32 x,INT32 y)
{
INT32 i;
- V_DrawScaledPatch (x-8,y+7,0,W_CachePatchName("M_LSLEFT",PU_CACHE));
+ V_DrawScaledPatch (x-8,y+7,0,W_CachePatchName("M_LSLEFT",PU_PATCH));
for (i = 0;i < 24;i++)
{
- V_DrawScaledPatch (x,y+7,0,W_CachePatchName("M_LSCNTR",PU_CACHE));
+ V_DrawScaledPatch (x,y+7,0,W_CachePatchName("M_LSCNTR",PU_PATCH));
x += 8;
}
- V_DrawScaledPatch (x,y+7,0,W_CachePatchName("M_LSRGHT",PU_CACHE));
+ V_DrawScaledPatch (x,y+7,0,W_CachePatchName("M_LSRGHT",PU_PATCH));
}
#endif
@@ -4069,10 +4114,10 @@ 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, false), PU_CACHE),
+ V_DrawSmallMappedPatch(x, y, 0, W_CachePatchName(M_GetEmblemPatch(emblem, false), PU_PATCH),
R_GetTranslationColormap(TC_DEFAULT, M_GetEmblemColor(emblem), GTC_CACHE));
else
- V_DrawSmallScaledPatch(x, y, 0, W_CachePatchName("NEEDIT", PU_CACHE));
+ V_DrawSmallScaledPatch(x, y, 0, W_CachePatchName("NEEDIT", PU_PATCH));
emblem = M_GetLevelEmblems(-1);
x -= 12;
@@ -4083,7 +4128,7 @@ static void M_DrawMenuTitle(void)
{
if (currentMenu->menutitlepic)
{
- patch_t *p = W_CachePatchName(currentMenu->menutitlepic, PU_CACHE);
+ patch_t *p = W_CachePatchName(currentMenu->menutitlepic, PU_PATCH);
if (p->height > 24) // title is larger than normal
{
@@ -4135,13 +4180,13 @@ static void M_DrawGenericMenu(void)
if (currentMenu->menuitems[i].status & IT_CENTER)
{
patch_t *p;
- p = W_CachePatchName(currentMenu->menuitems[i].patch, PU_CACHE);
+ p = W_CachePatchName(currentMenu->menuitems[i].patch, PU_PATCH);
V_DrawScaledPatch((BASEVIDWIDTH - SHORT(p->width))/2, y, 0, p);
}
else
{
V_DrawScaledPatch(x, y, 0,
- W_CachePatchName(currentMenu->menuitems[i].patch, PU_CACHE));
+ W_CachePatchName(currentMenu->menuitems[i].patch, PU_PATCH));
}
}
/* FALLTHRU */
@@ -4210,7 +4255,7 @@ static void M_DrawGenericMenu(void)
case IT_GRAYPATCH:
if (currentMenu->menuitems[i].patch && currentMenu->menuitems[i].patch[0])
V_DrawMappedPatch(x, y, 0,
- W_CachePatchName(currentMenu->menuitems[i].patch,PU_CACHE), graymap);
+ W_CachePatchName(currentMenu->menuitems[i].patch,PU_PATCH), graymap);
y += LINEHEIGHT;
break;
case IT_TRANSTEXT:
@@ -4244,12 +4289,12 @@ static void M_DrawGenericMenu(void)
|| ((currentMenu->menuitems[itemOn].status & IT_DISPLAY) == IT_NOTHING))
{
V_DrawScaledPatch(currentMenu->x + SKULLXOFF, cursory - 5, 0,
- W_CachePatchName("M_CURSOR", PU_CACHE));
+ W_CachePatchName("M_CURSOR", PU_PATCH));
}
else
{
V_DrawScaledPatch(currentMenu->x - 24, cursory, 0,
- W_CachePatchName("M_CURSOR", PU_CACHE));
+ W_CachePatchName("M_CURSOR", PU_PATCH));
V_DrawString(currentMenu->x, cursory, V_YELLOWMAP, currentMenu->menuitems[itemOn].text);
}
}
@@ -4485,7 +4530,7 @@ static void M_DrawGenericScrollMenu(void)
// DRAW THE SKULL CURSOR
V_DrawScaledPatch(currentMenu->x - 24, cursory, 0,
- W_CachePatchName("M_CURSOR", PU_CACHE));
+ W_CachePatchName("M_CURSOR", PU_PATCH));
}
static void M_DrawPauseMenu(void)
@@ -4606,10 +4651,10 @@ static void M_DrawPauseMenu(void)
continue;
if (emblem->collected)
- V_DrawSmallMappedPatch(40, 44 + (i*8), 0, W_CachePatchName(M_GetEmblemPatch(emblem, false), PU_CACHE),
+ V_DrawSmallMappedPatch(40, 44 + (i*8), 0, W_CachePatchName(M_GetEmblemPatch(emblem, false), PU_PATCH),
R_GetTranslationColormap(TC_DEFAULT, M_GetEmblemColor(emblem), GTC_CACHE));
else
- V_DrawSmallScaledPatch(40, 44 + (i*8), 0, W_CachePatchName("NEEDIT", PU_CACHE));
+ V_DrawSmallScaledPatch(40, 44 + (i*8), 0, W_CachePatchName("NEEDIT", PU_PATCH));
switch (emblem->type)
{
@@ -4655,13 +4700,13 @@ static void M_DrawCenteredMenu(void)
if (currentMenu->menuitems[i].status & IT_CENTER)
{
patch_t *p;
- p = W_CachePatchName(currentMenu->menuitems[i].patch, PU_CACHE);
+ p = W_CachePatchName(currentMenu->menuitems[i].patch, PU_PATCH);
V_DrawScaledPatch((BASEVIDWIDTH - SHORT(p->width))/2, y, 0, p);
}
else
{
V_DrawScaledPatch(x, y, 0,
- W_CachePatchName(currentMenu->menuitems[i].patch, PU_CACHE));
+ W_CachePatchName(currentMenu->menuitems[i].patch, PU_PATCH));
}
}
/* FALLTHRU */
@@ -4736,7 +4781,7 @@ static void M_DrawCenteredMenu(void)
case IT_GRAYPATCH:
if (currentMenu->menuitems[i].patch && currentMenu->menuitems[i].patch[0])
V_DrawMappedPatch(x, y, 0,
- W_CachePatchName(currentMenu->menuitems[i].patch,PU_CACHE), graymap);
+ W_CachePatchName(currentMenu->menuitems[i].patch,PU_PATCH), graymap);
y += LINEHEIGHT;
break;
}
@@ -4747,12 +4792,12 @@ static void M_DrawCenteredMenu(void)
|| ((currentMenu->menuitems[itemOn].status & IT_DISPLAY) == IT_NOTHING))
{
V_DrawScaledPatch(x + SKULLXOFF, cursory - 5, 0,
- W_CachePatchName("M_CURSOR", PU_CACHE));
+ W_CachePatchName("M_CURSOR", PU_PATCH));
}
else
{
V_DrawScaledPatch(x - V_StringWidth(currentMenu->menuitems[itemOn].text, 0)/2 - 24, cursory, 0,
- W_CachePatchName("M_CURSOR", PU_CACHE));
+ W_CachePatchName("M_CURSOR", PU_PATCH));
V_DrawCenteredString(x, cursory, V_YELLOWMAP, currentMenu->menuitems[itemOn].text);
}
}
@@ -4900,6 +4945,9 @@ static boolean M_CanShowLevelOnPlatter(INT32 mapnum, INT32 gt)
if (gt == GT_RACE && (mapheaderinfo[mapnum]->typeoflevel & TOL_RACE))
return true;
+ if (gt > 0 && gt < gametypecount && (mapheaderinfo[mapnum]->typeoflevel & gametypetol[gt]))
+ return true;
+
return false;
case LLM_LEVELSELECT:
@@ -4993,6 +5041,22 @@ static INT32 M_CountRowsToShowOnPlatter(INT32 gt)
return rows;
}
+//
+// M_CacheLevelPlatter
+//
+// Cache every patch used by the level platter.
+//
+static void M_CacheLevelPlatter(void)
+{
+ levselp[0][0] = W_CachePatchName("SLCT1LVL", PU_PATCH);
+ levselp[0][1] = W_CachePatchName("SLCT2LVL", PU_PATCH);
+ levselp[0][2] = W_CachePatchName("BLANKLVL", PU_PATCH);
+
+ levselp[1][0] = W_CachePatchName("SLCT1LVW", PU_PATCH);
+ levselp[1][1] = W_CachePatchName("SLCT2LVW", PU_PATCH);
+ levselp[1][2] = W_CachePatchName("BLANKLVW", PU_PATCH);
+}
+
//
// M_PrepareLevelPlatter
//
@@ -5142,24 +5206,7 @@ static boolean M_PrepareLevelPlatter(INT32 gt, boolean nextmappick)
}
#endif
- if (levselp[0][0]) // never going to have some provided but not all, saves individually checking
- {
- W_UnlockCachedPatch(levselp[0][0]);
- W_UnlockCachedPatch(levselp[0][1]);
- W_UnlockCachedPatch(levselp[0][2]);
-
- W_UnlockCachedPatch(levselp[1][0]);
- W_UnlockCachedPatch(levselp[1][1]);
- W_UnlockCachedPatch(levselp[1][2]);
- }
-
- levselp[0][0] = W_CachePatchName("SLCT1LVL", PU_STATIC);
- levselp[0][1] = W_CachePatchName("SLCT2LVL", PU_STATIC);
- levselp[0][2] = W_CachePatchName("BLANKLVL", PU_STATIC);
-
- levselp[1][0] = W_CachePatchName("SLCT1LVW", PU_STATIC);
- levselp[1][1] = W_CachePatchName("SLCT2LVW", PU_STATIC);
- levselp[1][2] = W_CachePatchName("BLANKLVW", PU_STATIC);
+ M_CacheLevelPlatter();
return true;
}
@@ -5380,6 +5427,9 @@ static void M_DrawLevelPlatterWideMap(UINT8 row, UINT8 col, INT32 x, INT32 y, bo
if (map <= 0)
return;
+ if (needpatchrecache)
+ M_CacheLevelPlatter();
+
// A 564x100 image of the level as entry MAPxxW
if (!(levelselect.rows[row].mapavailable[col]))
{
@@ -5389,7 +5439,7 @@ static void M_DrawLevelPlatterWideMap(UINT8 row, UINT8 col, INT32 x, INT32 y, bo
else
{
if (W_CheckNumForName(va("%sW", G_BuildMapName(map))) != LUMPERROR)
- patch = W_CachePatchName(va("%sW", G_BuildMapName(map)), PU_CACHE);
+ patch = W_CachePatchName(va("%sW", G_BuildMapName(map)), PU_PATCH);
else
patch = levselp[1][2]; // don't static to indicate that it's just a normal level
@@ -5411,6 +5461,9 @@ static void M_DrawLevelPlatterMap(UINT8 row, UINT8 col, INT32 x, INT32 y, boolea
if (map <= 0)
return;
+ if (needpatchrecache)
+ M_CacheLevelPlatter();
+
// A 160x100 image of the level as entry MAPxxP
if (!(levelselect.rows[row].mapavailable[col]))
{
@@ -5420,7 +5473,7 @@ static void M_DrawLevelPlatterMap(UINT8 row, UINT8 col, INT32 x, INT32 y, boolea
else
{
if (W_CheckNumForName(va("%sP", G_BuildMapName(map))) != LUMPERROR)
- patch = W_CachePatchName(va("%sP", G_BuildMapName(map)), PU_CACHE);
+ patch = W_CachePatchName(va("%sP", G_BuildMapName(map)), PU_PATCH);
else
patch = levselp[0][2]; // don't static to indicate that it's just a normal level
@@ -5480,8 +5533,8 @@ 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);
+ patch_t *fg = W_CachePatchName("RECATKFG", PU_PATCH);
+ patch_t *clock = W_CachePatchName("RECCLOCK", PU_PATCH);
angle_t fa;
INT32 i;
@@ -5519,7 +5572,7 @@ 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);
+ patch_t *background = W_CachePatchName(curbgname, PU_PATCH);
INT32 x = FixedInt(bgscrollx) % SHORT(background->width);
INT32 y = BASEVIDHEIGHT - SHORT(background->height)*2;
@@ -5542,16 +5595,16 @@ static void M_DrawNightsAttackBackground(void)
INT32 i;
// top
- patch_t *backtopfg = W_CachePatchName("NTSATKT1", PU_CACHE);
- patch_t *fronttopfg = W_CachePatchName("NTSATKT2", PU_CACHE);
+ patch_t *backtopfg = W_CachePatchName("NTSATKT1", PU_PATCH);
+ patch_t *fronttopfg = W_CachePatchName("NTSATKT2", PU_PATCH);
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);
+ patch_t *backbottomfg = W_CachePatchName("NTSATKB1", PU_PATCH);
+ patch_t *frontbottomfg = W_CachePatchName("NTSATKB2", PU_PATCH);
INT32 backbottomwidth = SHORT(backbottomfg->width);
INT32 backbottomheight = SHORT(backbottomfg->height);
INT32 frontbottomwidth = SHORT(frontbottomfg->width);
@@ -5695,7 +5748,7 @@ static void M_DrawLevelPlatterMenu(void)
#if 0
if (levelselect.rows[lsrow].maplist[lscol] > 0)
- V_DrawScaledPatch(lsbasex + cursorx-17, lsbasey+50+lsoffs[0], 0, W_CachePatchName("M_CURSOR", PU_CACHE));
+ V_DrawScaledPatch(lsbasex + cursorx-17, lsbasey+50+lsoffs[0], 0, W_CachePatchName("M_CURSOR", PU_PATCH));
#endif
// handle movement of cursor box
@@ -5965,7 +6018,7 @@ static void M_DrawImageDef(void)
V_DrawScaledPic(0,0,0,W_GetNumForName(currentMenu->menuitems[itemOn].text));
else
{
- patch_t *patch = W_CachePatchName(currentMenu->menuitems[itemOn].text,PU_CACHE);
+ patch_t *patch = W_CachePatchName(currentMenu->menuitems[itemOn].text,PU_PATCH);
if (patch->width <= BASEVIDWIDTH)
V_DrawScaledPatch(0,0,0,patch);
else
@@ -6024,6 +6077,27 @@ static void M_AddonsOptions(INT32 choice)
#define LOCATIONSTRING1 "Visit \x83SRB2.ORG/MODS\x80 to get & make add-ons!"
//#define LOCATIONSTRING2 "Visit \x88SRB2.ORG/MODS\x80 to get & make add-ons!"
+static void M_LoadAddonsPatches(void)
+{
+ addonsp[EXT_FOLDER] = W_CachePatchName("M_FFLDR", PU_PATCH);
+ addonsp[EXT_UP] = W_CachePatchName("M_FBACK", PU_PATCH);
+ addonsp[EXT_NORESULTS] = W_CachePatchName("M_FNOPE", PU_PATCH);
+ addonsp[EXT_TXT] = W_CachePatchName("M_FTXT", PU_PATCH);
+ addonsp[EXT_CFG] = W_CachePatchName("M_FCFG", PU_PATCH);
+ addonsp[EXT_WAD] = W_CachePatchName("M_FWAD", PU_PATCH);
+#ifdef USE_KART
+ addonsp[EXT_KART] = W_CachePatchName("M_FKART", PU_PATCH);
+#endif
+ addonsp[EXT_PK3] = W_CachePatchName("M_FPK3", PU_PATCH);
+ addonsp[EXT_SOC] = W_CachePatchName("M_FSOC", PU_PATCH);
+ addonsp[EXT_LUA] = W_CachePatchName("M_FLUA", PU_PATCH);
+ addonsp[NUM_EXT] = W_CachePatchName("M_FUNKN", PU_PATCH);
+ addonsp[NUM_EXT+1] = W_CachePatchName("M_FSEL", PU_PATCH);
+ addonsp[NUM_EXT+2] = W_CachePatchName("M_FLOAD", PU_PATCH);
+ addonsp[NUM_EXT+3] = W_CachePatchName("M_FSRCH", PU_PATCH);
+ addonsp[NUM_EXT+4] = W_CachePatchName("M_FSAVE", PU_PATCH);
+}
+
static void M_Addons(INT32 choice)
{
const char *pathname = ".";
@@ -6067,30 +6141,7 @@ static void M_Addons(INT32 choice)
else
dir_on[menudepthleft] = 0;
- if (addonsp[0]) // never going to have some provided but not all, saves individually checking
- {
- size_t i;
- for (i = 0; i < NUM_EXT+5; i++)
- W_UnlockCachedPatch(addonsp[i]);
- }
-
- addonsp[EXT_FOLDER] = W_CachePatchName("M_FFLDR", PU_STATIC);
- addonsp[EXT_UP] = W_CachePatchName("M_FBACK", PU_STATIC);
- addonsp[EXT_NORESULTS] = W_CachePatchName("M_FNOPE", PU_STATIC);
- addonsp[EXT_TXT] = W_CachePatchName("M_FTXT", PU_STATIC);
- addonsp[EXT_CFG] = W_CachePatchName("M_FCFG", PU_STATIC);
- addonsp[EXT_WAD] = W_CachePatchName("M_FWAD", PU_STATIC);
-#ifdef USE_KART
- addonsp[EXT_KART] = W_CachePatchName("M_FKART", PU_STATIC);
-#endif
- addonsp[EXT_PK3] = W_CachePatchName("M_FPK3", PU_STATIC);
- addonsp[EXT_SOC] = W_CachePatchName("M_FSOC", PU_STATIC);
- addonsp[EXT_LUA] = W_CachePatchName("M_FLUA", PU_STATIC);
- addonsp[NUM_EXT] = W_CachePatchName("M_FUNKN", PU_STATIC);
- addonsp[NUM_EXT+1] = W_CachePatchName("M_FSEL", PU_STATIC);
- addonsp[NUM_EXT+2] = W_CachePatchName("M_FLOAD", PU_STATIC);
- addonsp[NUM_EXT+3] = W_CachePatchName("M_FSRCH", PU_STATIC);
- addonsp[NUM_EXT+4] = W_CachePatchName("M_FSAVE", PU_STATIC);
+ M_LoadAddonsPatches();
MISC_AddonsDef.prevMenu = currentMenu;
M_SetupNextMenu(&MISC_AddonsDef);
@@ -6230,6 +6281,10 @@ static void M_DrawAddons(void)
return;
}
+ // Lactozilla: Load addons menu patches.
+ if (needpatchrecache)
+ M_LoadAddonsPatches();
+
if (Playing())
V_DrawCenteredString(BASEVIDWIDTH/2, 5, warningflags, "Adding files mid-game may cause problems.");
else
@@ -7165,13 +7220,13 @@ static void M_DrawEmblemHints(void)
if (emblem->collected)
{
collected = V_GREENMAP;
- V_DrawMappedPatch(12, 12+(28*j), 0, W_CachePatchName(M_GetEmblemPatch(emblem, false), PU_CACHE),
+ V_DrawMappedPatch(12, 12+(28*j), 0, W_CachePatchName(M_GetEmblemPatch(emblem, false), PU_PATCH),
R_GetTranslationColormap(TC_DEFAULT, M_GetEmblemColor(emblem), GTC_CACHE));
}
else
{
collected = 0;
- V_DrawScaledPatch(12, 12+(28*j), 0, W_CachePatchName("NEEDIT", PU_CACHE));
+ V_DrawScaledPatch(12, 12+(28*j), 0, W_CachePatchName("NEEDIT", PU_PATCH));
}
if (emblem->hint[0])
@@ -7225,39 +7280,41 @@ static tic_t st_time = 0;
static patch_t* st_radio[9];
static patch_t* st_launchpad[4];
-static void M_SoundTest(INT32 choice)
+static void M_CacheSoundTest(void)
{
- INT32 ul = skyRoomMenuTranslations[choice-1];
UINT8 i;
char buf[8];
- soundtestpage = (UINT8)(unlockables[ul].variable);
- if (!soundtestpage)
- soundtestpage = 1;
-
- if (!S_PrepareSoundTest())
- {
- M_StartMessage(M_GetText("No selectable tracks found.\n"),NULL,MM_NOTHING);
- return;
- }
-
STRBUFCPY(buf, "M_RADIOn");
for (i = 0; i < 9; i++)
{
- if (st_radio[i])
- W_UnlockCachedPatch(st_radio[i]);
buf[7] = (char)('0'+i);
- st_radio[i] = W_CachePatchName(buf, PU_STATIC);
+ st_radio[i] = W_CachePatchName(buf, PU_PATCH);
}
STRBUFCPY(buf, "M_LPADn");
for (i = 0; i < 4; i++)
{
- if (st_launchpad[i])
- W_UnlockCachedPatch(st_launchpad[i]);
buf[6] = (char)('0'+i);
- st_launchpad[i] = W_CachePatchName(buf, PU_STATIC);
+ st_launchpad[i] = W_CachePatchName(buf, PU_PATCH);
}
+}
+
+static void M_SoundTest(INT32 choice)
+{
+ INT32 ul = skyRoomMenuTranslations[choice-1];
+
+ soundtestpage = (UINT8)(unlockables[ul].variable);
+ if (!soundtestpage)
+ soundtestpage = 1;
+
+ if (!S_PrepareSoundTest())
+ {
+ M_StartMessage(M_GetText("No selectable tracks found.\n"),NULL,MM_NOTHING);
+ return;
+ }
+
+ M_CacheSoundTest();
curplaying = NULL;
st_time = 0;
@@ -7276,6 +7333,9 @@ static void M_DrawSoundTest(void)
fixed_t hscale = FRACUNIT/2, vscale = FRACUNIT/2, bounce = 0;
UINT8 frame[4] = {0, 0, -1, SKINCOLOR_RUBY};
+ if (needpatchrecache)
+ M_CacheSoundTest();
+
// let's handle the ticker first. ideally we'd tick this somewhere else, BUT...
if (curplaying)
{
@@ -7848,6 +7908,17 @@ static INT32 saveSlotSelected = 1;
static INT32 loadgamescroll = 0;
static UINT8 loadgameoffset = 0;
+static void M_CacheLoadGameData(void)
+{
+ savselp[0] = W_CachePatchName("SAVEBACK", PU_PATCH);
+ savselp[1] = W_CachePatchName("SAVENONE", PU_PATCH);
+ savselp[2] = W_CachePatchName("ULTIMATE", PU_PATCH);
+
+ savselp[3] = W_CachePatchName("GAMEDONE", PU_PATCH);
+ savselp[4] = W_CachePatchName("BLACXLVL", PU_PATCH);
+ savselp[5] = W_CachePatchName("BLANKLVL", PU_PATCH);
+}
+
static void M_DrawLoadGameData(void)
{
INT32 i, savetodraw, x, y, hsep = 90;
@@ -7856,6 +7927,9 @@ static void M_DrawLoadGameData(void)
if (vid.width != BASEVIDWIDTH*vid.dupx)
hsep = (hsep*vid.width)/(BASEVIDWIDTH*vid.dupx);
+ if (needpatchrecache)
+ M_CacheLoadGameData();
+
for (i = -2; i <= 2; i++)
{
savetodraw = (saveSlotSelected + i + numsaves)%numsaves;
@@ -7964,7 +8038,7 @@ static void M_DrawLoadGameData(void)
{
lumpnum_t lumpnum = W_CheckNumForName(va("%sP", G_BuildMapName((savegameinfo[savetodraw].gamemap) & 8191)));
if (lumpnum != LUMPERROR)
- patch = W_CachePatchNum(lumpnum, PU_CACHE);
+ patch = W_CachePatchNum(lumpnum, PU_PATCH);
else
patch = savselp[5];
}
@@ -8020,7 +8094,7 @@ static void M_DrawLoadGameData(void)
goto skipbot;
colormap = R_GetTranslationColormap(savegameinfo[savetodraw].botskin, charbotskin->prefcolor, 0);
sprframe = &sprdef->spriteframes[0];
- patch = W_CachePatchNum(sprframe->lumppat[0], PU_CACHE);
+ patch = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
V_DrawFixedPatch(
tempx + (18<<FRACBITS),
@@ -8042,7 +8116,7 @@ skipbot:
if (!sprdef->numframes)
goto skipsign;
sprframe = &sprdef->spriteframes[0];
- patch = W_CachePatchNum(sprframe->lumppat[0], PU_CACHE);
+ patch = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
V_DrawFixedPatch(
tempx,
@@ -8066,7 +8140,7 @@ skipsign:
if (!sprdef->numframes)
goto skiplife;
sprframe = &sprdef->spriteframes[0];
- patch = W_CachePatchNum(sprframe->lumppat[0], PU_CACHE);
+ patch = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
V_DrawFixedPatch(
(tempx + 4)<<FRACBITS,
@@ -8077,7 +8151,7 @@ skiplife:
if (colormap)
Z_Free(colormap);
- patch = W_CachePatchName("STLIVEX", PU_CACHE);
+ patch = W_CachePatchName("STLIVEX", PU_PATCH);
V_DrawScaledPatch(tempx + 9, y + 2, 0, patch);
tempx += 16;
@@ -8093,14 +8167,14 @@ skiplife:
// continues
if (savegameinfo[savetodraw].continues > 0)
{
- V_DrawSmallScaledPatch(tempx, y, 0, W_CachePatchName("CONTSAVE", PU_CACHE));
+ V_DrawSmallScaledPatch(tempx, y, 0, W_CachePatchName("CONTSAVE", PU_PATCH));
V_DrawScaledPatch(tempx + 9, y + 2, 0, patch);
V_DrawString(tempx + 16, y, 0, va("%d", savegameinfo[savetodraw].continues));
}
else
{
- V_DrawSmallScaledPatch(tempx, y, 0, W_CachePatchName("CONTNONE", PU_CACHE));
- V_DrawScaledPatch(tempx + 9, y + 2, 0, W_CachePatchName("STNONEX", PU_CACHE));
+ V_DrawSmallScaledPatch(tempx, y, 0, W_CachePatchName("CONTNONE", PU_PATCH));
+ V_DrawScaledPatch(tempx + 9, y + 2, 0, W_CachePatchName("STNONEX", PU_PATCH));
V_DrawString(tempx + 16, y, V_GRAYMAP, "0");
}
}
@@ -8332,24 +8406,7 @@ static void M_ReadSaveStrings(void)
M_ReadSavegameInfo(i);
}
- if (savselp[0]) // never going to have some provided but not all, saves individually checking
- {
- W_UnlockCachedPatch(savselp[0]);
- W_UnlockCachedPatch(savselp[1]);
- W_UnlockCachedPatch(savselp[2]);
-
- W_UnlockCachedPatch(savselp[3]);
- W_UnlockCachedPatch(savselp[4]);
- W_UnlockCachedPatch(savselp[5]);
- }
-
- savselp[0] = W_CachePatchName("SAVEBACK", PU_STATIC);
- savselp[1] = W_CachePatchName("SAVENONE", PU_STATIC);
- savselp[2] = W_CachePatchName("ULTIMATE", PU_STATIC);
-
- savselp[3] = W_CachePatchName("GAMEDONE", PU_STATIC);
- savselp[4] = W_CachePatchName("BLACXLVL", PU_STATIC);
- savselp[5] = W_CachePatchName("BLANKLVL", PU_STATIC);
+ M_CacheLoadGameData();
}
//
@@ -8529,6 +8586,43 @@ void M_ForceSaveSlotSelected(INT32 sslot)
// CHARACTER SELECT
// ================
+// lactozilla: sometimes the renderer changes and these patches don't exist anymore
+static void M_CacheCharacterSelectEntry(INT32 i, INT32 skinnum)
+{
+ if (!(description[i].picname[0]))
+ {
+ if (skins[skinnum].sprites[SPR2_XTRA].numframes > XTRA_CHARSEL)
+ {
+ 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_PATCH);
+ }
+ else
+ description[i].charpic = W_CachePatchName(description[i].picname, PU_PATCH);
+
+ if (description[i].nametag[0])
+ description[i].namepic = W_CachePatchName(description[i].nametag, PU_PATCH);
+}
+
+static void M_CacheCharacterSelect(void)
+{
+ INT32 i, skinnum;
+
+ for (i = 0; i < 32; i++)
+ {
+ if (!description[i].used)
+ continue;
+
+ // Already set in M_SetupChoosePlayer
+ skinnum = description[i].skinnum[0];
+ if ((skinnum != -1) && (R_SkinUsable(-1, skinnum)))
+ M_CacheCharacterSelectEntry(i, skinnum);
+ }
+}
+
static void M_SetupChoosePlayer(INT32 choice)
{
INT32 skinnum;
@@ -8576,27 +8670,7 @@ static void M_SetupChoosePlayer(INT32 choice)
if (i == char_on)
allowed = true;
- if (!(description[i].picname[0]))
- {
- if (skins[skinnum].sprites[SPR2_XTRA].numframes > XTRA_CHARSEL)
- {
- spritedef_t *sprdef = &skins[skinnum].sprites[SPR2_XTRA];
- spriteframe_t *sprframe = &sprdef->spriteframes[XTRA_CHARSEL];
- description[i].charpic = W_CachePatchNum(sprframe->lumppat[0], PU_CACHE);
- }
- else
- description[i].charpic = W_CachePatchName("MISSING", PU_CACHE);
- }
- else
- description[i].charpic = W_CachePatchName(description[i].picname, PU_CACHE);
-
- 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);
- }
+ M_CacheCharacterSelectEntry(i, skinnum);
}
// else -- Technically, character select icons without corresponding skins get bundled away behind this too. Sucks to be them.
}
@@ -8735,8 +8809,8 @@ static void M_DrawSetupChoosePlayerMenu(void)
UINT8 *colormap = NULL;
INT32 prev = -1, next = -1;
- patch_t *charbg = W_CachePatchName("CHARBG", PU_CACHE);
- patch_t *charfg = W_CachePatchName("CHARFG", PU_CACHE);
+ patch_t *charbg = W_CachePatchName("CHARBG", PU_PATCH);
+ patch_t *charfg = W_CachePatchName("CHARFG", PU_PATCH);
INT16 bgheight = SHORT(charbg->height);
INT16 fgheight = SHORT(charfg->height);
INT16 bgwidth = SHORT(charbg->width);
@@ -8744,6 +8818,10 @@ static void M_DrawSetupChoosePlayerMenu(void)
INT32 x, y;
INT32 w = (vid.width/vid.dupx);
+ // lactozilla: the renderer changed so recache patches
+ if (needpatchrecache)
+ M_CacheCharacterSelect();
+
if (abs(char_scroll) > FRACUNIT)
char_scroll -= (char_scroll>>2);
else // close enough.
@@ -8922,7 +9000,7 @@ static void M_DrawSetupChoosePlayerMenu(void)
// Alternative menu header
#ifdef CHOOSEPLAYER_DRAWHEADER
{
- patch_t *header = W_CachePatchName("M_PICKP", PU_CACHE);
+ patch_t *header = W_CachePatchName("M_PICKP", PU_PATCH);
INT32 xtitle = 146;
INT32 ytitle = (35 - SHORT(header->height))/2;
V_DrawFixedPatch(xtitle<<FRACBITS, ytitle<<FRACBITS, FRACUNIT/2, 0, header, NULL);
@@ -9092,10 +9170,10 @@ static void M_DrawStatsMaps(int location)
exemblem = &extraemblems[i];
if (exemblem->collected)
- V_DrawSmallMappedPatch(292, y, 0, W_CachePatchName(M_GetExtraEmblemPatch(exemblem, false), PU_CACHE),
+ V_DrawSmallMappedPatch(292, y, 0, W_CachePatchName(M_GetExtraEmblemPatch(exemblem, false), PU_PATCH),
R_GetTranslationColormap(TC_DEFAULT, M_GetExtraEmblemColor(exemblem), GTC_CACHE));
else
- V_DrawSmallScaledPatch(292, y, 0, W_CachePatchName("NEEDIT", PU_CACHE));
+ V_DrawSmallScaledPatch(292, y, 0, W_CachePatchName("NEEDIT", PU_PATCH));
V_DrawString(20, y, V_YELLOWMAP|V_ALLOWLOWERCASE, va("%s", exemblem->description));
}
@@ -9171,7 +9249,7 @@ static void M_DrawLevelStats(void)
V_DrawString(20, 56, V_GREENMAP, "(complete)");
V_DrawString(36, 64, 0, va("x %d/%d", M_CountEmblems(), numemblems+numextraemblems));
- V_DrawSmallScaledPatch(20, 64, 0, W_CachePatchName("EMBLICON", PU_STATIC));
+ V_DrawSmallScaledPatch(20, 64, 0, W_CachePatchName("EMBLICON", PU_PATCH));
sprintf(beststr, "%u", bestscore);
V_DrawString(BASEVIDWIDTH/2, 48, V_YELLOWMAP, "SCORE:");
@@ -9303,7 +9381,7 @@ void M_DrawTimeAttackMenu(void)
}
// DRAW THE SKULL CURSOR
- V_DrawScaledPatch(currentMenu->x - 24, cursory, 0, W_CachePatchName("M_CURSOR", PU_CACHE));
+ V_DrawScaledPatch(currentMenu->x - 24, cursory, 0, W_CachePatchName("M_CURSOR", PU_PATCH));
V_DrawString(currentMenu->x, cursory, V_YELLOWMAP, currentMenu->menuitems[itemOn].text);
// Character face!
@@ -9312,10 +9390,10 @@ void M_DrawTimeAttackMenu(void)
{
spritedef_t *sprdef = &skins[cv_chooseskin.value-1].sprites[SPR2_XTRA];
spriteframe_t *sprframe = &sprdef->spriteframes[XTRA_CHARSEL];
- PictureOfUrFace = W_CachePatchNum(sprframe->lumppat[0], PU_CACHE);
+ PictureOfUrFace = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
}
else
- PictureOfUrFace = W_CachePatchName("MISSING", PU_CACHE);
+ PictureOfUrFace = W_CachePatchName("MISSING", PU_PATCH);
if (PictureOfUrFace->width >= 256)
V_DrawTinyScaledPatch(224, 120, 0, PictureOfUrFace);
@@ -9343,9 +9421,9 @@ void M_DrawTimeAttackMenu(void)
lumpnum = W_CheckNumForName(va("%sP", G_BuildMapName(cv_nextmap.value)));
if (lumpnum != LUMPERROR)
- PictureOfLevel = W_CachePatchName(va("%sP", G_BuildMapName(cv_nextmap.value)), PU_CACHE);
+ PictureOfLevel = W_CachePatchName(va("%sP", G_BuildMapName(cv_nextmap.value)), PU_PATCH);
else
- PictureOfLevel = W_CachePatchName("BLANKLVL", PU_CACHE);
+ PictureOfLevel = W_CachePatchName("BLANKLVL", PU_PATCH);
y = 32+lsheadingheight;
V_DrawSmallScaledPatch(216, y, 0, PictureOfLevel);
@@ -9390,7 +9468,7 @@ void M_DrawTimeAttackMenu(void)
goto skipThisOne;
}
- empatch = W_CachePatchName(M_GetEmblemPatch(em, true), PU_CACHE);
+ empatch = W_CachePatchName(M_GetEmblemPatch(em, true), PU_PATCH);
empatx = SHORT(empatch->leftoffset)/2;
empaty = SHORT(empatch->topoffset)/2;
@@ -9399,7 +9477,7 @@ void M_DrawTimeAttackMenu(void)
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));
+ V_DrawSmallScaledPatch(104+76, yHeight+lsheadingheight/2, 0, W_CachePatchName("NEEDITL", PU_PATCH));
skipThisOne:
em = M_GetLevelEmblems(-1);
@@ -9579,7 +9657,7 @@ void M_DrawNightsAttackMenu(void)
}
// DRAW THE SKULL CURSOR
- V_DrawScaledPatch(currentMenu->x - 24, cursory, 0, W_CachePatchName("M_CURSOR", PU_CACHE));
+ V_DrawScaledPatch(currentMenu->x - 24, cursory, 0, W_CachePatchName("M_CURSOR", PU_PATCH));
V_DrawString(currentMenu->x, cursory, V_YELLOWMAP, currentMenu->menuitems[itemOn].text);
// Level record list
@@ -9603,9 +9681,9 @@ void M_DrawNightsAttackMenu(void)
lumpnum = W_CheckNumForName(va("%sP", G_BuildMapName(cv_nextmap.value)));
if (lumpnum != LUMPERROR)
- PictureOfLevel = W_CachePatchName(va("%sP", G_BuildMapName(cv_nextmap.value)), PU_CACHE);
+ PictureOfLevel = W_CachePatchName(va("%sP", G_BuildMapName(cv_nextmap.value)), PU_PATCH);
else
- PictureOfLevel = W_CachePatchName("BLANKLVL", PU_CACHE);
+ PictureOfLevel = W_CachePatchName("BLANKLVL", PU_PATCH);
y = 32+lsheadingheight;
V_DrawSmallScaledPatch(208, y, 0, PictureOfLevel);
@@ -9677,10 +9755,10 @@ void M_DrawNightsAttackMenu(void)
}
if (em->collected)
- V_DrawSmallMappedPatch(xpos, yHeight+lsheadingheight/2, 0, W_CachePatchName(M_GetEmblemPatch(em, false), PU_CACHE),
+ V_DrawSmallMappedPatch(xpos, yHeight+lsheadingheight/2, 0, W_CachePatchName(M_GetEmblemPatch(em, false), PU_PATCH),
R_GetTranslationColormap(TC_DEFAULT, M_GetEmblemColor(em), GTC_CACHE));
else
- V_DrawSmallScaledPatch(xpos, yHeight+lsheadingheight/2, 0, W_CachePatchName("NEEDIT", PU_CACHE));
+ V_DrawSmallScaledPatch(xpos, yHeight+lsheadingheight/2, 0, W_CachePatchName("NEEDIT", PU_PATCH));
skipThisOne:
em = M_GetLevelEmblems(-1);
@@ -9716,8 +9794,8 @@ 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);
+ ntssupersonic[0] = W_CachePatchName("NTSSONC1", PU_PATCH);
+ ntssupersonic[1] = W_CachePatchName("NTSSONC2", PU_PATCH);
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
@@ -10148,7 +10226,7 @@ static void M_DrawConnectMenu(void)
va("Ping: %u", (UINT32)LONG(serverlist[slindex].info.time)));
gt = "Unknown";
- if (serverlist[slindex].info.gametype < NUMGAMETYPES)
+ if (serverlist[slindex].info.gametype < gametypecount)
gt = Gametype_Names[serverlist[slindex].info.gametype];
V_DrawSmallString(currentMenu->x+46,S_LINEY(i)+8, globalflags,
@@ -10439,9 +10517,9 @@ static void M_DrawServerMenu(void)
lumpnum = W_CheckNumForName(va("%sP", G_BuildMapName(cv_nextmap.value)));
if (lumpnum != LUMPERROR)
- PictureOfLevel = W_CachePatchName(va("%sP", G_BuildMapName(cv_nextmap.value)), PU_CACHE);
+ PictureOfLevel = W_CachePatchName(va("%sP", G_BuildMapName(cv_nextmap.value)), PU_PATCH);
else
- PictureOfLevel = W_CachePatchName("BLANKLVL", PU_CACHE);
+ PictureOfLevel = W_CachePatchName("BLANKLVL", PU_PATCH);
V_DrawSmallScaledPatch(319 - (currentMenu->x + (SHORT(PictureOfLevel->width)/2)), currentMenu->y + imgheight, 0, PictureOfLevel);
}
@@ -10758,7 +10836,7 @@ static void M_DrawSetupMultiPlayerMenu(void)
multi_frame = 0;
sprframe = &sprdef->spriteframes[multi_frame];
- patch = W_CachePatchNum(sprframe->lumppat[0], PU_CACHE);
+ patch = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
if (sprframe->flip & 1) // Only for first sprite
flags |= V_FLIP; // This sprite is left/right flipped!
@@ -10779,7 +10857,7 @@ faildraw:
return; // Can't render!
sprframe = &sprdef->spriteframes[0];
- patch = W_CachePatchNum(sprframe->lumppat[0], PU_CACHE);
+ patch = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
if (sprframe->flip & 1) // Only for first sprite
flags |= V_FLIP; // This sprite is left/right flipped!
@@ -10850,7 +10928,7 @@ colordraw:
cursory = y;
V_DrawScaledPatch(x - 17, cursory, 0,
- W_CachePatchName("M_CURSOR", PU_CACHE));
+ W_CachePatchName("M_CURSOR", PU_PATCH));
}
// Handle 1P/2P MP Setup
@@ -11176,7 +11254,7 @@ static void M_DrawJoystick(void)
if (i == itemOn)
{
V_DrawScaledPatch(currentMenu->x - 24, OP_JoystickSetDef.y+LINEHEIGHT*i-4, 0,
- W_CachePatchName("M_CURSOR", PU_CACHE));
+ W_CachePatchName("M_CURSOR", PU_PATCH));
}
}
}
@@ -11494,7 +11572,7 @@ static void M_DrawControl(void)
}
V_DrawScaledPatch(currentMenu->x - 20, cursory, 0,
- W_CachePatchName("M_CURSOR", PU_CACHE));
+ W_CachePatchName("M_CURSOR", PU_PATCH));
}
#undef controlbuffer
@@ -11868,7 +11946,7 @@ static void M_DrawVideoMode(void)
j = OP_VideoModeDef.y + 14 + ((vidm_selected % vidm_column_size)*8);
V_DrawScaledPatch(i - 8, j, 0,
- W_CachePatchName("M_CURSOR", PU_CACHE));
+ W_CachePatchName("M_CURSOR", PU_PATCH));
}
// Just M_DrawGenericScrollMenu but showing a backing behind the headers.
@@ -11996,7 +12074,7 @@ static void M_DrawColorMenu(void)
// DRAW THE SKULL CURSOR
V_DrawScaledPatch(currentMenu->x - 24, cursory, 0,
- W_CachePatchName("M_CURSOR", PU_CACHE));
+ W_CachePatchName("M_CURSOR", PU_PATCH));
}
// special menuitem key handler for video mode list
@@ -12074,17 +12152,7 @@ static void M_HandleVideoMode(INT32 ch)
static void M_DrawScreenshotMenu(void)
{
-
M_DrawGenericScrollMenu();
-#ifdef HWRENDER
- if ((rendermode == render_opengl) && (itemOn < 7)) // where it starts to go offscreen; change this number if you change the layout of the screenshot menu
- {
- INT32 y = currentMenu->y+currentMenu->menuitems[op_screenshot_colorprofile].alphaKey*2;
- if (itemOn == 6)
- y -= 10;
- V_DrawRightAlignedString(BASEVIDWIDTH - currentMenu->x, y, V_REDMAP, "ON");
- }
-#endif
}
// ===============
@@ -12169,7 +12237,7 @@ void M_QuitResponse(INT32 ch)
ptime = I_GetTime() + NEWTICRATE*2; // Shortened the quit time, used to be 2 seconds Tails 03-26-2001
while (ptime > I_GetTime())
{
- V_DrawScaledPatch(0, 0, 0, W_CachePatchName("GAMEQUIT", PU_CACHE)); // Demo 3 Quit Screen Tails 06-16-2001
+ V_DrawScaledPatch(0, 0, 0, W_CachePatchName("GAMEQUIT", PU_PATCH)); // Demo 3 Quit Screen Tails 06-16-2001
I_FinishUpdate(); // Update the screen with the image Tails 06-19-2001
I_Sleep();
}
diff --git a/src/m_menu.h b/src/m_menu.h
index 09bf371cbfd989e0cab83538a2f9070d2fcf716e..7730133ebd86d6fe5cc308e02e805ad3542effcf 100644
--- a/src/m_menu.h
+++ b/src/m_menu.h
@@ -373,6 +373,7 @@ typedef struct
UINT8 col[2];
char notes[441];
} gtdesc_t;
+extern gtdesc_t gametypedesc[NUMGAMETYPES];
// mode descriptions for video mode menu
typedef struct
diff --git a/src/m_misc.c b/src/m_misc.c
index 0fe1b6087a26d1d1fe2bf4643f387656aa21e4cb..13607a66c6908b3274172e4242a7657a59ea8a29 100644
--- a/src/m_misc.c
+++ b/src/m_misc.c
@@ -1779,7 +1779,7 @@ char *M_GetToken(const char *inputString)
|| stringToUse[startPos] == '\r'
|| stringToUse[startPos] == '\n'
|| stringToUse[startPos] == '\0'
- || stringToUse[startPos] == '"' // we're treating this as whitespace because SLADE likes adding it for no good reason
+ || stringToUse[startPos] == '=' || stringToUse[startPos] == ';' // UDMF TEXTMAP.
|| inComment != 0)
&& startPos < stringLength)
{
@@ -1837,6 +1837,23 @@ char *M_GetToken(const char *inputString)
texturesToken[1] = '\0';
return texturesToken;
}
+ // Return entire string within quotes, except without the quotes.
+ else if (stringToUse[startPos] == '"')
+ {
+ endPos = ++startPos;
+ while (stringToUse[endPos] != '"' && endPos < stringLength)
+ endPos++;
+
+ texturesTokenLength = endPos++ - startPos;
+ // Assign the memory. Don't forget an extra byte for the end of the string!
+ texturesToken = (char *)Z_Malloc((texturesTokenLength+1)*sizeof(char),PU_STATIC,NULL);
+ // Copy the string.
+ M_Memcpy(texturesToken, stringToUse+startPos, (size_t)texturesTokenLength);
+ // Make the final character NUL.
+ texturesToken[texturesTokenLength] = '\0';
+
+ return texturesToken;
+ }
// Now find the end of the token. This includes several additional characters that are okay to capture as one character, but not trailing at the end of another token.
endPos = startPos + 1;
@@ -1847,7 +1864,7 @@ char *M_GetToken(const char *inputString)
&& stringToUse[endPos] != ','
&& stringToUse[endPos] != '{'
&& stringToUse[endPos] != '}'
- && stringToUse[endPos] != '"' // see above
+ && stringToUse[endPos] != '=' && stringToUse[endPos] != ';' // UDMF TEXTMAP.
&& inComment == 0)
&& endPos < stringLength)
{
diff --git a/src/p_enemy.c b/src/p_enemy.c
index 74a11fe6735027ad018f110a031ffdc82e274f0a..ce201844ff74c9b093b591d52b2a052686c4e586 100644
--- a/src/p_enemy.c
+++ b/src/p_enemy.c
@@ -181,11 +181,9 @@ void A_SpawnObjectAbsolute(mobj_t *actor);
void A_SpawnObjectRelative(mobj_t *actor);
void A_ChangeAngleRelative(mobj_t *actor);
void A_ChangeAngleAbsolute(mobj_t *actor);
-#ifdef ROTSPRITE
void A_RollAngle(mobj_t *actor);
void A_ChangeRollAngleRelative(mobj_t *actor);
void A_ChangeRollAngleAbsolute(mobj_t *actor);
-#endif // ROTSPRITE
void A_PlaySound(mobj_t *actor);
void A_FindTarget(mobj_t *actor);
void A_FindTracer(mobj_t *actor);
@@ -2263,7 +2261,7 @@ void A_CrushclawLaunch(mobj_t *actor)
while (chain)
{
P_TeleportMove(chain, actor->target->x + idx, actor->target->y + idy, actor->target->z + idz);
- chain->watertop = chain->z;
+ chain->movefactor = chain->z;
idx += dx;
idy += dy;
idz += dz;
@@ -4985,7 +4983,7 @@ void A_ThrownRing(mobj_t *actor)
continue;
// Don't home in on teammates.
- if (gametype == GT_CTF
+ if ((gametyperules & GTR_TEAMFLAGS)
&& actor->target->player->ctfteam == player->ctfteam)
continue;
}
@@ -6591,7 +6589,7 @@ void A_OldRingExplode(mobj_t *actor) {
if (changecolor)
{
- if (gametype != GT_CTF)
+ if (!(gametyperules & GTR_TEAMFLAGS))
mo->color = actor->target->color; //copy color
else if (actor->target->player->ctfteam == 2)
mo->color = skincolor_bluering;
@@ -6607,7 +6605,7 @@ void A_OldRingExplode(mobj_t *actor) {
if (changecolor)
{
- if (gametype != GT_CTF)
+ if (!(gametyperules & GTR_TEAMFLAGS))
mo->color = actor->target->color; //copy color
else if (actor->target->player->ctfteam == 2)
mo->color = skincolor_bluering;
@@ -6622,7 +6620,7 @@ void A_OldRingExplode(mobj_t *actor) {
if (changecolor)
{
- if (gametype != GT_CTF)
+ if (!(gametyperules & GTR_TEAMFLAGS))
mo->color = actor->target->color; //copy color
else if (actor->target->player->ctfteam == 2)
mo->color = skincolor_bluering;
@@ -8627,7 +8625,6 @@ void A_ChangeAngleAbsolute(mobj_t *actor)
actor->angle = FixedAngle(P_RandomRange(amin, amax));
}
-#ifdef ROTSPRITE
// Function: A_RollAngle
//
// Description: Changes the roll angle.
@@ -8663,16 +8660,10 @@ void A_RollAngle(mobj_t *actor)
//
void A_ChangeRollAngleRelative(mobj_t *actor)
{
- // Oh god, the old code /sucked/. Changed this and the absolute version to get a random range using amin and amax instead of
- // getting a random angle from the _entire_ spectrum and then clipping. While we're at it, do the angle conversion to the result
- // rather than the ranges, so <0 and >360 work as possible values. -Red
INT32 locvar1 = var1;
INT32 locvar2 = var2;
- //angle_t angle = (P_RandomByte()+1)<<24;
const fixed_t amin = locvar1*FRACUNIT;
const fixed_t amax = locvar2*FRACUNIT;
- //const angle_t amin = FixedAngle(locvar1*FRACUNIT);
- //const angle_t amax = FixedAngle(locvar2*FRACUNIT);
#ifdef HAVE_BLUA
if (LUA_CallAction("A_ChangeRollAngleRelative", actor))
return;
@@ -8682,11 +8673,6 @@ void A_ChangeRollAngleRelative(mobj_t *actor)
if (amin > amax)
I_Error("A_ChangeRollAngleRelative: var1 is greater than var2");
#endif
-/*
- if (angle < amin)
- angle = amin;
- if (angle > amax)
- angle = amax;*/
actor->rollangle += FixedAngle(P_RandomRange(amin, amax));
}
@@ -8702,11 +8688,8 @@ void A_ChangeRollAngleAbsolute(mobj_t *actor)
{
INT32 locvar1 = var1;
INT32 locvar2 = var2;
- //angle_t angle = (P_RandomByte()+1)<<24;
const fixed_t amin = locvar1*FRACUNIT;
const fixed_t amax = locvar2*FRACUNIT;
- //const angle_t amin = FixedAngle(locvar1*FRACUNIT);
- //const angle_t amax = FixedAngle(locvar2*FRACUNIT);
#ifdef HAVE_BLUA
if (LUA_CallAction("A_ChangeRollAngleAbsolute", actor))
return;
@@ -8716,15 +8699,9 @@ void A_ChangeRollAngleAbsolute(mobj_t *actor)
if (amin > amax)
I_Error("A_ChangeRollAngleAbsolute: var1 is greater than var2");
#endif
-/*
- if (angle < amin)
- angle = amin;
- if (angle > amax)
- angle = amax;*/
actor->rollangle = FixedAngle(P_RandomRange(amin, amax));
}
-#endif // ROTSPRITE
// Function: A_PlaySound
//
@@ -13614,12 +13591,12 @@ static boolean PIT_DustDevilLaunch(mobj_t *thing)
}
else
{ //Player on the top of the tornado.
+ P_ResetPlayer(player);
thing->z = dustdevil->z + dustdevil->height;
thrust = 20 * FRACUNIT;
player->powers[pw_nocontrol] = 0;
S_StartSound(thing, sfx_wdjump);
P_SetPlayerMobjState(thing, S_PLAY_FALL);
- player->pflags &= ~PF_JUMPED;
}
thing->momz = thrust;
@@ -14248,7 +14225,7 @@ void A_SaloonDoorSpawn(mobj_t *actor)
fixed_t c = FINECOSINE(fa)*locvar2;
fixed_t s = FINESINE(fa)*locvar2;
mobj_t *door;
- mobjflag2_t ambush = (actor->flags & MF2_AMBUSH);
+ mobjflag2_t ambush = (actor->flags2 & MF2_AMBUSH);
#ifdef HAVE_BLUA
if (LUA_CallAction("A_SaloonDoorSpawn", actor))
@@ -14712,20 +14689,35 @@ void A_DragonWing(mobj_t *actor)
void A_DragonSegment(mobj_t *actor)
{
mobj_t *target = actor->target;
- fixed_t dist = P_AproxDistance(P_AproxDistance(actor->x - target->x, actor->y - target->y), actor->z - target->z);
- fixed_t radius = actor->radius + target->radius;
- angle_t hangle = R_PointToAngle2(target->x, target->y, actor->x, actor->y);
- angle_t zangle = R_PointToAngle2(0, target->z, dist, actor->z);
- fixed_t hdist = P_ReturnThrustX(target, zangle, radius);
- fixed_t xdist = P_ReturnThrustX(target, hangle, hdist);
- fixed_t ydist = P_ReturnThrustY(target, hangle, hdist);
- fixed_t zdist = P_ReturnThrustY(target, zangle, radius);
+ fixed_t dist;
+ fixed_t radius;
+ angle_t hangle;
+ angle_t zangle;
+ fixed_t hdist;
+ fixed_t xdist;
+ fixed_t ydist;
+ fixed_t zdist;
#ifdef HAVE_BLUA
if (LUA_CallAction("A_DragonSegment", actor))
return;
#endif
+ if (target == NULL || !target->health)
+ {
+ P_RemoveMobj(actor);
+ return;
+ }
+
+ dist = P_AproxDistance(P_AproxDistance(actor->x - target->x, actor->y - target->y), actor->z - target->z);
+ radius = actor->radius + target->radius;
+ hangle = R_PointToAngle2(target->x, target->y, actor->x, actor->y);
+ zangle = R_PointToAngle2(0, target->z, dist, actor->z);
+ hdist = P_ReturnThrustX(target, zangle, radius);
+ xdist = P_ReturnThrustX(target, hangle, hdist);
+ ydist = P_ReturnThrustY(target, hangle, hdist);
+ zdist = P_ReturnThrustY(target, zangle, radius);
+
actor->angle = hangle;
P_TeleportMove(actor, target->x + xdist, target->y + ydist, target->z + zdist);
}
diff --git a/src/p_inter.c b/src/p_inter.c
index 1acbad085e44a0a91742648cfd9a4dd4876024be..f39415cd67f5cbe8ef0901ffb74ac538621cc814 100644
--- a/src/p_inter.c
+++ b/src/p_inter.c
@@ -625,7 +625,7 @@ void P_TouchSpecialThing(mobj_t *special, mobj_t *toucher, boolean heightcheck)
P_AddPlayerScore(player, 1000);
- if (gametype != GT_COOP || modeattacking) // score only?
+ if (!(gametyperules & GTR_SPECIALSTAGES) || modeattacking) // score only?
{
S_StartSound(toucher, sfx_chchng);
break;
@@ -1888,7 +1888,7 @@ static void P_HitDeathMessages(player_t *player, mobj_t *inflictor, mobj_t *sour
char targetname[MAXPLAYERNAME+4];
char sourcename[MAXPLAYERNAME+4];
- if (G_PlatformGametype())
+ if (!(gametyperules & (GTR_RINGSLINGER|GTR_HURTMESSAGES)))
return; // Not in coop, etc.
if (!player)
@@ -2093,7 +2093,7 @@ void P_CheckTimeLimit(void)
if (!(multiplayer || netgame))
return;
- if (G_PlatformGametype())
+ if (!(gametyperules & GTR_TIMELIMIT))
return;
if (leveltime < timelimitintics)
@@ -2124,7 +2124,7 @@ void P_CheckTimeLimit(void)
}
//Optional tie-breaker for Match/CTF
- else if (cv_overtime.value)
+ else if ((cv_overtime.value) && (gametyperules & GTR_OVERTIME))
{
INT32 playerarray[MAXPLAYERS];
INT32 tempplayer = 0;
@@ -2206,7 +2206,7 @@ void P_CheckPointLimit(void)
if (!(multiplayer || netgame))
return;
- if (G_PlatformGametype())
+ if (!(gametyperules & GTR_POINTLIMIT))
return;
// pointlimit is nonzero, check if it's been reached by this player
@@ -2389,7 +2389,7 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
{
if (metalrecording) // Ack! Metal Sonic shouldn't die! Cut the tape, end recording!
G_StopMetalRecording(true);
- if (gametype == GT_MATCH // note, no team match suicide penalty
+ if ((gametyperules & GTR_DEATHPENALTY) // note, no team match suicide penalty
&& ((target == source) || (source == NULL && inflictor == NULL) || (source && !source->player)))
{ // Suicide penalty
if (target->player->score >= 50)
@@ -2481,9 +2481,7 @@ void P_KillMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, UINT8 damaget
P_SetMobjState(scoremobj, scorestate);
- // On ground? No chain starts.
- if (source->player->powers[pw_invulnerability] || !P_IsObjectOnGround(source))
- source->player->scoreadd = locscoreadd;
+ source->player->scoreadd = locscoreadd;
}
}
@@ -2978,7 +2976,7 @@ static void P_NiGHTSDamage(mobj_t *target, mobj_t *source)
player->flyangle += 180; // Shuffle's BETTERNIGHTSMOVEMENT?
player->flyangle %= 360;
- if (gametype == GT_RACE || gametype == GT_COMPETITION)
+ if (gametyperules & GTR_RACE)
player->drillmeter -= 5*20;
else
{
@@ -3005,9 +3003,7 @@ static void P_NiGHTSDamage(mobj_t *target, mobj_t *source)
P_SetPlayerMobjState(target, S_PLAY_NIGHTS_STUN);
S_StartSound(target, sfx_nghurt);
-#ifdef ROTSPRITE
player->mo->rollangle = 0;
-#endif
if (oldnightstime > 10*TICRATE
&& player->nightstime < 10*TICRATE)
@@ -3042,7 +3038,7 @@ static boolean P_TagDamage(mobj_t *target, mobj_t *inflictor, mobj_t *source, IN
return false;
// Ignore IT players shooting each other, unless friendlyfire is on.
- if ((player->pflags & PF_TAGIT && !((cv_friendlyfire.value || (damagetype & DMG_CANHURTSELF)) &&
+ if ((player->pflags & PF_TAGIT && !((cv_friendlyfire.value || (gametyperules & GTR_FRIENDLYFIRE) || (damagetype & DMG_CANHURTSELF)) &&
source && source->player && source->player->pflags & PF_TAGIT)))
{
if (inflictor->type == MT_LHRT && !(player->powers[pw_shield] & SH_NOSTACK))
@@ -3058,7 +3054,7 @@ static boolean P_TagDamage(mobj_t *target, mobj_t *inflictor, mobj_t *source, IN
// Don't allow players on the same team to hurt one another,
// unless cv_friendlyfire is on.
- if (!(cv_friendlyfire.value || (damagetype & DMG_CANHURTSELF)) && (player->pflags & PF_TAGIT) == (source->player->pflags & PF_TAGIT))
+ if (!(cv_friendlyfire.value || (gametyperules & GTR_FRIENDLYFIRE) || (damagetype & DMG_CANHURTSELF)) && (player->pflags & PF_TAGIT) == (source->player->pflags & PF_TAGIT))
{
if (inflictor->type == MT_LHRT && !(player->powers[pw_shield] & SH_NOSTACK))
{
@@ -3143,7 +3139,7 @@ static boolean P_PlayerHitsPlayer(mobj_t *target, mobj_t *inflictor, mobj_t *sou
return false;
// In COOP/RACE, you can't hurt other players unless cv_friendlyfire is on
- if (!cv_friendlyfire.value && (G_PlatformGametype()))
+ if (!(cv_friendlyfire.value || (gametyperules & GTR_FRIENDLYFIRE)) && (G_PlatformGametype()))
{
if (gametype == GT_COOP && inflictor->type == MT_LHRT && !(player->powers[pw_shield] & SH_NOSTACK)) // co-op only
{
@@ -3166,7 +3162,7 @@ static boolean P_PlayerHitsPlayer(mobj_t *target, mobj_t *inflictor, mobj_t *sou
{
// Don't allow players on the same team to hurt one another,
// unless cv_friendlyfire is on.
- if (!cv_friendlyfire.value && target->player->ctfteam == source->player->ctfteam)
+ if (!(cv_friendlyfire.value || (gametyperules & GTR_FRIENDLYFIRE)) && target->player->ctfteam == source->player->ctfteam)
{
if (inflictor->type == MT_LHRT && !(player->powers[pw_shield] & SH_NOSTACK))
{
@@ -3224,7 +3220,7 @@ static void P_KillPlayer(player_t *player, mobj_t *source, INT32 damage)
player->mo->flags2 &= ~MF2_DONTDRAW;
P_SetPlayerMobjState(player->mo, player->mo->info->deathstate);
- if (gametype == GT_CTF && (player->gotflag & (GF_REDFLAG|GF_BLUEFLAG)))
+ if ((gametyperules & GTR_TEAMFLAGS) && (player->gotflag & (GF_REDFLAG|GF_BLUEFLAG)))
{
P_PlayerFlagBurst(player, false);
if (source && source->player)
@@ -3349,7 +3345,7 @@ static void P_ShieldDamage(player_t *player, mobj_t *inflictor, mobj_t *source,
else
S_StartSound (player->mo, sfx_shldls); // Ba-Dum! Shield loss.
- if (gametype == GT_CTF && (player->gotflag & (GF_REDFLAG|GF_BLUEFLAG)))
+ if ((gametyperules & GTR_TEAMFLAGS) && (player->gotflag & (GF_REDFLAG|GF_BLUEFLAG)))
{
P_PlayerFlagBurst(player, false);
if (source && source->player)
@@ -3383,7 +3379,7 @@ static void P_RingDamage(player_t *player, mobj_t *inflictor, mobj_t *source, IN
P_AddPlayerScore(source->player, 50);
}
- if (gametype == GT_CTF && (player->gotflag & (GF_REDFLAG|GF_BLUEFLAG)))
+ if ((gametyperules & GTR_TEAMFLAGS) && (player->gotflag & (GF_REDFLAG|GF_BLUEFLAG)))
{
P_PlayerFlagBurst(player, false);
if (source && source->player)
@@ -3426,6 +3422,24 @@ void P_SpecialStageDamage(player_t *player, mobj_t *inflictor, mobj_t *source)
if (player->powers[pw_invulnerability] || player->powers[pw_flashing] || player->powers[pw_super])
return;
+ if (!cv_friendlyfire.value)
+ {
+ if (inflictor->type == MT_LHRT && !(player->powers[pw_shield] & SH_NOSTACK))
+ {
+ if (player->revitem != MT_LHRT && player->spinitem != MT_LHRT && player->thokitem != MT_LHRT) // Healers do not get to heal other healers.
+ {
+ P_SwitchShield(player, SH_PINK);
+ S_StartSound(player->mo, mobjinfo[MT_PITY_ICON].seesound);
+ }
+ }
+
+ if (source->player->ctfteam == player->ctfteam)
+ return;
+ }
+
+ if (inflictor->type == MT_LHRT)
+ return;
+
if (player->powers[pw_shield] || player->bot) //If One-Hit Shield
{
P_RemoveShield(player);
@@ -3442,7 +3456,7 @@ void P_SpecialStageDamage(player_t *player, mobj_t *inflictor, mobj_t *source)
P_DoPlayerPain(player, inflictor, source);
- if (gametype == GT_CTF && player->gotflag & (GF_REDFLAG|GF_BLUEFLAG))
+ if ((gametyperules & GTR_TEAMFLAGS) && player->gotflag & (GF_REDFLAG|GF_BLUEFLAG))
P_PlayerFlagBurst(player, false);
if (oldnightstime > 10*TICRATE
@@ -3593,7 +3607,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
{
if (source == target)
return false; // Don't hit yourself with your own paraloop, baka
- if (source && source->player && !cv_friendlyfire.value
+ if (source && source->player && !(cv_friendlyfire.value || (gametyperules & GTR_FRIENDLYFIRE))
&& (gametype == GT_COOP
|| (G_GametypeHasTeams() && player->ctfteam == source->player->ctfteam)))
return false; // Don't run eachother over in special stages and team games and such
@@ -3688,7 +3702,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
// by friendly fire. Spilling their rings and other items is enough.
else if (!force && G_GametypeHasTeams()
&& source && source->player && (source->player->ctfteam == player->ctfteam)
- && cv_friendlyfire.value)
+ && (cv_friendlyfire.value || (gametyperules & GTR_FRIENDLYFIRE)))
{
damage = 0;
P_ShieldDamage(player, inflictor, source, damage, damagetype);
diff --git a/src/p_map.c b/src/p_map.c
index b6519ffca0c7acff5c07ab41ee35e4d272aaa341..0c78f7fb8a1b2aa4486dd81a574369e04303d021 100644
--- a/src/p_map.c
+++ b/src/p_map.c
@@ -615,7 +615,7 @@ static void P_DoTailsCarry(player_t *sonic, player_t *tails)
// Why block opposing teams from tailsflying each other?
// Sneaking into the hands of a flying tails player in Race might be a viable strategy, who knows.
/*
- if (gametype == GT_RACE || gametype == GT_COMPETITION
+ if ((gametyperules & GTR_RACE)
|| (netgame && (tails->spectator || sonic->spectator))
|| (G_TagGametype() && (!(tails->pflags & PF_TAGIT) != !(sonic->pflags & PF_TAGIT)))
|| (gametype == GT_MATCH)
@@ -829,13 +829,13 @@ static boolean PIT_CheckThing(mobj_t *thing)
for (iter = thing->subsector->sector->thinglist; iter; iter = iter->snext)
if (iter->type == thing->type && iter->health > 0 && iter->flags & MF_SOLID && (iter == thing || P_AproxDistance(P_AproxDistance(thing->x - iter->x, thing->y - iter->y), thing->z - iter->z) < 56*thing->scale))//FixedMul(56*FRACUNIT, thing->scale))
P_KillMobj(iter, tmthing, tmthing, 0);
+ return true;
}
else
{
- thing->health = 0;
- P_KillMobj(thing, tmthing, tmthing, 0);
+ if (P_DamageMobj(thing, tmthing, tmthing, 1, 0))
+ return true;
}
- return true;
}
// vectorise metal - done in a special case as at this point neither has the right flags for touching
@@ -995,7 +995,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
if (thing->type == MT_SALOONDOOR && tmthing->player)
{
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)
+ if ((thing->flags2 & MF2_AMBUSH) || ref != tmthing)
{
fixed_t dm = min(FixedHypot(ref->momx, ref->momy), 16*FRACUNIT);
angle_t ang = R_PointToAngle2(0, 0, ref->momx, ref->momy) - thing->angle;
@@ -1008,7 +1008,7 @@ static boolean PIT_CheckThing(mobj_t *thing)
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)))
+ if ((thing->flags2 & MF2_AMBUSH) || (tmthing->player->powers[pw_carry] == CR_MINECART && tmthing->tracer && !P_MobjWasRemoved(tmthing->tracer)))
return true;
}
diff --git a/src/p_mobj.c b/src/p_mobj.c
index dea4a7a4d2528217d12b62f44cd5726ad2506bfd..5c0ed12923cb6bebe494e401c532a80a76157f31 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -7143,2903 +7143,3047 @@ static void P_PyreFlyBurn(mobj_t *mobj, fixed_t hoffs, INT16 vrange, mobjtype_t
particle->momz = momz;
}
-//
-// P_MobjThinker
-//
-void P_MobjThinker(mobj_t *mobj)
+static void P_MobjScaleThink(mobj_t *mobj)
{
- I_Assert(mobj != NULL);
- I_Assert(!P_MobjWasRemoved(mobj));
-
- if (mobj->flags & MF_NOTHINK)
- return;
-
- if ((mobj->flags & MF_BOSS) && mobj->spawnpoint && (bossdisabled & (1<<mobj->spawnpoint->extrainfo)))
- return;
+ fixed_t oldheight = mobj->height;
+ UINT8 correctionType = 0; // Don't correct Z position, just gain height
- // Remove dead target/tracer.
- if (mobj->target && P_MobjWasRemoved(mobj->target))
- P_SetTarget(&mobj->target, NULL);
- if (mobj->tracer && P_MobjWasRemoved(mobj->tracer))
- P_SetTarget(&mobj->tracer, NULL);
- if (mobj->hnext && P_MobjWasRemoved(mobj->hnext))
- P_SetTarget(&mobj->hnext, NULL);
- if (mobj->hprev && P_MobjWasRemoved(mobj->hprev))
- P_SetTarget(&mobj->hprev, NULL);
+ if ((mobj->flags & MF_NOCLIPHEIGHT || (mobj->z > mobj->floorz && mobj->z + mobj->height < mobj->ceilingz))
+ && mobj->type != MT_EGGMOBILE_FIRE)
+ correctionType = 1; // Correct Z position by centering
+ else if (mobj->eflags & MFE_VERTICALFLIP)
+ correctionType = 2; // Correct Z position by moving down
+
+ if (abs(mobj->scale - mobj->destscale) < mobj->scalespeed)
+ P_SetScale(mobj, mobj->destscale);
+ else if (mobj->scale < mobj->destscale)
+ P_SetScale(mobj, mobj->scale + mobj->scalespeed);
+ else if (mobj->scale > mobj->destscale)
+ P_SetScale(mobj, mobj->scale - mobj->scalespeed);
+
+ if (correctionType == 1)
+ mobj->z -= (mobj->height - oldheight)/2;
+ else if (correctionType == 2)
+ mobj->z -= mobj->height - oldheight;
+
+ if (mobj->scale == mobj->destscale)
+ /// \todo Lua hook for "reached destscale"?
+ switch (mobj->type)
+ {
+ case MT_EGGMOBILE_FIRE:
+ mobj->destscale = FRACUNIT;
+ mobj->scalespeed = FRACUNIT>>4;
+ break;
+ default:
+ break;
+ }
+}
- mobj->eflags &= ~(MFE_PUSHED|MFE_SPRUNG);
+static void P_MaceSceneryThink(mobj_t *mobj)
+{
+ angle_t oldmovedir = mobj->movedir;
- tmfloorthing = tmhitthing = NULL;
+ // Always update movedir to prevent desyncing (in the traditional sense, not the netplay sense).
+ mobj->movedir = (mobj->movedir + mobj->lastlook) & FINEMASK;
- // 970 allows ANY mobj to trigger a linedef exec
- if (mobj->subsector && GETSECSPECIAL(mobj->subsector->sector->special, 2) == 8)
+ // If too far away and not deliberately spitting in the face of optimisation, don't think!
+ if (!(mobj->flags2 & MF2_BOSSNOTRAP))
{
- sector_t *sec2;
-
- sec2 = P_ThingOnSpecial3DFloor(mobj);
- if (sec2 && GETSECSPECIAL(sec2->special, 2) == 1)
- P_LinedefExecute(sec2->tag, mobj, sec2);
- }
+ UINT8 i;
+ // Quick! Look through players! Don't move unless a player is relatively close by.
+ // The below is selected based on CEZ2's first room. I promise you it is a coincidence that it looks like the weed number.
+ for (i = 0; i < MAXPLAYERS; ++i)
+ if (playeringame[i] && players[i].mo
+ && P_AproxDistance(P_AproxDistance(mobj->x - players[i].mo->x, mobj->y - players[i].mo->y), mobj->z - players[i].mo->z) < (4200 << FRACBITS))
+ break; // Stop looking.
+ if (i == MAXPLAYERS)
+ {
+ if (!(mobj->flags2 & MF2_BEYONDTHEGRAVE))
+ {
+ mobj_t *ref = mobj;
- // Slowly scale up/down to reach your destscale.
- if (mobj->scale != mobj->destscale)
- {
- fixed_t oldheight = mobj->height;
- UINT8 correctionType = 0; // Don't correct Z position, just gain height
+ // stop/hide all your babies
+ while ((ref = ref->hnext))
+ {
+ ref->eflags = (((ref->flags & MF_NOTHINK) ? 0 : 1)
+ | ((ref->flags & MF_NOCLIPTHING) ? 0 : 2)
+ | ((ref->flags2 & MF2_DONTDRAW) ? 0 : 4)); // oh my god this is nasty.
+ ref->flags |= MF_NOTHINK|MF_NOCLIPTHING;
+ ref->flags2 |= MF2_DONTDRAW;
+ ref->momx = ref->momy = ref->momz = 0;
+ }
- if ((mobj->flags & MF_NOCLIPHEIGHT || (mobj->z > mobj->floorz && mobj->z + mobj->height < mobj->ceilingz))
- && mobj->type != MT_EGGMOBILE_FIRE)
- correctionType = 1; // Correct Z position by centering
- else if (mobj->eflags & MFE_VERTICALFLIP)
- correctionType = 2; // Correct Z position by moving down
-
- if (abs(mobj->scale - mobj->destscale) < mobj->scalespeed)
- P_SetScale(mobj, mobj->destscale);
- else if (mobj->scale < mobj->destscale)
- P_SetScale(mobj, mobj->scale + mobj->scalespeed);
- else if (mobj->scale > mobj->destscale)
- P_SetScale(mobj, mobj->scale - mobj->scalespeed);
-
- if (correctionType == 1)
- mobj->z -= (mobj->height - oldheight)/2;
- else if (correctionType == 2)
- mobj->z -= mobj->height - oldheight;
+ mobj->flags2 |= MF2_BEYONDTHEGRAVE;
+ }
+ return; // don't make bubble!
+ }
+ else if (mobj->flags2 & MF2_BEYONDTHEGRAVE)
+ {
+ mobj_t *ref = mobj;
- if (mobj->scale == mobj->destscale)
- /// \todo Lua hook for "reached destscale"?
- switch(mobj->type)
+ // start/show all your babies
+ while ((ref = ref->hnext))
{
- case MT_EGGMOBILE_FIRE:
- mobj->destscale = FRACUNIT;
- mobj->scalespeed = FRACUNIT>>4;
- break;
- default:
- break;
+ if (ref->eflags & 1)
+ ref->flags &= ~MF_NOTHINK;
+ if (ref->eflags & 2)
+ ref->flags &= ~MF_NOCLIPTHING;
+ if (ref->eflags & 4)
+ ref->flags2 &= ~MF2_DONTDRAW;
+ ref->eflags = 0; // le sign
}
- }
- if ((mobj->type == MT_GHOST || mobj->type == MT_THOK) && mobj->fuse > 0) // Not guaranteed to be MF_SCENERY or not MF_SCENERY!
- {
- if (mobj->flags2 & MF2_BOSSNOTRAP) // "fast" flag
- {
- if ((signed)((mobj->frame & FF_TRANSMASK) >> FF_TRANSSHIFT) < (NUMTRANSMAPS-1) - (2*mobj->fuse)/3)
- // fade out when nearing the end of fuse...
- mobj->frame = (mobj->frame & ~FF_TRANSMASK) | (((NUMTRANSMAPS-1) - (2*mobj->fuse)/3) << FF_TRANSSHIFT);
- }
- else
- {
- if ((signed)((mobj->frame & FF_TRANSMASK) >> FF_TRANSSHIFT) < (NUMTRANSMAPS-1) - mobj->fuse / 2)
- // fade out when nearing the end of fuse...
- mobj->frame = (mobj->frame & ~FF_TRANSMASK) | (((NUMTRANSMAPS-1) - mobj->fuse / 2) << FF_TRANSSHIFT);
+ mobj->flags2 &= ~MF2_BEYONDTHEGRAVE;
}
}
- // Special thinker for scenery objects
- if (mobj->flags & MF_SCENERY)
- {
-#ifdef HAVE_BLUA
- if (LUAh_MobjThinker(mobj))
- return;
- if (P_MobjWasRemoved(mobj))
- return;
-#endif
+ // Okay, time to MOVE
+ P_MaceRotate(mobj, mobj->movedir, oldmovedir);
+}
- if (mobj->flags2 & MF2_SHIELD)
- if (!P_AddShield(mobj))
- return;
+static boolean P_DrownNumbersSceneryThink(mobj_t *mobj)
+{
+ if (!mobj->target)
+ {
+ P_RemoveMobj(mobj);
+ return false;
+ }
+ if (!mobj->target->player || !(mobj->target->player->powers[pw_underwater] || mobj->target->player->powers[pw_spacetime]))
+ {
+ P_RemoveMobj(mobj);
+ return false;
+ }
+ mobj->x = mobj->target->x;
+ mobj->y = mobj->target->y;
- switch (mobj->type)
- {
- case MT_BOSSJUNK:
- mobj->flags2 ^= MF2_DONTDRAW;
- break;
- case MT_MACEPOINT:
- case MT_CHAINMACEPOINT:
- case MT_SPRINGBALLPOINT:
- case MT_CHAINPOINT:
- case MT_FIREBARPOINT:
- case MT_CUSTOMMACEPOINT:
- case MT_HIDDEN_SLING:
- {
- angle_t oldmovedir = mobj->movedir;
+ mobj->destscale = mobj->target->destscale;
+ P_SetScale(mobj, mobj->target->scale);
- // Always update movedir to prevent desyncing (in the traditional sense, not the netplay sense).
- mobj->movedir = (mobj->movedir + mobj->lastlook) & FINEMASK;
+ if (mobj->target->eflags & MFE_VERTICALFLIP)
+ {
+ mobj->z = mobj->target->z - FixedMul(16*FRACUNIT, mobj->target->scale) - mobj->height;
+ if (mobj->target->player->pflags & PF_FLIPCAM)
+ mobj->eflags |= MFE_VERTICALFLIP;
+ }
+ else
+ mobj->z = mobj->target->z + (mobj->target->height) + FixedMul(8*FRACUNIT, mobj->target->scale); // Adjust height for height changes
- // If too far away and not deliberately spitting in the face of optimisation, don't think!
- if (!(mobj->flags2 & MF2_BOSSNOTRAP))
- {
- UINT8 i;
- // Quick! Look through players! Don't move unless a player is relatively close by.
- // The below is selected based on CEZ2's first room. I promise you it is a coincidence that it looks like the weed number.
- for (i = 0; i < MAXPLAYERS; ++i)
- if (playeringame[i] && players[i].mo
- && P_AproxDistance(P_AproxDistance(mobj->x - players[i].mo->x, mobj->y - players[i].mo->y), mobj->z - players[i].mo->z) < (4200<<FRACBITS))
- break; // Stop looking.
- if (i == MAXPLAYERS)
- {
- if (!(mobj->flags2 & MF2_BEYONDTHEGRAVE))
- {
- mobj_t *ref = mobj;
+ if (mobj->threshold <= 35)
+ mobj->flags2 |= MF2_DONTDRAW;
+ else
+ mobj->flags2 &= ~MF2_DONTDRAW;
+ if (mobj->threshold <= 30)
+ mobj->threshold = 40;
+ mobj->threshold--;
+ return true;
+}
- // stop/hide all your babies
- while ((ref = ref->hnext))
- {
- ref->eflags = (((ref->flags & MF_NOTHINK) ? 0 : 1)
- | ((ref->flags & MF_NOCLIPTHING) ? 0 : 2)
- | ((ref->flags2 & MF2_DONTDRAW) ? 0 : 4)); // oh my god this is nasty.
- ref->flags |= MF_NOTHINK|MF_NOCLIPTHING;
- ref->flags2 |= MF2_DONTDRAW;
- ref->momx = ref->momy = ref->momz = 0;
- }
+static void P_FlameJetSceneryThink(mobj_t *mobj)
+{
+ mobj_t *flame;
+ fixed_t strength;
- mobj->flags2 |= MF2_BEYONDTHEGRAVE;
- }
+ if (!(mobj->flags2 & MF2_FIRING))
+ return;
- break; // don't make bubble!
- }
- else if (mobj->flags2 & MF2_BEYONDTHEGRAVE)
- {
- mobj_t *ref = mobj;
+ if ((leveltime & 3) == 0)
+ return;
- // start/show all your babies
- while ((ref = ref->hnext))
- {
- if (ref->eflags & 1)
- ref->flags &= ~MF_NOTHINK;
- if (ref->eflags & 2)
- ref->flags &= ~MF_NOCLIPTHING;
- if (ref->eflags & 4)
- ref->flags2 &= ~MF2_DONTDRAW;
- ref->eflags = 0; // le sign
- }
+ // Wave the flames back and forth. Reactiontime determines which direction it's going.
+ if (mobj->fuse <= -16)
+ mobj->reactiontime = 1;
+ else if (mobj->fuse >= 16)
+ mobj->reactiontime = 0;
- mobj->flags2 &= ~MF2_BEYONDTHEGRAVE;
- }
- }
+ if (mobj->reactiontime)
+ mobj->fuse += 2;
+ else
+ mobj->fuse -= 2;
- // Okay, time to MOVE
- P_MaceRotate(mobj, mobj->movedir, oldmovedir);
- }
- break;
- case MT_HOOP:
- if (mobj->fuse > 1)
- P_MoveHoop(mobj);
- else if (mobj->fuse == 1)
- mobj->movecount = 1;
+ flame = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_FLAMEJETFLAME);
+ P_SetMobjState(flame, S_FLAMEJETFLAME4);
- if (mobj->movecount)
- {
- mobj->fuse++;
+ flame->angle = mobj->angle;
- if (mobj->fuse > 32)
- {
- // Don't kill the hoop center. For the sake of respawning.
- //if (mobj->target)
- // P_RemoveMobj(mobj->target);
+ if (mobj->flags2 & MF2_AMBUSH) // Wave up and down instead of side-to-side
+ flame->momz = mobj->fuse << (FRACBITS - 2);
+ else
+ flame->angle += FixedAngle(mobj->fuse<<FRACBITS);
- P_RemoveMobj(mobj);
- }
- }
- else
- mobj->fuse--;
- return;
- case MT_NIGHTSPARKLE:
- if (mobj->tics != -1)
- {
- mobj->tics--;
+ strength = 20*FRACUNIT;
+ strength -= ((20*FRACUNIT)/16)*mobj->movedir;
- // you can cycle through multiple states in a tic
- if (!mobj->tics)
- if (!P_SetMobjState(mobj, mobj->state->nextstate))
- return; // freed itself
- }
+ P_InstaThrust(flame, flame->angle, strength);
+ S_StartSound(flame, sfx_fire);
+}
- P_UnsetThingPosition(mobj);
- mobj->x += mobj->momx;
- mobj->y += mobj->momy;
- mobj->z += mobj->momz;
- P_SetThingPosition(mobj);
- return;
- case MT_NIGHTSLOOPHELPER:
- if (--mobj->tics <= 0)
- P_RemoveMobj(mobj);
+static void P_VerticalFlameJetSceneryThink(mobj_t *mobj)
+{
+ mobj_t *flame;
+ fixed_t strength;
- // Don't touch my fuse!
- return;
- case MT_OVERLAY:
- if (!mobj->target)
- {
- P_RemoveMobj(mobj);
- return;
- }
- else
- P_AddOverlay(mobj);
- break;
- case MT_PITY_ORB:
- case MT_WHIRLWIND_ORB:
- case MT_ARMAGEDDON_ORB:
- if (!(mobj->flags2 & MF2_SHIELD))
- return;
- break;
- case MT_ATTRACT_ORB:
- if (!(mobj->flags2 & MF2_SHIELD))
- return;
- if (/*(mobj->target) -- the following is implicit by P_AddShield
- && (mobj->target->player)
- && */ (mobj->target->player->homing) && (mobj->target->player->pflags & PF_SHIELDABILITY))
- {
- P_SetMobjState(mobj, mobj->info->painstate);
- mobj->tics++;
- }
- break;
- case MT_ELEMENTAL_ORB:
- if (!(mobj->flags2 & MF2_SHIELD))
- return;
- if (mobj->tracer
- /* && mobj->target -- the following is implicit by P_AddShield
- && mobj->target->player
- && (mobj->target->player->powers[pw_shield] & SH_NOSTACK) == SH_ELEMENTAL */
- && mobj->target->player->pflags & PF_SHIELDABILITY
- && ((statenum_t)(mobj->tracer->state-states) < mobj->info->raisestate
- || (mobj->tracer->state->nextstate < mobj->info->raisestate && mobj->tracer->tics == 1)))
- {
- P_SetMobjState(mobj, mobj->info->painstate);
- mobj->tics++;
- P_SetMobjState(mobj->tracer, mobj->info->raisestate);
- mobj->tracer->tics++;
- }
- break;
- case MT_FORCE_ORB:
- if (!(mobj->flags2 & MF2_SHIELD))
- return;
- if (/*
- && mobj->target -- the following is implicit by P_AddShield
- && mobj->target->player
- && (mobj->target->player->powers[pw_shield] & SH_FORCE)
- && */ (mobj->target->player->pflags & PF_SHIELDABILITY))
- {
- mobj_t *whoosh = P_SpawnMobjFromMobj(mobj, 0, 0, 0, MT_GHOST); // done here so the offset is correct
- P_SetMobjState(whoosh, mobj->info->raisestate);
- whoosh->destscale = whoosh->scale<<1;
- whoosh->scalespeed = FixedMul(whoosh->scalespeed, whoosh->scale);
- whoosh->height = 38*whoosh->scale;
- whoosh->fuse = 10;
- whoosh->flags |= MF_NOCLIPHEIGHT;
- whoosh->momz = mobj->target->momz; // Stay reasonably centered for a few frames
- mobj->target->player->pflags &= ~PF_SHIELDABILITY; // prevent eternal whoosh
- }
- /* FALLTHRU */
- case MT_FLAMEAURA_ORB:
- if (!(mobj->flags2 & MF2_SHIELD))
- return;
- if ((statenum_t)(mobj->state-states) < mobj->info->painstate)
- mobj->angle = mobj->target->angle; // implicitly okay because of P_AddShield
- if (mobj->tracer
- /* && mobj->target -- the following is implicit by P_AddShield
- && mobj->target->player
- && (mobj->target->player->powers[pw_shield] & SH_NOSTACK) == SH_FLAMEAURA */
- && mobj->target->player->pflags & PF_SHIELDABILITY
- && ((statenum_t)(mobj->tracer->state-states) < mobj->info->raisestate
- || (mobj->tracer->state->nextstate < mobj->info->raisestate && mobj->tracer->tics == 1)))
- {
- P_SetMobjState(mobj, mobj->info->painstate);
- mobj->tics++;
- P_SetMobjState(mobj->tracer, mobj->info->raisestate);
- mobj->tracer->tics++;
- }
- break;
- case MT_BUBBLEWRAP_ORB:
- if (!(mobj->flags2 & MF2_SHIELD))
- return;
- if (mobj->tracer
- /* && mobj->target -- the following is implicit by P_AddShield
- && mobj->target->player
- && (mobj->target->player->powers[pw_shield] & SH_NOSTACK) == SH_BUBBLEWRAP */
- )
- {
- if (mobj->target->player->pflags & PF_SHIELDABILITY
- && ((statenum_t)(mobj->state-states) < mobj->info->painstate
- || (mobj->state->nextstate < mobj->info->painstate && mobj->tics == 1)))
- {
- P_SetMobjState(mobj, mobj->info->painstate);
- mobj->tics++;
- P_SetMobjState(mobj->tracer, mobj->info->raisestate);
- mobj->tracer->tics++;
- }
- else if (mobj->target->eflags & MFE_JUSTHITFLOOR
- && (statenum_t)(mobj->state-states) == mobj->info->painstate)
- {
- P_SetMobjState(mobj, mobj->info->painstate+1);
- mobj->tics++;
- P_SetMobjState(mobj->tracer, mobj->info->raisestate+1);
- mobj->tracer->tics++;
- }
- }
- break;
- case MT_THUNDERCOIN_ORB:
- if (!(mobj->flags2 & MF2_SHIELD))
- return;
- if (mobj->tracer
- /* && mobj->target -- the following is implicit by P_AddShield
- && mobj->target->player
- && (mobj->target->player->powers[pw_shield] & SH_NOSTACK) == SH_THUNDERCOIN */
- && (mobj->target->player->pflags & PF_SHIELDABILITY))
- {
- P_SetMobjState(mobj, mobj->info->painstate);
- mobj->tics++;
- P_SetMobjState(mobj->tracer, mobj->info->raisestate);
- mobj->tracer->tics++;
- mobj->target->player->pflags &= ~PF_SHIELDABILITY; // prevent eternal spark
- }
- break;
- case MT_WATERDROP:
- P_SceneryCheckWater(mobj);
- if ((mobj->z <= mobj->floorz || mobj->z <= mobj->watertop)
- && mobj->health > 0)
- {
- mobj->health = 0;
- P_SetMobjState(mobj, mobj->info->deathstate);
- S_StartSound(mobj, mobj->info->deathsound+P_RandomKey(mobj->info->mass));
- return;
- }
- break;
- case MT_BUBBLES:
- P_SceneryCheckWater(mobj);
- break;
- case MT_SMALLBUBBLE:
- case MT_MEDIUMBUBBLE:
- case MT_EXTRALARGEBUBBLE: // start bubble dissipate
- P_SceneryCheckWater(mobj);
- if (P_MobjWasRemoved(mobj)) // bubble was removed by not being in water
- return;
- if (!(mobj->eflags & MFE_UNDERWATER)
- || (!(mobj->eflags & MFE_VERTICALFLIP) && mobj->z + mobj->height >= mobj->ceilingz)
- || (mobj->eflags & MFE_VERTICALFLIP && mobj->z <= mobj->floorz)
- || (P_CheckDeathPitCollide(mobj))
- || --mobj->fuse <= 0) // Bubbles eventually dissipate if they can't reach the surface.
- {
- // no playing sound: no point; the object is being removed
- P_RemoveMobj(mobj);
- return;
- }
- break;
- case MT_LOCKON:
- if (!mobj->target)
- {
- P_RemoveMobj(mobj);
- return;
- }
+ if (!(mobj->flags2 & MF2_FIRING))
+ return;
- mobj->flags2 &= ~MF2_DONTDRAW;
+ if ((leveltime & 3) == 0)
+ return;
- mobj->x = mobj->target->x;
- mobj->y = mobj->target->y;
+ // Wave the flames back and forth. Reactiontime determines which direction it's going.
+ if (mobj->fuse <= -16)
+ mobj->reactiontime = 1;
+ else if (mobj->fuse >= 16)
+ mobj->reactiontime = 0;
- mobj->eflags |= (mobj->target->eflags & MFE_VERTICALFLIP);
+ if (mobj->reactiontime)
+ mobj->fuse++;
+ else
+ mobj->fuse--;
- mobj->destscale = mobj->target->destscale;
- P_SetScale(mobj, mobj->target->scale);
+ flame = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_FLAMEJETFLAME);
- if (!(mobj->eflags & MFE_VERTICALFLIP))
- mobj->z = mobj->target->z + mobj->target->height + FixedMul((16 + abs((signed)(leveltime % TICRATE) - TICRATE/2))*FRACUNIT, mobj->target->scale);
- else
- mobj->z = mobj->target->z - FixedMul((16 + abs((signed)(leveltime % TICRATE) - TICRATE/2))*FRACUNIT, mobj->target->scale) - mobj->height;
- break;
- case MT_LOCKONINF:
- if (!(mobj->flags2 & MF2_STRONGBOX))
- {
- mobj->threshold = mobj->z;
- mobj->flags2 |= MF2_STRONGBOX;
- }
- if (!(mobj->eflags & MFE_VERTICALFLIP))
- mobj->z = mobj->threshold + FixedMul((16 + abs((signed)(leveltime % TICRATE) - TICRATE/2))*FRACUNIT, mobj->scale);
- else
- mobj->z = mobj->threshold - FixedMul((16 + abs((signed)(leveltime % TICRATE) - TICRATE/2))*FRACUNIT, mobj->scale);
- break;
- case MT_DROWNNUMBERS:
- if (!mobj->target)
- {
- P_RemoveMobj(mobj);
- return;
- }
- if (!mobj->target->player || !(mobj->target->player->powers[pw_underwater] || mobj->target->player->powers[pw_spacetime]))
- {
- P_RemoveMobj(mobj);
- return;
- }
- mobj->x = mobj->target->x;
- mobj->y = mobj->target->y;
+ strength = 20*FRACUNIT;
+ strength -= ((20*FRACUNIT)/16)*mobj->movedir;
- mobj->destscale = mobj->target->destscale;
- P_SetScale(mobj, mobj->target->scale);
+ // If deaf'd, the object spawns on the ceiling.
+ if (mobj->flags2 & MF2_AMBUSH)
+ {
+ mobj->z = mobj->ceilingz - mobj->height;
+ 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);
+}
- if (mobj->target->eflags & MFE_VERTICALFLIP)
- {
- mobj->z = mobj->target->z - FixedMul(16*FRACUNIT, mobj->target->scale) - mobj->height;
- if (mobj->target->player->pflags & PF_FLIPCAM)
- mobj->eflags |= MFE_VERTICALFLIP;
- }
- else
- mobj->z = mobj->target->z + (mobj->target->height) + FixedMul(8*FRACUNIT, mobj->target->scale); // Adjust height for height changes
+static boolean P_ParticleGenSceneryThink(mobj_t *mobj)
+{
+ if (!mobj->lastlook)
+ return false;
- if (mobj->threshold <= 35)
- mobj->flags2 |= MF2_DONTDRAW;
- else
- mobj->flags2 &= ~MF2_DONTDRAW;
- if (mobj->threshold <= 30)
- mobj->threshold = 40;
- mobj->threshold--;
- break;
- case MT_FLAMEJET:
- if ((mobj->flags2 & MF2_FIRING) && (leveltime & 3) == 0)
- {
- mobj_t *flame;
- fixed_t strength;
+ if (!mobj->threshold)
+ return false;
- // Wave the flames back and forth. Reactiontime determines which direction it's going.
- if (mobj->fuse <= -16)
- mobj->reactiontime = 1;
- else if (mobj->fuse >= 16)
- mobj->reactiontime = 0;
+ if (--mobj->fuse <= 0)
+ {
+ INT32 i = 0;
+ mobj_t *spawn;
+ fixed_t bottomheight, topheight;
+ INT32 type = mobj->threshold, line = mobj->cvmem;
- if (mobj->reactiontime)
- mobj->fuse += 2;
- else
- mobj->fuse -= 2;
+ mobj->fuse = (tic_t)mobj->reactiontime;
- flame = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_FLAMEJETFLAME);
- P_SetMobjState(flame, S_FLAMEJETFLAME4);
+ bottomheight = lines[line].frontsector->floorheight;
+ topheight = lines[line].frontsector->ceilingheight - mobjinfo[(mobjtype_t)type].height;
- flame->angle = mobj->angle;
+ if (mobj->waterbottom != bottomheight || mobj->watertop != topheight)
+ {
+ if (mobj->movefactor && (topheight > bottomheight))
+ mobj->health = (tic_t)(FixedDiv((topheight - bottomheight), abs(mobj->movefactor)) >> FRACBITS);
+ else
+ mobj->health = 0;
- if (mobj->flags2 & MF2_AMBUSH) // Wave up and down instead of side-to-side
- flame->momz = mobj->fuse << (FRACBITS-2);
- else
- flame->angle += FixedAngle(mobj->fuse*FRACUNIT);
+ mobj->z = ((mobj->flags2 & MF2_OBJECTFLIP) ? topheight : bottomheight);
+ }
- strength = 20*FRACUNIT;
- strength -= ((20*FRACUNIT)/16)*mobj->movedir;
+ if (!mobj->health)
+ return false;
- P_InstaThrust(flame, flame->angle, strength);
- S_StartSound(flame, sfx_fire);
- }
- break;
- case MT_VERTICALFLAMEJET:
- if ((mobj->flags2 & MF2_FIRING) && (leveltime & 3) == 0)
- {
- mobj_t *flame;
- fixed_t strength;
+ for (i = 0; i < mobj->lastlook; i++)
+ {
+ spawn = P_SpawnMobj(
+ mobj->x + FixedMul(FixedMul(mobj->friction, mobj->scale), FINECOSINE(mobj->angle >> ANGLETOFINESHIFT)),
+ mobj->y + FixedMul(FixedMul(mobj->friction, mobj->scale), FINESINE(mobj->angle >> ANGLETOFINESHIFT)),
+ mobj->z,
+ (mobjtype_t)mobj->threshold);
+ P_SetScale(spawn, mobj->scale);
+ spawn->momz = FixedMul(mobj->movefactor, spawn->scale);
+ spawn->destscale = spawn->scale/100;
+ spawn->scalespeed = spawn->scale/mobj->health;
+ spawn->tics = (tic_t)mobj->health;
+ spawn->flags2 |= (mobj->flags2 & MF2_OBJECTFLIP);
+ spawn->angle += P_RandomKey(36)*ANG10; // irrelevant for default objects but might make sense for some custom ones
- // Wave the flames back and forth. Reactiontime determines which direction it's going.
- if (mobj->fuse <= -16)
- mobj->reactiontime = 1;
- else if (mobj->fuse >= 16)
- mobj->reactiontime = 0;
+ mobj->angle += mobj->movedir;
+ }
- if (mobj->reactiontime)
- mobj->fuse++;
- else
- mobj->fuse--;
+ mobj->angle += (angle_t)mobj->movecount;
+ }
- flame = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_FLAMEJETFLAME);
+ return true;
+}
- strength = 20*FRACUNIT;
- strength -= ((20*FRACUNIT)/16)*mobj->movedir;
+static void P_RosySceneryThink(mobj_t *mobj)
+{
+ 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 deaf'd, the object spawns on the ceiling.
- if (mobj->flags2 & MF2_AMBUSH)
- {
- mobj->z = mobj->ceilingz-mobj->height;
- 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);
- }
- break;
- case MT_FLICKY_01_CENTER:
- case MT_FLICKY_02_CENTER:
- case MT_FLICKY_03_CENTER:
- case MT_FLICKY_04_CENTER:
- case MT_FLICKY_05_CENTER:
- case MT_FLICKY_06_CENTER:
- case MT_FLICKY_07_CENTER:
- case MT_FLICKY_08_CENTER:
- case MT_FLICKY_09_CENTER:
- case MT_FLICKY_10_CENTER:
- case MT_FLICKY_11_CENTER:
- case MT_FLICKY_12_CENTER:
- case MT_FLICKY_13_CENTER:
- case MT_FLICKY_14_CENTER:
- case MT_FLICKY_15_CENTER:
- case MT_FLICKY_16_CENTER:
- case MT_SECRETFLICKY_01_CENTER:
- case MT_SECRETFLICKY_02_CENTER:
- if (mobj->tracer && (mobj->flags & MF_NOCLIPTHING)
- && (mobj->flags & MF_GRENADEBOUNCE))
- // for now: only do this bounce routine if flicky is in-place. \todo allow in all movements
- {
- if (!(mobj->tracer->flags2 & MF2_OBJECTFLIP) && mobj->tracer->z <= mobj->tracer->floorz)
- mobj->tracer->momz = 7*FRACUNIT;
- else if ((mobj->tracer->flags2 & MF2_OBJECTFLIP) && mobj->tracer->z >= mobj->tracer->ceilingz - mobj->tracer->height)
- mobj->tracer->momz = -7*FRACUNIT;
- }
- break;
- case MT_SEED:
- if (P_MobjFlip(mobj)*mobj->momz < mobj->info->speed)
- mobj->momz = P_MobjFlip(mobj)*mobj->info->speed;
- break;
- case MT_ROCKCRUMBLE1:
- case MT_ROCKCRUMBLE2:
- case MT_ROCKCRUMBLE3:
- case MT_ROCKCRUMBLE4:
- case MT_ROCKCRUMBLE5:
- case MT_ROCKCRUMBLE6:
- case MT_ROCKCRUMBLE7:
- case MT_ROCKCRUMBLE8:
- case MT_ROCKCRUMBLE9:
- case MT_ROCKCRUMBLE10:
- case MT_ROCKCRUMBLE11:
- case MT_ROCKCRUMBLE12:
- case MT_ROCKCRUMBLE13:
- case MT_ROCKCRUMBLE14:
- case MT_ROCKCRUMBLE15:
- 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])
- {
- P_SetMobjState(mobj, mobj->info->deathstate);
- return;
- }
- break;
- case MT_PARTICLEGEN:
- if (!mobj->lastlook)
- return;
-
- if (!mobj->threshold)
- return;
-
- if (--mobj->fuse <= 0)
- {
- INT32 i = 0;
- mobj_t *spawn;
- fixed_t bottomheight, topheight;
- INT32 type = mobj->threshold, line = mobj->cvmem;
-
- mobj->fuse = (tic_t)mobj->reactiontime;
-
- bottomheight = lines[line].frontsector->floorheight;
- topheight = lines[line].frontsector->ceilingheight - mobjinfo[(mobjtype_t)type].height;
-
- if (mobj->waterbottom != bottomheight || mobj->watertop != topheight)
- {
- if (mobj->movefactor && (topheight > bottomheight))
- mobj->health = (tic_t)(FixedDiv((topheight - bottomheight), abs(mobj->movefactor)) >> FRACBITS);
- else
- mobj->health = 0;
-
- mobj->z = ((mobj->flags2 & MF2_OBJECTFLIP) ? topheight : bottomheight);
- }
-
- if (!mobj->health)
- return;
-
- for (i = 0; i < mobj->lastlook; i++)
- {
- spawn = P_SpawnMobj(
- mobj->x + FixedMul(FixedMul(mobj->friction, mobj->scale), FINECOSINE(mobj->angle>>ANGLETOFINESHIFT)),
- mobj->y + FixedMul(FixedMul(mobj->friction, mobj->scale), FINESINE(mobj->angle>>ANGLETOFINESHIFT)),
- mobj->z,
- (mobjtype_t)mobj->threshold);
- P_SetScale(spawn, mobj->scale);
- spawn->momz = FixedMul(mobj->movefactor, spawn->scale);
- spawn->destscale = spawn->scale/100;
- spawn->scalespeed = spawn->scale/mobj->health;
- spawn->tics = (tic_t)mobj->health;
- spawn->flags2 |= (mobj->flags2 & MF2_OBJECTFLIP);
- spawn->angle += P_RandomKey(36)*ANG10; // irrelevant for default objects but might make sense for some custom ones
-
- mobj->angle += mobj->movedir;
- }
-
- mobj->angle += (angle_t)mobj->movecount;
- }
- break;
- case MT_FSGNA:
- 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, (INT32)mobj->movedir)*3;
- if (strength < 10)
- mobj->frame |= ((10-strength)<<(FF_TRANSSHIFT));
- }
- /* FALLTHRU */
- default:
- if (mobj->fuse)
- { // Scenery object fuse! Very basic!
- mobj->fuse--;
- if (!mobj->fuse)
- {
-#ifdef HAVE_BLUA
- if (!LUAh_MobjFuse(mobj))
-#endif
- P_RemoveMobj(mobj);
- return;
- }
- }
- break;
+ 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);
}
-
- P_SceneryThinker(mobj);
- return;
+ else if (P_MobjFlip(mobj)*mobj->momz < 0)
+ mobj->frame = mobj->state->frame + mobj->state->var1;
}
-#ifdef HAVE_BLUA
- // Check for a Lua thinker first
- if (!mobj->player)
- {
- if (LUAh_MobjThinker(mobj) || P_MobjWasRemoved(mobj))
- return;
- }
- else if (!mobj->player->spectator)
- {
- // You cannot short-circuit the player thinker like you can other thinkers.
- LUAh_MobjThinker(mobj);
- if (P_MobjWasRemoved(mobj))
- return;
- }
-#endif
- // if it's pushable, or if it would be pushable other than temporary disablement, use the
- // separate thinker
- if (mobj->flags & MF_PUSHABLE || (mobj->info->flags & MF_PUSHABLE && mobj->fuse))
+ if (!player)
{
- P_MobjCheckWater(mobj);
- P_PushableThinker(mobj);
-
- // Extinguish fire objects in water. (Yes, it's extraordinarily rare to have a pushable flame object, but Brak uses such a case.)
- if (mobj->flags & MF_FIRE && mobj->type != MT_PUMA && mobj->type != MT_FIREBALL
- && (mobj->eflags & (MFE_UNDERWATER|MFE_TOUCHWATER)))
+ if ((stat < S_ROSY_IDLE1 || stat > S_ROSY_IDLE4) && stat != S_ROSY_JUMP)
{
- P_KillMobj(mobj, NULL, NULL, 0);
- return;
+ mobj->momx = mobj->momy = 0;
+ P_SetMobjState(mobj, S_ROSY_IDLE1);
}
}
- else if (mobj->flags & MF_BOSS)
+ else
{
-#ifdef HAVE_BLUA
- if (LUAh_BossThinker(mobj))
+ boolean dojump = false, targonground, love, makeheart = false;
+ if (mobj->target != player->mo)
+ P_SetTarget(&mobj->target, player->mo);
+ // Tatsuru: Don't try to hug them if they're above or below you!
+ targonground = (P_IsObjectOnGround(mobj->target) && (player->panim == PA_IDLE || player->panim == PA_WALK || player->panim == PA_RUN) && player->mo->z == mobj->z);
+ love = (player->skin == 0 || player->skin == 5);
+
+ switch (stat)
{
- if (P_MobjWasRemoved(mobj))
- return;
- }
- else if (P_MobjWasRemoved(mobj))
- return;
- else
-#endif
- switch (mobj->type)
+ 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:
{
- case MT_EGGMOBILE:
- if (mobj->health < mobj->info->damage+1 && leveltime & 2)
- {
- fixed_t rad = mobj->radius>>FRACBITS;
- fixed_t hei = mobj->height>>FRACBITS;
- mobj_t *particle = P_SpawnMobjFromMobj(mobj,
- P_RandomRange(rad, -rad)<<FRACBITS,
- P_RandomRange(rad, -rad)<<FRACBITS,
- P_RandomRange(hei/2, hei)<<FRACBITS,
- MT_SMOKE);
- P_SetObjectMomZ(particle, 2<<FRACBITS, false);
- particle->momz += mobj->momz;
- }
- if (mobj->flags2 & MF2_SKULLFLY)
-#if 1
- P_SpawnGhostMobj(mobj);
-#else // all the way back from final demo... MT_THOK isn't even the same size anymore!
- {
- mobj_t *spawnmobj;
- spawnmobj = P_SpawnMobj(mobj->x, mobj->y, mobj->z, mobj->info->painchance);
- P_SetTarget(&spawnmobj->target, mobj);
- spawnmobj->color = SKINCOLOR_GREY;
- }
-#endif
- P_Boss1Thinker(mobj);
- break;
- case MT_EGGMOBILE2:
- if (mobj->health < mobj->info->damage+1 && leveltime & 2)
- {
- fixed_t rad = mobj->radius>>FRACBITS;
- fixed_t hei = mobj->height>>FRACBITS;
- mobj_t *particle = P_SpawnMobjFromMobj(mobj,
- P_RandomRange(rad, -rad)<<FRACBITS,
- P_RandomRange(rad, -rad)<<FRACBITS,
- P_RandomRange(hei/2, hei)<<FRACBITS,
- MT_SMOKE);
- P_SetObjectMomZ(particle, 2<<FRACBITS, false);
- particle->momz += mobj->momz;
- }
- P_Boss2Thinker(mobj);
- break;
- case MT_EGGMOBILE3:
- if (mobj->health < mobj->info->damage+1 && leveltime & 2)
+ 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)
{
- fixed_t rad = mobj->radius>>FRACBITS;
- fixed_t hei = mobj->height>>FRACBITS;
- mobj_t *particle = P_SpawnMobjFromMobj(mobj,
- P_RandomRange(rad, -rad)<<FRACBITS,
- P_RandomRange(rad, -rad)<<FRACBITS,
- P_RandomRange(hei/2, hei)<<FRACBITS,
- MT_SMOKE);
- P_SetObjectMomZ(particle, 2<<FRACBITS, false);
- particle->momz += mobj->momz;
+ 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;
}
- P_Boss3Thinker(mobj);
- break;
- case MT_EGGMOBILE4:
- if (mobj->health < mobj->info->damage+1 && leveltime & 2)
+ if (max < (mobj->radius + mobj->target->radius))
{
- fixed_t rad = mobj->radius>>FRACBITS;
- fixed_t hei = mobj->height>>FRACBITS;
- mobj_t *particle = P_SpawnMobjFromMobj(mobj,
- P_RandomRange(rad, -rad)<<FRACBITS,
- P_RandomRange(rad, -rad)<<FRACBITS,
- P_RandomRange(hei/2, hei)<<FRACBITS,
- MT_SMOKE);
- P_SetObjectMomZ(particle, 2<<FRACBITS, false);
- particle->momz += mobj->momz;
+ 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;
+ }
}
- P_Boss4Thinker(mobj);
- break;
- case MT_FANG:
- P_Boss5Thinker(mobj);
- break;
- case MT_BLACKEGGMAN:
- P_Boss7Thinker(mobj);
- break;
- case MT_METALSONIC_BATTLE:
- P_Boss9Thinker(mobj);
- break;
- default: // Generic SOC-made boss
- if (mobj->flags2 & MF2_SKULLFLY)
- P_SpawnGhostMobj(mobj);
- P_GenericBossThinker(mobj);
- break;
- }
- if (mobj->flags2 & MF2_BOSSFLEE)
- {
- if (mobj->extravalue1)
- {
- if (!(--mobj->extravalue1))
+ else
{
- if (mobj->target)
+ max /= 3;
+ if (max > 30*mobj->scale)
+ max = 30*mobj->scale;
+ if (mom > max && max > mobj->scale)
{
- mobj->momz = FixedMul(FixedDiv(mobj->target->z - mobj->z, P_AproxDistance(mobj->x-mobj->target->x,mobj->y-mobj->target->y)), mobj->scale<<1);
- mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
+ max = FixedDiv(max, mom);
+ mobj->momx = FixedMul(mobj->momx, max);
+ mobj->momy = FixedMul(mobj->momy, max);
}
- else
- mobj->momz = 8*mobj->scale;
+ if (abs(mobj->momx) > mobj->scale || abs(mobj->momy) > mobj->scale)
+ mobj->angle = R_PointToAngle2(0, 0, mobj->momx, mobj->momy);
}
- else
- mobj->angle += mobj->movedir;
- }
- else if (mobj->target)
- P_InstaThrust(mobj, mobj->angle, FixedMul(12*FRACUNIT, mobj->scale));
- }
- if (mobj->type == MT_CYBRAKDEMON && !mobj->health)
- {
- if (!(mobj->tics & 1))
- {
- var1 = 2;
- var2 = 0;
- A_BossScream(mobj);
- }
- if (P_CheckDeathPitCollide(mobj))
- {
- P_RemoveMobj(mobj);
- return;
- }
- if (mobj->momz && mobj->z+mobj->momz <= mobj->floorz)
- {
- S_StartSound(mobj, sfx_befall);
- if (mobj->state != states+S_CYBRAKDEMON_DIE8)
- P_SetMobjState(mobj, S_CYBRAKDEMON_DIE8);
}
+ else
+ dojump = true;
}
- }
- else if (mobj->health <= 0) // Dead things think differently than the living.
- switch (mobj->type)
- {
- case MT_BLUESPHERE:
- if ((mobj->tics>>2)+1 > 0 && (mobj->tics>>2)+1 <= tr_trans60) // tr_trans50 through tr_trans90, shifting once every second frame
- mobj->frame = (NUMTRANSMAPS-((mobj->tics>>2)+1))<<FF_TRANSSHIFT;
- else // tr_trans60 otherwise
- mobj->frame = tr_trans60<<FF_TRANSSHIFT;
- break;
- case MT_EGGCAPSULE:
- if (mobj->z <= mobj->floorz)
+ break;
+ case S_ROSY_HUG:
+ if (targonground)
{
- P_RemoveMobj(mobj);
- return;
+ player->pflags |= PF_STASIS;
+ if (mobj->cvmem < 5*TICRATE)
+ mobj->cvmem++;
+ if (love && !(leveltime & 7))
+ makeheart = true;
}
- break;
- case MT_FAKEMOBILE:
- if (mobj->scale == mobj->destscale)
+ else
{
- if (!mobj->fuse)
+ if (mobj->cvmem < (love ? 5*TICRATE : 0))
{
- S_StartSound(mobj, sfx_s3k77);
- mobj->flags2 |= MF2_DONTDRAW;
- mobj->fuse = TICRATE;
+ P_SetMobjState(mobj, (stat = S_ROSY_PAIN));
+ S_StartSound(mobj, sfx_cdpcm7);
}
- return;
- }
- if (!mobj->reactiontime)
- {
- if (P_RandomChance(FRACUNIT/2))
- mobj->movefactor = FRACUNIT;
- else
- mobj->movefactor = -FRACUNIT;
- if (P_RandomChance(FRACUNIT/2))
- mobj->movedir = ANG20;
else
- mobj->movedir = -ANG20;
- mobj->reactiontime = 5;
- }
- mobj->momz += mobj->movefactor;
- mobj->angle += mobj->movedir;
- P_InstaThrust(mobj, mobj->angle, -mobj->info->speed);
- mobj->reactiontime--;
- break;
- case MT_EGGSHIELD:
- mobj->flags2 ^= MF2_DONTDRAW;
- break;
- case MT_EGGTRAP: // Egg Capsule animal release
- if (mobj->fuse > 0)// && mobj->fuse < TICRATE-(TICRATE/7))
- {
- INT32 i;
- fixed_t x,y,z;
- fixed_t ns;
- mobj_t *mo2;
- mobj_t *flicky;
-
- z = mobj->subsector->sector->floorheight + FRACUNIT + (P_RandomKey(64)<<FRACBITS);
- for (i = 0; i < 3; i++)
- {
- const angle_t fa = P_RandomKey(FINEANGLES) & FINEMASK;
- ns = 64 * FRACUNIT;
- x = mobj->x + FixedMul(FINESINE(fa),ns);
- y = mobj->y + FixedMul(FINECOSINE(fa),ns);
-
- mo2 = P_SpawnMobj(x, y, z, MT_EXPLODE);
- P_SetMobjStateNF(mo2, S_XPLD_EGGTRAP); // so the flickies don't lose their target if they spawn
- ns = 4 * FRACUNIT;
- mo2->momx = FixedMul(FINESINE(fa),ns);
- mo2->momy = FixedMul(FINECOSINE(fa),ns);
- mo2->angle = fa << ANGLETOFINESHIFT;
-
- if (!i && !(mobj->fuse & 2))
- S_StartSound(mo2, mobj->info->deathsound);
-
- flicky = P_InternalFlickySpawn(mo2, 0, 8*FRACUNIT, false, -1);
- if (!flicky)
- break;
-
- P_SetTarget(&flicky->target, mo2);
- flicky->momx = mo2->momx;
- flicky->momy = mo2->momy;
- }
-
- mobj->fuse--;
+ P_SetMobjState(mobj, (stat = S_ROSY_JUMP));
+ var1 = var2 = 0;
+ A_DoNPCPain(mobj);
+ mobj->cvmem -= TICRATE;
}
break;
- case MT_PLAYER:
- /// \todo Have the player's dead body completely finish its animation even if they've already respawned.
- if (!mobj->fuse)
- { // Go away.
- /// \todo Actually go ahead and remove mobj completely, and fix any bugs and crashes doing this creates. Chasecam should stop moving, and F12 should never return to it.
- mobj->momz = 0;
- if (mobj->player)
- mobj->flags2 |= MF2_DONTDRAW;
- else // safe to remove, nobody's going to complain!
- {
- P_RemoveMobj(mobj);
- return;
- }
- }
- else // Apply gravity to fall downwards.
+ 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 (mobj->player && !(mobj->fuse % 8) && (mobj->player->charflags & SF_MACHINE))
+ if (love && !(leveltime & 15))
+ makeheart = true;
+ if (player->exiting || --mobj->cvmem < TICRATE)
{
- 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_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;
}
- if (mobj->movedir == DMG_DROWNED)
- P_SetObjectMomZ(mobj, -FRACUNIT / 2, true); // slower fall from drowning
- else
- 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);
- }
+ case S_ROSY_UNHAPPY:
default:
break;
}
- else
- {
- if ((mobj->flags & MF_ENEMY) && (mobj->state->nextstate == mobj->info->spawnstate && mobj->tics == 1))
- mobj->flags2 &= ~MF2_FRET;
- // Angle-to-tracer to trigger a linedef exec
- // See Linedef Exec 457 (Track mobj angle to point)
- if ((mobj->eflags & MFE_TRACERANGLE) && mobj->tracer && mobj->extravalue2)
+ if (stat == S_ROSY_HUG)
{
- // mobj->lastlook - Don't disable behavior after first failure
- // mobj->extravalue1 - Angle tolerance
- // mobj->extravalue2 - Exec tag upon failure
- // mobj->cvval - Allowable failure delay
- // mobj->cvmem - Failure timer
-
- angle_t ang = mobj->angle - R_PointToAngle2(mobj->x, mobj->y, mobj->tracer->x, mobj->tracer->y);
-
- // \todo account for distance between mobj and tracer
- // Because closer mobjs can be facing beyond the angle tolerance
- // yet tracer is still in the camera view
-
- // failure state: mobj is not facing tracer
- // Reasaonable defaults: ANGLE_67h, ANGLE_292h
- if (ang >= (angle_t)mobj->extravalue1 && ang <= ANGLE_MAX - (angle_t)mobj->extravalue1)
- {
- if (mobj->cvmem)
- mobj->cvmem--;
- else
- {
- INT32 exectag = mobj->extravalue2; // remember this before we erase the values
-
- if (mobj->lastlook)
- mobj->cvmem = mobj->cusval; // reset timer for next failure
- else
- {
- // disable after first failure
- mobj->eflags &= ~MFE_TRACERANGLE;
- mobj->lastlook = mobj->extravalue1 = mobj->extravalue2 = mobj->cvmem = mobj->cusval = 0;
- }
+ if (player->panim != PA_IDLE)
+ P_SetPlayerMobjState(mobj->target, S_PLAY_STND);
+ player->pflags |= PF_STASIS;
+ }
- P_LinedefExecute(exectag, mobj, NULL);
- }
- }
- else
- mobj->cvmem = mobj->cusval; // reset failure timer
+ 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);
}
- switch (mobj->type)
+ if (makeheart)
{
- case MT_WALLSPIKEBASE:
- if (!mobj->target) {
- P_RemoveMobj(mobj);
- return;
- }
- mobj->frame = (mobj->frame & ~FF_FRAMEMASK)|(mobj->target->frame & FF_FRAMEMASK);
-#if 0
- if (mobj->angle != mobj->target->angle + ANGLE_90) // reposition if not the correct angle
- {
- mobj_t *target = mobj->target; // shortcut
- const fixed_t baseradius = target->radius - (target->scale/2); //FixedMul(FRACUNIT/2, target->scale);
- P_UnsetThingPosition(mobj);
- mobj->x = target->x - P_ReturnThrustX(target, target->angle, baseradius);
- mobj->y = target->y - P_ReturnThrustY(target, target->angle, baseradius);
- P_SetThingPosition(mobj);
- mobj->angle = target->angle + ANGLE_90;
- }
+ 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;
+ }
+ }
+}
+
+static void P_MobjSceneryThink(mobj_t *mobj)
+{
+#ifdef HAVE_BLUA
+ if (LUAh_MobjThinker(mobj))
+ return;
+ if (P_MobjWasRemoved(mobj))
+ return;
+#endif
+
+ if ((mobj->flags2 & MF2_SHIELD) && !P_AddShield(mobj))
+ return;
+
+ switch (mobj->type)
+ {
+ case MT_BOSSJUNK:
+ mobj->flags2 ^= MF2_DONTDRAW;
+ break;
+ case MT_MACEPOINT:
+ case MT_CHAINMACEPOINT:
+ case MT_SPRINGBALLPOINT:
+ case MT_CHAINPOINT:
+ case MT_FIREBARPOINT:
+ case MT_CUSTOMMACEPOINT:
+ case MT_HIDDEN_SLING:
+ P_MaceSceneryThink(mobj);
+ break;
+ case MT_HOOP:
+ if (mobj->fuse > 1)
+ P_MoveHoop(mobj);
+ else if (mobj->fuse == 1)
+ mobj->movecount = 1;
+
+ if (mobj->movecount)
+ {
+ mobj->fuse++;
+
+ if (mobj->fuse > 32)
+ {
+ // Don't kill the hoop center. For the sake of respawning.
+ //if (mobj->target)
+ // P_RemoveMobj(mobj->target);
+
+ P_RemoveMobj(mobj);
+ }
+ }
+ else
+ mobj->fuse--;
+ return;
+ case MT_NIGHTSPARKLE:
+ if (mobj->tics != -1)
+ {
+ mobj->tics--;
+
+ // you can cycle through multiple states in a tic
+ if (!mobj->tics)
+ if (!P_SetMobjState(mobj, mobj->state->nextstate))
+ return; // freed itself
+ }
+
+ P_UnsetThingPosition(mobj);
+ mobj->x += mobj->momx;
+ mobj->y += mobj->momy;
+ mobj->z += mobj->momz;
+ P_SetThingPosition(mobj);
+ return;
+ case MT_NIGHTSLOOPHELPER:
+ if (--mobj->tics <= 0)
+ P_RemoveMobj(mobj);
+
+ // Don't touch my fuse!
+ return;
+ case MT_OVERLAY:
+ if (!mobj->target)
+ {
+ P_RemoveMobj(mobj);
+ return;
+ }
+ else
+ P_AddOverlay(mobj);
+ break;
+ case MT_PITY_ORB:
+ case MT_WHIRLWIND_ORB:
+ case MT_ARMAGEDDON_ORB:
+ if (!(mobj->flags2 & MF2_SHIELD))
+ return;
+ break;
+ case MT_ATTRACT_ORB:
+ if (!(mobj->flags2 & MF2_SHIELD))
+ return;
+ if (/*(mobj->target) -- the following is implicit by P_AddShield
+ && (mobj->target->player)
+ && */ (mobj->target->player->homing) && (mobj->target->player->pflags & PF_SHIELDABILITY))
+ {
+ P_SetMobjState(mobj, mobj->info->painstate);
+ mobj->tics++;
+ }
+ break;
+ case MT_ELEMENTAL_ORB:
+ if (!(mobj->flags2 & MF2_SHIELD))
+ return;
+ if (mobj->tracer
+ /* && mobj->target -- the following is implicit by P_AddShield
+ && mobj->target->player
+ && (mobj->target->player->powers[pw_shield] & SH_NOSTACK) == SH_ELEMENTAL */
+ && mobj->target->player->pflags & PF_SHIELDABILITY
+ && ((statenum_t)(mobj->tracer->state - states) < mobj->info->raisestate
+ || (mobj->tracer->state->nextstate < mobj->info->raisestate && mobj->tracer->tics == 1)))
+ {
+ P_SetMobjState(mobj, mobj->info->painstate);
+ mobj->tics++;
+ P_SetMobjState(mobj->tracer, mobj->info->raisestate);
+ mobj->tracer->tics++;
+ }
+ break;
+ case MT_FORCE_ORB:
+ if (!(mobj->flags2 & MF2_SHIELD))
+ return;
+ if (/*
+ && mobj->target -- the following is implicit by P_AddShield
+ && mobj->target->player
+ && (mobj->target->player->powers[pw_shield] & SH_FORCE)
+ && */ (mobj->target->player->pflags & PF_SHIELDABILITY))
+ {
+ mobj_t *whoosh = P_SpawnMobjFromMobj(mobj, 0, 0, 0, MT_GHOST); // done here so the offset is correct
+ P_SetMobjState(whoosh, mobj->info->raisestate);
+ whoosh->destscale = whoosh->scale << 1;
+ whoosh->scalespeed = FixedMul(whoosh->scalespeed, whoosh->scale);
+ whoosh->height = 38*whoosh->scale;
+ whoosh->fuse = 10;
+ whoosh->flags |= MF_NOCLIPHEIGHT;
+ whoosh->momz = mobj->target->momz; // Stay reasonably centered for a few frames
+ mobj->target->player->pflags &= ~PF_SHIELDABILITY; // prevent eternal whoosh
+ }
+ /* FALLTHRU */
+ case MT_FLAMEAURA_ORB:
+ if (!(mobj->flags2 & MF2_SHIELD))
+ return;
+ if ((statenum_t)(mobj->state - states) < mobj->info->painstate)
+ mobj->angle = mobj->target->angle; // implicitly okay because of P_AddShield
+ if (mobj->tracer
+ /* && mobj->target -- the following is implicit by P_AddShield
+ && mobj->target->player
+ && (mobj->target->player->powers[pw_shield] & SH_NOSTACK) == SH_FLAMEAURA */
+ && mobj->target->player->pflags & PF_SHIELDABILITY
+ && ((statenum_t)(mobj->tracer->state - states) < mobj->info->raisestate
+ || (mobj->tracer->state->nextstate < mobj->info->raisestate && mobj->tracer->tics == 1)))
+ {
+ P_SetMobjState(mobj, mobj->info->painstate);
+ mobj->tics++;
+ P_SetMobjState(mobj->tracer, mobj->info->raisestate);
+ mobj->tracer->tics++;
+ }
+ break;
+ case MT_BUBBLEWRAP_ORB:
+ if (!(mobj->flags2 & MF2_SHIELD))
+ return;
+ if (mobj->tracer
+ /* && mobj->target -- the following is implicit by P_AddShield
+ && mobj->target->player
+ && (mobj->target->player->powers[pw_shield] & SH_NOSTACK) == SH_BUBBLEWRAP */
+ )
+ {
+ if (mobj->target->player->pflags & PF_SHIELDABILITY
+ && ((statenum_t)(mobj->state - states) < mobj->info->painstate
+ || (mobj->state->nextstate < mobj->info->painstate && mobj->tics == 1)))
+ {
+ P_SetMobjState(mobj, mobj->info->painstate);
+ mobj->tics++;
+ P_SetMobjState(mobj->tracer, mobj->info->raisestate);
+ mobj->tracer->tics++;
+ }
+ else if (mobj->target->eflags & MFE_JUSTHITFLOOR
+ && (statenum_t)(mobj->state - states) == mobj->info->painstate)
+ {
+ P_SetMobjState(mobj, mobj->info->painstate + 1);
+ mobj->tics++;
+ P_SetMobjState(mobj->tracer, mobj->info->raisestate + 1);
+ mobj->tracer->tics++;
+ }
+ }
+ break;
+ case MT_THUNDERCOIN_ORB:
+ if (!(mobj->flags2 & MF2_SHIELD))
+ return;
+ if (mobj->tracer
+ /* && mobj->target -- the following is implicit by P_AddShield
+ && mobj->target->player
+ && (mobj->target->player->powers[pw_shield] & SH_NOSTACK) == SH_THUNDERCOIN */
+ && (mobj->target->player->pflags & PF_SHIELDABILITY))
+ {
+ P_SetMobjState(mobj, mobj->info->painstate);
+ mobj->tics++;
+ P_SetMobjState(mobj->tracer, mobj->info->raisestate);
+ mobj->tracer->tics++;
+ mobj->target->player->pflags &= ~PF_SHIELDABILITY; // prevent eternal spark
+ }
+ break;
+ case MT_WATERDROP:
+ P_SceneryCheckWater(mobj);
+ if ((mobj->z <= mobj->floorz || mobj->z <= mobj->watertop)
+ && mobj->health > 0)
+ {
+ mobj->health = 0;
+ P_SetMobjState(mobj, mobj->info->deathstate);
+ S_StartSound(mobj, mobj->info->deathsound + P_RandomKey(mobj->info->mass));
+ return;
+ }
+ break;
+ case MT_BUBBLES:
+ P_SceneryCheckWater(mobj);
+ break;
+ case MT_SMALLBUBBLE:
+ case MT_MEDIUMBUBBLE:
+ case MT_EXTRALARGEBUBBLE: // start bubble dissipate
+ P_SceneryCheckWater(mobj);
+ if (P_MobjWasRemoved(mobj)) // bubble was removed by not being in water
+ return;
+ if (!(mobj->eflags & MFE_UNDERWATER)
+ || (!(mobj->eflags & MFE_VERTICALFLIP) && mobj->z + mobj->height >= mobj->ceilingz)
+ || (mobj->eflags & MFE_VERTICALFLIP && mobj->z <= mobj->floorz)
+ || (P_CheckDeathPitCollide(mobj))
+ || --mobj->fuse <= 0) // Bubbles eventually dissipate if they can't reach the surface.
+ {
+ // no playing sound: no point; the object is being removed
+ P_RemoveMobj(mobj);
+ return;
+ }
+ break;
+ case MT_LOCKON:
+ if (!mobj->target)
+ {
+ P_RemoveMobj(mobj);
+ return;
+ }
+
+ mobj->flags2 &= ~MF2_DONTDRAW;
+
+ mobj->x = mobj->target->x;
+ mobj->y = mobj->target->y;
+
+ mobj->eflags |= (mobj->target->eflags & MFE_VERTICALFLIP);
+
+ mobj->destscale = mobj->target->destscale;
+ P_SetScale(mobj, mobj->target->scale);
+
+ if (!(mobj->eflags & MFE_VERTICALFLIP))
+ mobj->z = mobj->target->z + mobj->target->height + FixedMul((16 + abs((signed)(leveltime % TICRATE) - TICRATE/2))*FRACUNIT, mobj->target->scale);
+ else
+ mobj->z = mobj->target->z - FixedMul((16 + abs((signed)(leveltime % TICRATE) - TICRATE/2))*FRACUNIT, mobj->target->scale) - mobj->height;
+ break;
+ case MT_LOCKONINF:
+ if (!(mobj->flags2 & MF2_STRONGBOX))
+ {
+ mobj->threshold = mobj->z;
+ mobj->flags2 |= MF2_STRONGBOX;
+ }
+ if (!(mobj->eflags & MFE_VERTICALFLIP))
+ mobj->z = mobj->threshold + FixedMul((16 + abs((signed)(leveltime % TICRATE) - TICRATE/2))*FRACUNIT, mobj->scale);
+ else
+ mobj->z = mobj->threshold - FixedMul((16 + abs((signed)(leveltime % TICRATE) - TICRATE/2))*FRACUNIT, mobj->scale);
+ break;
+ case MT_DROWNNUMBERS:
+ if (!P_DrownNumbersSceneryThink(mobj))
+ return;
+ break;
+ case MT_FLAMEJET:
+ P_FlameJetSceneryThink(mobj);
+ break;
+ case MT_VERTICALFLAMEJET:
+ P_VerticalFlameJetSceneryThink(mobj);
+ break;
+ case MT_FLICKY_01_CENTER:
+ case MT_FLICKY_02_CENTER:
+ case MT_FLICKY_03_CENTER:
+ case MT_FLICKY_04_CENTER:
+ case MT_FLICKY_05_CENTER:
+ case MT_FLICKY_06_CENTER:
+ case MT_FLICKY_07_CENTER:
+ case MT_FLICKY_08_CENTER:
+ case MT_FLICKY_09_CENTER:
+ case MT_FLICKY_10_CENTER:
+ case MT_FLICKY_11_CENTER:
+ case MT_FLICKY_12_CENTER:
+ case MT_FLICKY_13_CENTER:
+ case MT_FLICKY_14_CENTER:
+ case MT_FLICKY_15_CENTER:
+ case MT_FLICKY_16_CENTER:
+ case MT_SECRETFLICKY_01_CENTER:
+ case MT_SECRETFLICKY_02_CENTER:
+ if (mobj->tracer && (mobj->flags & MF_NOCLIPTHING)
+ && (mobj->flags & MF_GRENADEBOUNCE))
+ // for now: only do this bounce routine if flicky is in-place. \todo allow in all movements
+ {
+ if (!(mobj->tracer->flags2 & MF2_OBJECTFLIP) && mobj->tracer->z <= mobj->tracer->floorz)
+ mobj->tracer->momz = 7*FRACUNIT;
+ else if ((mobj->tracer->flags2 & MF2_OBJECTFLIP) && mobj->tracer->z >= mobj->tracer->ceilingz - mobj->tracer->height)
+ mobj->tracer->momz = -7*FRACUNIT;
+ }
+ break;
+ case MT_SEED:
+ if (P_MobjFlip(mobj)*mobj->momz < mobj->info->speed)
+ mobj->momz = P_MobjFlip(mobj)*mobj->info->speed;
+ break;
+ case MT_ROCKCRUMBLE1:
+ case MT_ROCKCRUMBLE2:
+ case MT_ROCKCRUMBLE3:
+ case MT_ROCKCRUMBLE4:
+ case MT_ROCKCRUMBLE5:
+ case MT_ROCKCRUMBLE6:
+ case MT_ROCKCRUMBLE7:
+ case MT_ROCKCRUMBLE8:
+ case MT_ROCKCRUMBLE9:
+ case MT_ROCKCRUMBLE10:
+ case MT_ROCKCRUMBLE11:
+ case MT_ROCKCRUMBLE12:
+ case MT_ROCKCRUMBLE13:
+ case MT_ROCKCRUMBLE14:
+ case MT_ROCKCRUMBLE15:
+ 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])
+ {
+ P_SetMobjState(mobj, mobj->info->deathstate);
+ return;
+ }
+ break;
+ case MT_PARTICLEGEN:
+ if (!P_ParticleGenSceneryThink(mobj))
+ return;
+ break;
+ case MT_FSGNA:
+ if (mobj->movedir)
+ mobj->angle += mobj->movedir;
+ break;
+ case MT_ROSY:
+ P_RosySceneryThink(mobj);
+ 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, (INT32)mobj->movedir)*3;
+ if (strength < 10)
+ mobj->frame |= ((10 - strength) << (FF_TRANSSHIFT));
+ }
+ /* FALLTHRU */
+ default:
+ if (mobj->fuse)
+ { // Scenery object fuse! Very basic!
+ mobj->fuse--;
+ if (!mobj->fuse)
+ {
+#ifdef HAVE_BLUA
+ if (!LUAh_MobjFuse(mobj))
#endif
- break;
- case MT_FALLINGROCK:
- // Despawn rocks here in case zmovement code can't do so (blame slopes)
- if (!mobj->momx && !mobj->momy && !mobj->momz
- && ((mobj->eflags & MFE_VERTICALFLIP) ?
- mobj->z + mobj->height >= mobj->ceilingz
- : mobj->z <= mobj->floorz))
- {
P_RemoveMobj(mobj);
- return;
- }
- P_MobjCheckWater(mobj);
- break;
- case MT_ARROW:
- if (mobj->flags & MF_MISSILE)
- {
- // Calculate the angle of movement.
- /*
- momz
- / |
- / |
- / |
- 0------dist(momx,momy)
- */
-
- fixed_t dist = P_AproxDistance(mobj->momx, mobj->momy);
- angle_t angle = R_PointToAngle2(0, 0, dist, mobj->momz);
-
- if (angle > ANG20 && angle <= ANGLE_180)
- mobj->frame = 2;
- else if (angle < ANG340 && angle > ANGLE_180)
- mobj->frame = 0;
- else
- mobj->frame = 1;
+ return;
+ }
+ }
+ break;
+ }
- if (!(mobj->extravalue1) && (mobj->momz < 0))
- {
- mobj->extravalue1 = 1;
- S_StartSound(mobj, mobj->info->activesound);
- }
- if (leveltime & 1)
- {
- mobj_t *dust = P_SpawnMobjFromMobj(mobj, 0, 0, 0, MT_PARTICLE);
- dust->tics = 18;
- dust->scalespeed = 4096;
- dust->destscale = FRACUNIT/32;
- }
+ P_SceneryThinker(mobj);
+}
+
+static boolean P_MobjPushableThink(mobj_t *mobj)
+{
+ P_MobjCheckWater(mobj);
+ P_PushableThinker(mobj);
+
+ // Extinguish fire objects in water. (Yes, it's extraordinarily rare to have a pushable flame object, but Brak uses such a case.)
+ if (mobj->flags & MF_FIRE && mobj->type != MT_PUMA && mobj->type != MT_FIREBALL
+ && (mobj->eflags & (MFE_UNDERWATER | MFE_TOUCHWATER)))
+ {
+ P_KillMobj(mobj, NULL, NULL, 0);
+ return false;
+ }
+
+ return true;
+}
+
+static boolean P_MobjBossThink(mobj_t *mobj)
+{
+#ifdef HAVE_BLUA
+ if (LUAh_BossThinker(mobj))
+ {
+ if (P_MobjWasRemoved(mobj))
+ return false;
+ }
+ else if (P_MobjWasRemoved(mobj))
+ return false;
+ else
+#endif
+ switch (mobj->type)
+ {
+ case MT_EGGMOBILE:
+ if (mobj->health < mobj->info->damage + 1 && leveltime & 2)
+ {
+ fixed_t rad = mobj->radius >> FRACBITS;
+ fixed_t hei = mobj->height >> FRACBITS;
+ mobj_t *particle = P_SpawnMobjFromMobj(mobj,
+ P_RandomRange(rad, -rad) << FRACBITS,
+ P_RandomRange(rad, -rad) << FRACBITS,
+ P_RandomRange(hei / 2, hei) << FRACBITS,
+ MT_SMOKE);
+ P_SetObjectMomZ(particle, 2 << FRACBITS, false);
+ particle->momz += mobj->momz;
+ }
+ if (mobj->flags2 & MF2_SKULLFLY)
+#if 1
+ P_SpawnGhostMobj(mobj);
+#else // all the way back from final demo... MT_THOK isn't even the same size anymore!
+ {
+ mobj_t *spawnmobj;
+ spawnmobj = P_SpawnMobj(mobj->x, mobj->y, mobj->z, mobj->info->painchance);
+ P_SetTarget(&spawnmobj->target, mobj);
+ spawnmobj->color = SKINCOLOR_GREY;
+ }
+#endif
+ P_Boss1Thinker(mobj);
+ break;
+ case MT_EGGMOBILE2:
+ if (mobj->health < mobj->info->damage + 1 && leveltime & 2)
+ {
+ fixed_t rad = mobj->radius >> FRACBITS;
+ fixed_t hei = mobj->height >> FRACBITS;
+ mobj_t *particle = P_SpawnMobjFromMobj(mobj,
+ P_RandomRange(rad, -rad) << FRACBITS,
+ P_RandomRange(rad, -rad) << FRACBITS,
+ P_RandomRange(hei/2, hei) << FRACBITS,
+ MT_SMOKE);
+ P_SetObjectMomZ(particle, 2 << FRACBITS, false);
+ particle->momz += mobj->momz;
+ }
+ P_Boss2Thinker(mobj);
+ break;
+ case MT_EGGMOBILE3:
+ if (mobj->health < mobj->info->damage + 1 && leveltime & 2)
+ {
+ fixed_t rad = mobj->radius >> FRACBITS;
+ fixed_t hei = mobj->height >> FRACBITS;
+ mobj_t *particle = P_SpawnMobjFromMobj(mobj,
+ P_RandomRange(rad, -rad) << FRACBITS,
+ P_RandomRange(rad, -rad) << FRACBITS,
+ P_RandomRange(hei/2, hei) << FRACBITS,
+ MT_SMOKE);
+ P_SetObjectMomZ(particle, 2 << FRACBITS, false);
+ particle->momz += mobj->momz;
+ }
+ P_Boss3Thinker(mobj);
+ break;
+ case MT_EGGMOBILE4:
+ if (mobj->health < mobj->info->damage + 1 && leveltime & 2)
+ {
+ fixed_t rad = mobj->radius >> FRACBITS;
+ fixed_t hei = mobj->height >> FRACBITS;
+ mobj_t* particle = P_SpawnMobjFromMobj(mobj,
+ P_RandomRange(rad, -rad) << FRACBITS,
+ P_RandomRange(rad, -rad) << FRACBITS,
+ P_RandomRange(hei/2, hei) << FRACBITS,
+ MT_SMOKE);
+ P_SetObjectMomZ(particle, 2 << FRACBITS, false);
+ particle->momz += mobj->momz;
+ }
+ P_Boss4Thinker(mobj);
+ break;
+ case MT_FANG:
+ P_Boss5Thinker(mobj);
+ break;
+ case MT_BLACKEGGMAN:
+ P_Boss7Thinker(mobj);
+ break;
+ case MT_METALSONIC_BATTLE:
+ P_Boss9Thinker(mobj);
+ break;
+ default: // Generic SOC-made boss
+ if (mobj->flags2 & MF2_SKULLFLY)
+ P_SpawnGhostMobj(mobj);
+ P_GenericBossThinker(mobj);
+ break;
+ }
+ if (mobj->flags2 & MF2_BOSSFLEE)
+ {
+ if (mobj->extravalue1)
+ {
+ if (!(--mobj->extravalue1))
+ {
+ if (mobj->target)
+ {
+ mobj->momz = FixedMul(FixedDiv(mobj->target->z - mobj->z, P_AproxDistance(mobj->x - mobj->target->x, mobj->y - mobj->target->y)), mobj->scale << 1);
+ mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
}
else
- mobj->flags2 ^= MF2_DONTDRAW;
- break;
- case MT_EMERALDSPAWN:
- if (mobj->threshold)
- {
- mobj->threshold--;
+ mobj->momz = 8*mobj->scale;
+ }
+ else
+ mobj->angle += mobj->movedir;
+ }
+ else if (mobj->target)
+ P_InstaThrust(mobj, mobj->angle, FixedMul(12*FRACUNIT, mobj->scale));
+ }
+ if (mobj->type == MT_CYBRAKDEMON && !mobj->health)
+ {
+ if (!(mobj->tics & 1))
+ {
+ var1 = 2;
+ var2 = 0;
+ A_BossScream(mobj);
+ }
+ if (P_CheckDeathPitCollide(mobj))
+ {
+ P_RemoveMobj(mobj);
+ return false;
+ }
+ if (mobj->momz && mobj->z + mobj->momz <= mobj->floorz)
+ {
+ S_StartSound(mobj, sfx_befall);
+ if (mobj->state != states + S_CYBRAKDEMON_DIE8)
+ P_SetMobjState(mobj, S_CYBRAKDEMON_DIE8);
+ }
+ }
+ return true;
+}
- if (!mobj->threshold && !mobj->target && mobj->reactiontime)
- {
- mobj_t *emerald = P_SpawnMobj(mobj->x, mobj->y, mobj->z, mobj->reactiontime);
- emerald->threshold = 42;
- P_SetTarget(&mobj->target, emerald);
- P_SetTarget(&emerald->target, mobj);
- }
- }
- break;
- 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
- && P_AproxDistance(P_AproxDistance(mobj->tracer->x - mobj->x, mobj->tracer->y - mobj->y), mobj->tracer->z - mobj->z) <= mobj->radius * 16)
- {
- // Home in on the target.
- P_HomingAttack(mobj, mobj->tracer);
+static boolean P_MobjDeadThink(mobj_t *mobj)
+{
+ switch (mobj->type)
+ {
+ case MT_BLUESPHERE:
+ if ((mobj->tics >> 2) + 1 > 0 && (mobj->tics >> 2) + 1 <= tr_trans60) // tr_trans50 through tr_trans90, shifting once every second frame
+ mobj->frame = (NUMTRANSMAPS - ((mobj->tics >> 2) + 1)) << FF_TRANSSHIFT;
+ else // tr_trans60 otherwise
+ mobj->frame = tr_trans60 << FF_TRANSSHIFT;
+ break;
+ case MT_EGGCAPSULE:
+ if (mobj->z <= mobj->floorz)
+ {
+ P_RemoveMobj(mobj);
+ return false;
+ }
+ break;
+ case MT_FAKEMOBILE:
+ if (mobj->scale == mobj->destscale)
+ {
+ if (!mobj->fuse)
+ {
+ S_StartSound(mobj, sfx_s3k77);
+ mobj->flags2 |= MF2_DONTDRAW;
+ mobj->fuse = TICRATE;
+ }
+ return false;
+ }
+ if (!mobj->reactiontime)
+ {
+ if (P_RandomChance(FRACUNIT/2))
+ mobj->movefactor = FRACUNIT;
+ else
+ mobj->movefactor = -FRACUNIT;
+ if (P_RandomChance(FRACUNIT/2))
+ mobj->movedir = ANG20;
+ else
+ mobj->movedir = -ANG20;
+ mobj->reactiontime = 5;
+ }
+ mobj->momz += mobj->movefactor;
+ mobj->angle += mobj->movedir;
+ P_InstaThrust(mobj, mobj->angle, -mobj->info->speed);
+ mobj->reactiontime--;
+ break;
+ case MT_EGGSHIELD:
+ mobj->flags2 ^= MF2_DONTDRAW;
+ break;
+ case MT_EGGTRAP: // Egg Capsule animal release
+ if (mobj->fuse > 0)// && mobj->fuse < TICRATE-(TICRATE/7))
+ {
+ INT32 i;
+ fixed_t x, y, z;
+ fixed_t ns;
+ mobj_t* mo2;
+ mobj_t* flicky;
- if (mobj->z < mobj->floorz)
- mobj->z = mobj->floorz;
+ z = mobj->subsector->sector->floorheight + FRACUNIT + (P_RandomKey(64) << FRACBITS);
+ for (i = 0; i < 3; i++)
+ {
+ const angle_t fa = P_RandomKey(FINEANGLES) & FINEMASK;
+ ns = 64*FRACUNIT;
+ x = mobj->x + FixedMul(FINESINE(fa), ns);
+ y = mobj->y + FixedMul(FINECOSINE(fa), ns);
- if (leveltime % mobj->info->painchance == 0)
- S_StartSound(mobj, mobj->info->activesound);
+ mo2 = P_SpawnMobj(x, y, z, MT_EXPLODE);
+ P_SetMobjStateNF(mo2, S_XPLD_EGGTRAP); // so the flickies don't lose their target if they spawn
+ ns = 4*FRACUNIT;
+ mo2->momx = FixedMul(FINESINE(fa), ns);
+ mo2->momy = FixedMul(FINECOSINE(fa), ns);
+ mo2->angle = fa << ANGLETOFINESHIFT;
- if ((statenum_t)(mobj->state-states) != mobj->info->seestate)
- P_SetMobjState(mobj, mobj->info->seestate);
- }
- else
- {
- // Try to find a player
- P_LookForPlayers(mobj, true, true, mobj->radius * 16);
- mobj->momx >>= 1;
- mobj->momy >>= 1;
- mobj->momz >>= 1;
- if ((statenum_t)(mobj->state-states) != mobj->info->spawnstate)
- P_SetMobjState(mobj, mobj->info->spawnstate);
- }
+ if (!i && !(mobj->fuse & 2))
+ S_StartSound(mo2, mobj->info->deathsound);
+
+ flicky = P_InternalFlickySpawn(mo2, 0, 8*FRACUNIT, false, -1);
+ if (!flicky)
+ break;
+
+ P_SetTarget(&flicky->target, mo2);
+ flicky->momx = mo2->momx;
+ flicky->momy = mo2->momy;
+ }
+
+ mobj->fuse--;
+ }
+ break;
+ case MT_PLAYER:
+ /// \todo Have the player's dead body completely finish its animation even if they've already respawned.
+ if (!mobj->fuse)
+ { // Go away.
+ /// \todo Actually go ahead and remove mobj completely, and fix any bugs and crashes doing this creates. Chasecam should stop moving, and F12 should never return to it.
+ mobj->momz = 0;
+ if (mobj->player)
+ mobj->flags2 |= MF2_DONTDRAW;
+ else // safe to remove, nobody's going to complain!
+ {
+ P_RemoveMobj(mobj);
+ return false;
+ }
+ }
+ else // Apply gravity to fall downwards.
+ {
+ if (mobj->player && !(mobj->fuse % 8) && (mobj->player->charflags & SF_MACHINE))
+ {
+ 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);
+ }
+ if (mobj->movedir == DMG_DROWNED)
+ P_SetObjectMomZ(mobj, -FRACUNIT/2, true); // slower fall from drowning
+ else
+ 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);
+ }
+ break;
+ default:
+ break;
+ }
+ return true;
+}
+
+// Angle-to-tracer to trigger a linedef exec
+// See Linedef Exec 457 (Track mobj angle to point)
+static void P_TracerAngleThink(mobj_t *mobj)
+{
+ angle_t ang;
+
+ if (!mobj->tracer)
+ return;
+
+ if (!mobj->extravalue2)
+ return;
+
+ // mobj->lastlook - Don't disable behavior after first failure
+ // mobj->extravalue1 - Angle tolerance
+ // mobj->extravalue2 - Exec tag upon failure
+ // mobj->cvval - Allowable failure delay
+ // mobj->cvmem - Failure timer
+
+ ang = mobj->angle - R_PointToAngle2(mobj->x, mobj->y, mobj->tracer->x, mobj->tracer->y);
+
+ // \todo account for distance between mobj and tracer
+ // Because closer mobjs can be facing beyond the angle tolerance
+ // yet tracer is still in the camera view
+
+ // failure state: mobj is not facing tracer
+ // Reasaonable defaults: ANGLE_67h, ANGLE_292h
+ if (ang >= (angle_t)mobj->extravalue1 && ang <= ANGLE_MAX - (angle_t)mobj->extravalue1)
+ {
+ if (mobj->cvmem)
+ mobj->cvmem--;
+ else
+ {
+ INT32 exectag = mobj->extravalue2; // remember this before we erase the values
+
+ if (mobj->lastlook)
+ mobj->cvmem = mobj->cusval; // reset timer for next failure
+ else
+ {
+ // disable after first failure
+ mobj->eflags &= ~MFE_TRACERANGLE;
+ mobj->lastlook = mobj->extravalue1 = mobj->extravalue2 = mobj->cvmem = mobj->cusval = 0;
+ }
+
+ P_LinedefExecute(exectag, mobj, NULL);
+ }
+ }
+ else
+ mobj->cvmem = mobj->cusval; // reset failure timer
+}
+
+static void P_ArrowThink(mobj_t *mobj)
+{
+ if (mobj->flags & MF_MISSILE)
+ {
+ // Calculate the angle of movement.
+ /*
+ momz
+ / |
+ / |
+ / |
+ 0------dist(momx,momy)
+ */
+
+ fixed_t dist = P_AproxDistance(mobj->momx, mobj->momy);
+ angle_t angle = R_PointToAngle2(0, 0, dist, mobj->momz);
+
+ if (angle > ANG20 && angle <= ANGLE_180)
+ mobj->frame = 2;
+ else if (angle < ANG340 && angle > ANGLE_180)
+ mobj->frame = 0;
+ else
+ mobj->frame = 1;
+
+ if (!(mobj->extravalue1) && (mobj->momz < 0))
+ {
+ mobj->extravalue1 = 1;
+ S_StartSound(mobj, mobj->info->activesound);
+ }
+ if (leveltime & 1)
+ {
+ mobj_t *dust = P_SpawnMobjFromMobj(mobj, 0, 0, 0, MT_PARTICLE);
+ dust->tics = 18;
+ dust->scalespeed = 4096;
+ dust->destscale = FRACUNIT/32;
+ }
+ }
+ else
+ mobj->flags2 ^= MF2_DONTDRAW;
+}
+
+static void P_BumbleboreThink(mobj_t *mobj)
+{
+ statenum_t st = mobj->state - states;
+ if (st == S_BUMBLEBORE_FLY1 || st == S_BUMBLEBORE_FLY2)
+ {
+ if (!mobj->target)
+ P_SetMobjState(mobj, mobj->info->spawnstate);
+ else if (P_MobjFlip(mobj)*((mobj->z + (mobj->height >> 1)) - (mobj->target->z + (mobj->target->height >> 1))) > 0
+ && R_PointToDist2(mobj->x, mobj->y, mobj->target->x, mobj->target->y) <= 32*FRACUNIT)
+ {
+ mobj->momx >>= 1;
+ mobj->momy >>= 1;
+ if (++mobj->movefactor == 4)
+ {
+ S_StartSound(mobj, mobj->info->seesound);
+ mobj->momx = mobj->momy = mobj->momz = 0;
+ mobj->flags = (mobj->flags|MF_PAIN) & ~MF_NOGRAVITY;
+ P_SetMobjState(mobj, mobj->info->meleestate);
+ }
+ }
+ else
+ mobj->movefactor = 0;
+ }
+ else if (st == S_BUMBLEBORE_RAISE || st == S_BUMBLEBORE_FALL2) // no _FALL1 because it's an 0-tic
+ {
+ if (P_IsObjectOnGround(mobj))
+ {
+ S_StopSound(mobj);
+ S_StartSound(mobj, mobj->info->attacksound);
+ mobj->flags = (mobj->flags | MF_NOGRAVITY) & ~MF_PAIN;
+ mobj->momx = mobj->momy = mobj->momz = 0;
+ P_SetMobjState(mobj, mobj->info->painstate);
+ }
+ else
+ {
+ mobj->angle += ANGLE_22h;
+ mobj->frame = mobj->state->frame + ((mobj->tics & 2) >> 1);
+ }
+ }
+ else if (st == S_BUMBLEBORE_STUCK2 && mobj->tics < TICRATE)
+ mobj->frame = mobj->state->frame + ((mobj->tics & 2) >> 1);
+}
+
+static boolean P_HangsterThink(mobj_t *mobj)
+{
+ statenum_t st = mobj->state - states;
+ //ghost image trail when flying down
+ if (st == S_HANGSTER_SWOOP1 || st == S_HANGSTER_SWOOP2)
+ {
+ P_SpawnGhostMobj(mobj);
+ //curve when in line with target, otherwise curve to avoid crashing into floor
+ if ((mobj->z - mobj->floorz <= 80*FRACUNIT) || (mobj->target && (mobj->z - mobj->target->z <= 80*FRACUNIT)))
+ P_SetMobjState(mobj, (st = S_HANGSTER_ARC1));
+ }
+
+ //swoop arc movement stuff
+ if (st == S_HANGSTER_ARC1)
+ {
+ A_FaceTarget(mobj);
+ P_Thrust(mobj, mobj->angle, 1*FRACUNIT);
+ }
+ else if (st == S_HANGSTER_ARC2)
+ P_Thrust(mobj, mobj->angle, 2*FRACUNIT);
+ else if (st == S_HANGSTER_ARC3)
+ P_Thrust(mobj, mobj->angle, 4*FRACUNIT);
+ //if movement has stopped while flying (like hitting a wall), fly up immediately
+ else if (st == S_HANGSTER_FLY1 && !mobj->momx && !mobj->momy)
+ {
+ mobj->extravalue1 = 0;
+ P_SetMobjState(mobj, S_HANGSTER_ARCUP1);
+ }
+ //after swooping back up, check for ceiling
+ else if ((st == S_HANGSTER_RETURN1 || st == S_HANGSTER_RETURN2) && mobj->momz == 0 && mobj->ceilingz == (mobj->z + mobj->height))
+ P_SetMobjState(mobj, (st = S_HANGSTER_RETURN3));
+
+ //should you roost on a ceiling with F_SKY1 as its flat, disappear forever
+ if (st == S_HANGSTER_RETURN3 && mobj->momz == 0 && mobj->ceilingz == (mobj->z + mobj->height)
+ && mobj->subsector->sector->ceilingpic == skyflatnum
+ && mobj->subsector->sector->ceilingheight == mobj->ceilingz)
+ {
+ P_RemoveMobj(mobj);
+ return false;
+ }
+
+ return true;
+}
+
+static boolean P_JetFume1Think(mobj_t *mobj)
+{
+ fixed_t jetx, jety;
+
+ if (!mobj->target // if you have no target
+ || (!(mobj->target->flags & MF_BOSS) && mobj->target->health <= 0)) // or your target isn't a boss and it's popped now
+ { // then remove yourself as well!
+ P_RemoveMobj(mobj);
+ return false;
+ }
+
+ jetx = mobj->target->x + P_ReturnThrustX(mobj->target, mobj->target->angle, FixedMul(-64*FRACUNIT, mobj->target->scale));
+ jety = mobj->target->y + P_ReturnThrustY(mobj->target, mobj->target->angle, FixedMul(-64*FRACUNIT, mobj->target->scale));
+
+ if (mobj->fuse == 56) // First one
+ {
+ P_UnsetThingPosition(mobj);
+ mobj->x = jetx;
+ mobj->y = jety;
+ if (mobj->target->eflags & MFE_VERTICALFLIP)
+ mobj->z = mobj->target->z + mobj->target->height - mobj->height - FixedMul(38*FRACUNIT, mobj->target->scale);
+ else
+ mobj->z = mobj->target->z + FixedMul(38*FRACUNIT, mobj->target->scale);
+ mobj->floorz = mobj->z;
+ mobj->ceilingz = mobj->z + mobj->height;
+ P_SetThingPosition(mobj);
+ }
+ else if (mobj->fuse == 57)
+ {
+ P_UnsetThingPosition(mobj);
+ mobj->x = jetx + P_ReturnThrustX(mobj->target, mobj->target->angle - ANGLE_90, FixedMul(24*FRACUNIT, mobj->target->scale));
+ mobj->y = jety + P_ReturnThrustY(mobj->target, mobj->target->angle - ANGLE_90, FixedMul(24*FRACUNIT, mobj->target->scale));
+ if (mobj->target->eflags & MFE_VERTICALFLIP)
+ mobj->z = mobj->target->z + mobj->target->height - mobj->height - FixedMul(12*FRACUNIT, mobj->target->scale);
+ else
+ mobj->z = mobj->target->z + FixedMul(12*FRACUNIT, mobj->target->scale);
+ mobj->floorz = mobj->z;
+ mobj->ceilingz = mobj->z + mobj->height;
+ P_SetThingPosition(mobj);
+ }
+ else if (mobj->fuse == 58)
+ {
+ P_UnsetThingPosition(mobj);
+ mobj->x = jetx + P_ReturnThrustX(mobj->target, mobj->target->angle + ANGLE_90, FixedMul(24*FRACUNIT, mobj->target->scale));
+ mobj->y = jety + P_ReturnThrustY(mobj->target, mobj->target->angle + ANGLE_90, FixedMul(24*FRACUNIT, mobj->target->scale));
+ if (mobj->target->eflags & MFE_VERTICALFLIP)
+ mobj->z = mobj->target->z + mobj->target->height - mobj->height - FixedMul(12*FRACUNIT, mobj->target->scale);
+ else
+ mobj->z = mobj->target->z + FixedMul(12*FRACUNIT, mobj->target->scale);
+ mobj->floorz = mobj->z;
+ mobj->ceilingz = mobj->z + mobj->height;
+ P_SetThingPosition(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
+ mobj->z = mobj->target->z + mobj->target->height/2 - mobj->height/2;
+ 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++;
+ return true;
+}
+
+static boolean P_EggRobo1Think(mobj_t *mobj)
+{
+#define SPECTATORRADIUS (96*mobj->scale)
+ if (!(mobj->flags2 & MF2_STRONGBOX))
+ {
+ mobj->cusval = mobj->x; // eat my SOCs, p_mobj.h warning, we have lua now
+ mobj->cvmem = mobj->y; // ditto
+ mobj->movedir = mobj->angle;
+ mobj->threshold = P_MobjFlip(mobj)*10*mobj->scale;
+ if (mobj->threshold < 0)
+ mobj->threshold += (mobj->ceilingz - mobj->height);
+ else
+ mobj->threshold += mobj->floorz;
+ var1 = 4;
+ A_BossJetFume(mobj);
+ mobj->flags2 |= MF2_STRONGBOX;
+ }
+
+ if (mobj->state == &states[mobj->info->deathstate]) // todo: make map actually set health to 0 for these
+ {
+ if (mobj->movecount)
+ {
+ if (!(--mobj->movecount))
+ S_StartSound(mobj, mobj->info->deathsound);
+ }
+ else
+ {
+ mobj->momz += P_MobjFlip(mobj)*mobj->scale;
+ if (mobj->momz > 0)
+ {
+ if (mobj->z + mobj->momz > mobj->ceilingz + (1000 << FRACBITS))
+ {
+ P_RemoveMobj(mobj);
+ return false;
}
- break;
- case MT_BUMBLEBORE:
+ }
+ else if (mobj->z + mobj->height + mobj->momz < mobj->floorz - (1000 << FRACBITS))
+ {
+ P_RemoveMobj(mobj);
+ return false;
+ }
+ }
+ }
+ else
+ {
+ fixed_t basex = mobj->cusval, basey = mobj->cvmem;
+
+ if (mobj->spawnpoint && mobj->spawnpoint->options & (MTF_AMBUSH|MTF_OBJECTSPECIAL))
+ {
+ angle_t sideang = mobj->movedir + ((mobj->spawnpoint->options & MTF_AMBUSH) ? ANGLE_90 : -ANGLE_90);
+ fixed_t oscillate = FixedMul(FINESINE(((leveltime * ANG1) >> (ANGLETOFINESHIFT + 2)) & FINEMASK), 250*mobj->scale);
+ basex += P_ReturnThrustX(mobj, sideang, oscillate);
+ basey += P_ReturnThrustY(mobj, sideang, oscillate);
+ }
+
+ mobj->z = mobj->threshold + FixedMul(FINESINE(((leveltime + mobj->movecount)*ANG2 >> (ANGLETOFINESHIFT - 2)) & FINEMASK), 8*mobj->scale);
+ if (mobj->state != &states[mobj->info->meleestate])
+ {
+ boolean didmove = false;
+
+ if (mobj->state == &states[mobj->info->spawnstate])
+ {
+ UINT8 i;
+ fixed_t dist = INT32_MAX;
+
+ for (i = 0; i < MAXPLAYERS; i++)
{
- statenum_t st = mobj->state-states;
- if (st == S_BUMBLEBORE_FLY1 || st == S_BUMBLEBORE_FLY2)
- {
- if (!mobj->target)
- P_SetMobjState(mobj, mobj->info->spawnstate);
- else if (P_MobjFlip(mobj)*((mobj->z + (mobj->height>>1)) - (mobj->target->z + (mobj->target->height>>1))) > 0
- && R_PointToDist2(mobj->x, mobj->y, mobj->target->x, mobj->target->y) <= 32*FRACUNIT)
- {
- mobj->momx >>= 1;
- mobj->momy >>= 1;
- if (++mobj->movefactor == 4)
- {
- S_StartSound(mobj, mobj->info->seesound);
- mobj->momx = mobj->momy = mobj->momz = 0;
- mobj->flags = (mobj->flags|MF_PAIN) & ~MF_NOGRAVITY;
- P_SetMobjState(mobj, mobj->info->meleestate);
- }
- }
- else
- mobj->movefactor = 0;
- }
- else if (st == S_BUMBLEBORE_RAISE || st == S_BUMBLEBORE_FALL2) // no _FALL1 because it's an 0-tic
- {
- if (P_IsObjectOnGround(mobj))
- {
- S_StopSound(mobj);
- S_StartSound(mobj, mobj->info->attacksound);
- mobj->flags = (mobj->flags|MF_NOGRAVITY) & ~MF_PAIN;
- mobj->momx = mobj->momy = mobj->momz = 0;
- P_SetMobjState(mobj, mobj->info->painstate);
- }
- else
- {
- mobj->angle += ANGLE_22h;
- mobj->frame = mobj->state->frame + ((mobj->tics & 2)>>1);
- }
- }
- else if (st == S_BUMBLEBORE_STUCK2 && mobj->tics < TICRATE)
- mobj->frame = mobj->state->frame + ((mobj->tics & 2)>>1);
+ fixed_t compdist;
+ if (!playeringame[i])
+ continue;
+ if (players[i].spectator)
+ continue;
+ if (!players[i].mo)
+ continue;
+ if (!players[i].mo->health)
+ continue;
+ if (P_PlayerInPain(&players[i]))
+ continue;
+ if (players[i].mo->z > mobj->z + mobj->height + 8*mobj->scale)
+ continue;
+ if (players[i].mo->z + players[i].mo->height < mobj->z - 8*mobj->scale)
+ continue;
+ compdist = P_AproxDistance(
+ players[i].mo->x + players[i].mo->momx - basex,
+ players[i].mo->y + players[i].mo->momy - basey);
+ if (compdist >= dist)
+ continue;
+ dist = compdist;
+ P_SetTarget(&mobj->target, players[i].mo);
}
- break;
- case MT_BIGMINE:
- mobj->extravalue1 += 3;
- mobj->extravalue1 %= 360;
- P_UnsetThingPosition(mobj);
- mobj->z += FINESINE(mobj->extravalue1*(FINEMASK+1)/360);
- P_SetThingPosition(mobj);
- break;
- case MT_FLAME:
- if (mobj->flags2 & MF2_BOSSNOTRAP)
+
+ if (dist < (SPECTATORRADIUS << 1))
{
- if (!mobj->target || P_MobjWasRemoved(mobj->target))
- {
- if (mobj->tracer && !P_MobjWasRemoved(mobj->tracer))
- P_RemoveMobj(mobj->tracer);
- P_RemoveMobj(mobj);
- return;
- }
- mobj->z = mobj->target->z + mobj->target->momz;
- if (!(mobj->eflags & MFE_VERTICALFLIP))
- mobj->z += mobj->target->height;
+ didmove = true;
+ mobj->frame = 3 + ((leveltime & 2) >> 1);
+ mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
+
+ if (P_AproxDistance(
+ mobj->x - basex,
+ mobj->y - basey)
+ < mobj->scale)
+ S_StartSound(mobj, mobj->info->seesound);
+
+ P_TeleportMove(mobj,
+ (15*(mobj->x >> 4)) + (basex >> 4) + P_ReturnThrustX(mobj, mobj->angle, SPECTATORRADIUS >> 4),
+ (15*(mobj->y >> 4)) + (basey >> 4) + P_ReturnThrustY(mobj, mobj->angle, SPECTATORRADIUS >> 4),
+ mobj->z);
}
- if (mobj->tracer && !P_MobjWasRemoved(mobj->tracer))
+ else
{
- mobj->tracer->z = mobj->z + P_MobjFlip(mobj)*20*mobj->scale;
- if (mobj->eflags & MFE_VERTICALFLIP)
- mobj->tracer->z += mobj->height;
+ angle_t diff = (mobj->movedir - mobj->angle);
+ if (diff > ANGLE_180)
+ diff = InvAngle(InvAngle(diff)/8);
+ else
+ diff /= 8;
+ mobj->angle += diff;
+
+ dist = FINECOSINE(((leveltime + mobj->movecount)*ANG2 >> (ANGLETOFINESHIFT - 2)) & FINEMASK);
+
+ if (abs(dist) < FRACUNIT/2)
+ mobj->frame = 0;
+ else
+ mobj->frame = (dist > 0) ? 1 : 2;
}
- break;
- case MT_WAVINGFLAG1:
- case MT_WAVINGFLAG2:
+ }
+
+ if (!didmove)
+ {
+ if (P_AproxDistance(mobj->x - basex, mobj->y - basey) < mobj->scale)
+ P_TeleportMove(mobj, basex, basey, mobj->z);
+ else
+ P_TeleportMove(mobj,
+ (15*(mobj->x >> 4)) + (basex >> 4),
+ (15*(mobj->y >> 4)) + (basey >> 4),
+ mobj->z);
+ }
+ }
+ }
+ return true;
+#undef SPECTATORRADIUS
+}
+
+static void P_NiGHTSDroneThink(mobj_t *mobj)
+{
+ {
+ // variable setup
+ mobj_t *goalpost = NULL;
+ mobj_t *sparkle = NULL;
+ mobj_t *droneman = NULL;
+
+ boolean flip = mobj->flags2 & MF2_OBJECTFLIP;
+ boolean topaligned = (mobj->flags & MF_SLIDEME) && !(mobj->flags & MF_GRENADEBOUNCE);
+ boolean middlealigned = (mobj->flags & MF_GRENADEBOUNCE) && !(mobj->flags & MF_SLIDEME);
+ boolean bottomoffsetted = !(mobj->flags & MF_SLIDEME) && !(mobj->flags & MF_GRENADEBOUNCE);
+ boolean flipchanged = false;
+
+ fixed_t dronemanoffset, goaloffset, sparkleoffset, droneboxmandiff, dronemangoaldiff;
+
+ if (mobj->target && mobj->target->type == MT_NIGHTSDRONE_GOAL)
+ {
+ goalpost = mobj->target;
+ if (goalpost->target && goalpost->target->type == MT_NIGHTSDRONE_SPARKLING)
+ sparkle = goalpost->target;
+ if (goalpost->tracer && goalpost->tracer->type == MT_NIGHTSDRONE_MAN)
+ droneman = goalpost->tracer;
+ }
+
+ if (!goalpost || !sparkle || !droneman)
+ return;
+
+ // did NIGHTSDRONE position, scale, flip, or flags change? all elements need to be synced
+ droneboxmandiff = max(mobj->height - droneman->height, 0);
+ dronemangoaldiff = max(droneman->height - goalpost->height, 0);
+
+ if (!(goalpost->flags2 & MF2_OBJECTFLIP) && (mobj->flags2 & MF2_OBJECTFLIP))
+ {
+ goalpost->eflags |= MFE_VERTICALFLIP;
+ goalpost->flags2 |= MF2_OBJECTFLIP;
+ sparkle->eflags |= MFE_VERTICALFLIP;
+ sparkle->flags2 |= MF2_OBJECTFLIP;
+ droneman->eflags |= MFE_VERTICALFLIP;
+ droneman->flags2 |= MF2_OBJECTFLIP;
+ flipchanged = true;
+ }
+ else if ((goalpost->flags2 & MF2_OBJECTFLIP) && !(mobj->flags2 & MF2_OBJECTFLIP))
+ {
+ goalpost->eflags &= ~MFE_VERTICALFLIP;
+ goalpost->flags2 &= ~MF2_OBJECTFLIP;
+ sparkle->eflags &= ~MFE_VERTICALFLIP;
+ sparkle->flags2 &= ~MF2_OBJECTFLIP;
+ droneman->eflags &= ~MFE_VERTICALFLIP;
+ droneman->flags2 &= ~MF2_OBJECTFLIP;
+ flipchanged = true;
+ }
+
+ if (goalpost->destscale != mobj->destscale
+ || goalpost->movefactor != mobj->z
+ || goalpost->friction != mobj->height
+ || flipchanged
+ || goalpost->threshold != (INT32)(mobj->flags & (MF_SLIDEME|MF_GRENADEBOUNCE)))
+ {
+ goalpost->destscale = sparkle->destscale = droneman->destscale = mobj->destscale;
+
+ // straight copy-pasta from P_SpawnMapThing, case MT_NIGHTSDRONE
+ if (!flip)
+ {
+ if (topaligned) // Align droneman to top of hitbox
{
- fixed_t base = (leveltime<<(FRACBITS+1));
- mobj_t *seg = mobj->tracer, *prev = mobj;
- mobj->movedir = mobj->angle
- + ((((FINESINE((FixedAngle(base<<1)>>ANGLETOFINESHIFT) & FINEMASK)
- + FINESINE((FixedAngle(base<<4)>>ANGLETOFINESHIFT) & FINEMASK))>>1)
- + FINESINE((FixedAngle(base*9)>>ANGLETOFINESHIFT) & FINEMASK)
- + FINECOSINE(((FixedAngle(base*9))>>ANGLETOFINESHIFT) & FINEMASK))<<12); //*2^12
- while (seg)
- {
- seg->movedir = seg->angle;
- seg->angle = prev->movedir;
- P_UnsetThingPosition(seg);
- seg->x = prev->x + P_ReturnThrustX(prev, prev->angle, prev->radius);
- seg->y = prev->y + P_ReturnThrustY(prev, prev->angle, prev->radius);
- seg->z = prev->z + prev->height - (seg->scale>>1);
- P_SetThingPosition(seg);
- prev = seg;
- seg = seg->tracer;
- }
+ dronemanoffset = droneboxmandiff;
+ goaloffset = dronemangoaldiff/2 + dronemanoffset;
}
- break;
- case MT_SPINCUSHION:
- if (mobj->target && mobj->state-states >= S_SPINCUSHION_AIM1 && mobj->state-states <= S_SPINCUSHION_AIM5)
- mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
- break;
- case MT_CRUSHCLAW:
- if (mobj->state-states == S_CRUSHCLAW_STAY && mobj->target)
+ else if (middlealigned) // Align droneman to center of hitbox
{
- mobj_t *chain = mobj->target->target;
- SINT8 sign = ((mobj->tics & 1) ? mobj->tics : -(SINT8)(mobj->tics));
- while (chain)
- {
- chain->z = chain->watertop + sign*mobj->scale;
- sign = -sign;
- chain = chain->target;
- }
+ dronemanoffset = droneboxmandiff/2;
+ goaloffset = dronemangoaldiff/2 + dronemanoffset;
}
- break;
- case MT_SMASHINGSPIKEBALL:
- mobj->momx = mobj->momy = 0;
- if (mobj->state-states == S_SMASHSPIKE_FALL && P_IsObjectOnGround(mobj))
+ else if (bottomoffsetted)
{
- P_SetMobjState(mobj, S_SMASHSPIKE_STOMP1);
- S_StartSound(mobj, sfx_spsmsh);
+ dronemanoffset = 24*FRACUNIT;
+ goaloffset = dronemangoaldiff + dronemanoffset;
}
- else if (mobj->state-states == S_SMASHSPIKE_RISE2 && P_MobjFlip(mobj)*(mobj->z - mobj->movecount) >= 0)
+ else
{
- mobj->momz = 0;
- P_SetMobjState(mobj, S_SMASHSPIKE_FLOAT);
+ dronemanoffset = 0;
+ goaloffset = dronemangoaldiff/2 + dronemanoffset;
}
- break;
- case MT_HANGSTER:
- {
- statenum_t st = mobj->state-states;
- //ghost image trail when flying down
- if (st == S_HANGSTER_SWOOP1 || st == S_HANGSTER_SWOOP2)
- {
- P_SpawnGhostMobj(mobj);
- //curve when in line with target, otherwise curve to avoid crashing into floor
- if ((mobj->z - mobj->floorz <= 80*FRACUNIT) || (mobj->target && (mobj->z - mobj->target->z <= 80*FRACUNIT)))
- P_SetMobjState(mobj, (st = S_HANGSTER_ARC1));
- }
- //swoop arc movement stuff
- if (st == S_HANGSTER_ARC1)
- {
- A_FaceTarget(mobj);
- P_Thrust(mobj, mobj->angle, 1*FRACUNIT);
- }
- else if (st == S_HANGSTER_ARC2)
- P_Thrust(mobj, mobj->angle, 2*FRACUNIT);
- else if (st == S_HANGSTER_ARC3)
- P_Thrust(mobj, mobj->angle, 4*FRACUNIT);
- //if movement has stopped while flying (like hitting a wall), fly up immediately
- else if (st == S_HANGSTER_FLY1 && !mobj->momx && !mobj->momy)
- {
- mobj->extravalue1 = 0;
- P_SetMobjState(mobj, S_HANGSTER_ARCUP1);
- }
- //after swooping back up, check for ceiling
- else if ((st == S_HANGSTER_RETURN1 || st == S_HANGSTER_RETURN2) && mobj->momz == 0 && mobj->ceilingz == (mobj->z + mobj->height))
- P_SetMobjState(mobj, (st = S_HANGSTER_RETURN3));
-
- //should you roost on a ceiling with F_SKY1 as its flat, disappear forever
- if (st == S_HANGSTER_RETURN3 && mobj->momz == 0 && mobj->ceilingz == (mobj->z + mobj->height)
- && mobj->subsector->sector->ceilingpic == skyflatnum
- && mobj->subsector->sector->ceilingheight == mobj->ceilingz)
- {
- P_RemoveMobj(mobj);
- return;
- }
- }
- break;
- case MT_LHRT:
- mobj->momx = FixedMul(mobj->momx, mobj->extravalue2);
- mobj->momy = FixedMul(mobj->momy, mobj->extravalue2);
- break;
- case MT_EGGCAPSULE:
- if (!mobj->reactiontime)
+ sparkleoffset = goaloffset - FixedMul(15*FRACUNIT, mobj->scale);
+ }
+ else
+ {
+ if (topaligned) // Align droneman to top of hitbox
{
- // Target nearest player on your mare.
- // (You can make it float up/down by adding MF_FLOAT,
- // but beware level design pitfalls.)
- fixed_t shortest = 1024*FRACUNIT;
- INT32 i;
- P_SetTarget(&mobj->target, NULL);
- for (i = 0; i < MAXPLAYERS; i++)
- if (playeringame[i] && players[i].mo
- && players[i].mare == mobj->threshold && players[i].spheres > 0)
- {
- fixed_t dist = P_AproxDistance(players[i].mo->x - mobj->x, players[i].mo->y - mobj->y);
- if (dist < shortest)
- {
- P_SetTarget(&mobj->target, players[i].mo);
- shortest = dist;
- }
- }
+ dronemanoffset = 0;
+ goaloffset = dronemangoaldiff/2 + dronemanoffset;
}
- break;
- case MT_EGGMOBILE2_POGO:
- if (!mobj->target
- || !mobj->target->health
- || mobj->target->state == &states[mobj->target->info->spawnstate]
- || mobj->target->state == &states[mobj->target->info->raisestate])
+ else if (middlealigned) // Align droneman to center of hitbox
{
- P_RemoveMobj(mobj);
- return;
+ dronemanoffset = droneboxmandiff/2;
+ goaloffset = dronemangoaldiff/2 + dronemanoffset;
}
- P_TeleportMove(mobj, mobj->target->x, mobj->target->y, mobj->target->z - mobj->height);
- break;
- case MT_HAMMER:
- if (mobj->z <= mobj->floorz)
+ else if (bottomoffsetted)
{
- P_RemoveMobj(mobj);
- return;
+ dronemanoffset = droneboxmandiff - FixedMul(24*FRACUNIT, mobj->scale);
+ goaloffset = dronemangoaldiff + dronemanoffset;
}
- break;
- case MT_KOOPA:
- P_KoopaThinker(mobj);
- break;
- case MT_FIREBALL:
- if (P_AproxDistance(mobj->momx, mobj->momy) <= 16*FRACUNIT) // Once fireballs lose enough speed, kill them
+ else
{
- P_KillMobj(mobj, NULL, NULL, 0);
- return;
+ dronemanoffset = droneboxmandiff;
+ goaloffset = dronemangoaldiff/2 + dronemanoffset;
}
- break;
- case MT_REDRING:
- if (((mobj->z < mobj->floorz) || (mobj->z + mobj->height > mobj->ceilingz))
- && mobj->flags & MF_MISSILE)
+
+ sparkleoffset = goaloffset + FixedMul(15*FRACUNIT, mobj->scale);
+ }
+
+ P_TeleportMove(goalpost, mobj->x, mobj->y, mobj->z + goaloffset);
+ P_TeleportMove(sparkle, mobj->x, mobj->y, mobj->z + sparkleoffset);
+ if (goalpost->movefactor != mobj->z || goalpost->friction != mobj->height)
+ {
+ P_TeleportMove(droneman, mobj->x, mobj->y, mobj->z + dronemanoffset);
+ goalpost->movefactor = mobj->z;
+ goalpost->friction = mobj->height;
+ }
+ goalpost->threshold = mobj->flags & (MF_SLIDEME|MF_GRENADEBOUNCE);
+ }
+ else
+ {
+ if (goalpost->x != mobj->x || goalpost->y != mobj->y)
+ {
+ P_TeleportMove(goalpost, mobj->x, mobj->y, goalpost->z);
+ P_TeleportMove(sparkle, mobj->x, mobj->y, sparkle->z);
+ }
+
+ if (droneman->x != mobj->x || droneman->y != mobj->y)
+ P_TeleportMove(droneman, mobj->x, mobj->y,
+ droneman->z >= mobj->floorz && droneman->z <= mobj->ceilingz ? droneman->z : mobj->z);
+ }
+
+ // now toggle states!
+ // GOAL mode?
+ if (sparkle->state >= &states[S_NIGHTSDRONE_SPARKLING1] && sparkle->state <= &states[S_NIGHTSDRONE_SPARKLING16])
+ {
+ INT32 i;
+ boolean bonustime = false;
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ if (playeringame[i] && players[i].bonustime && players[i].powers[pw_carry] == CR_NIGHTSMODE)
{
- P_ExplodeMissile(mobj);
- return;
+ bonustime = true;
+ break;
}
- break;
- case MT_BOSSFLYPOINT:
- return;
- case MT_NIGHTSCORE:
- mobj->color = (UINT8)(leveltime % SKINCOLOR_WHITE);
- break;
- case MT_JETFUME1:
- {
- fixed_t jetx, jety;
- if (!mobj->target // if you have no target
- || (!(mobj->target->flags & MF_BOSS) && mobj->target->health <= 0)) // or your target isn't a boss and it's popped now
- { // then remove yourself as well!
- P_RemoveMobj(mobj);
- return;
- }
+ if (!bonustime)
+ {
+ CONS_Debug(DBG_NIGHTSBASIC, "Removing goal post\n");
+ if (goalpost && goalpost->state != &states[S_INVISIBLE])
+ P_SetMobjState(goalpost, S_INVISIBLE);
+ if (sparkle && sparkle->state != &states[S_INVISIBLE])
+ P_SetMobjState(sparkle, S_INVISIBLE);
+ }
+ }
+ // Invisible/bouncing mode.
+ else
+ {
+ INT32 i;
+ boolean bonustime = false;
+ fixed_t zcomp;
- jetx = mobj->target->x + P_ReturnThrustX(mobj->target, mobj->target->angle, FixedMul(-64*FRACUNIT, mobj->target->scale));
- jety = mobj->target->y + P_ReturnThrustY(mobj->target, mobj->target->angle, FixedMul(-64*FRACUNIT, mobj->target->scale));
+ // Bouncy bouncy!
+ if (!flip)
+ {
+ if (topaligned)
+ zcomp = droneboxmandiff + mobj->z;
+ else if (middlealigned)
+ zcomp = (droneboxmandiff/2) + mobj->z;
+ else if (bottomoffsetted)
+ zcomp = mobj->z + FixedMul(24*FRACUNIT, mobj->scale);
+ else
+ zcomp = mobj->z;
+ }
+ else
+ {
+ if (topaligned)
+ zcomp = mobj->z;
+ else if (middlealigned)
+ zcomp = (droneboxmandiff/2) + mobj->z;
+ else if (bottomoffsetted)
+ zcomp = mobj->z + droneboxmandiff - FixedMul(24*FRACUNIT, mobj->scale);
+ else
+ zcomp = mobj->z + droneboxmandiff;
+ }
- if (mobj->fuse == 56) // First one
- {
- P_UnsetThingPosition(mobj);
- mobj->x = jetx;
- mobj->y = jety;
- if (mobj->target->eflags & MFE_VERTICALFLIP)
- mobj->z = mobj->target->z + mobj->target->height - mobj->height - FixedMul(38*FRACUNIT, mobj->target->scale);
- else
- mobj->z = mobj->target->z + FixedMul(38*FRACUNIT, mobj->target->scale);
- mobj->floorz = mobj->z;
- mobj->ceilingz = mobj->z+mobj->height;
- P_SetThingPosition(mobj);
- }
- else if (mobj->fuse == 57)
- {
- P_UnsetThingPosition(mobj);
- mobj->x = jetx + P_ReturnThrustX(mobj->target, mobj->target->angle-ANGLE_90, FixedMul(24*FRACUNIT, mobj->target->scale));
- mobj->y = jety + P_ReturnThrustY(mobj->target, mobj->target->angle-ANGLE_90, FixedMul(24*FRACUNIT, mobj->target->scale));
- if (mobj->target->eflags & MFE_VERTICALFLIP)
- mobj->z = mobj->target->z + mobj->target->height - mobj->height - FixedMul(12*FRACUNIT, mobj->target->scale);
- else
- mobj->z = mobj->target->z + FixedMul(12*FRACUNIT, mobj->target->scale);
- mobj->floorz = mobj->z;
- mobj->ceilingz = mobj->z+mobj->height;
- P_SetThingPosition(mobj);
- }
- else if (mobj->fuse == 58)
- {
- P_UnsetThingPosition(mobj);
- mobj->x = jetx + P_ReturnThrustX(mobj->target, mobj->target->angle+ANGLE_90, FixedMul(24*FRACUNIT, mobj->target->scale));
- mobj->y = jety + P_ReturnThrustY(mobj->target, mobj->target->angle+ANGLE_90, FixedMul(24*FRACUNIT, mobj->target->scale));
- if (mobj->target->eflags & MFE_VERTICALFLIP)
- mobj->z = mobj->target->z + mobj->target->height - mobj->height - FixedMul(12*FRACUNIT, mobj->target->scale);
- else
- mobj->z = mobj->target->z + FixedMul(12*FRACUNIT, mobj->target->scale);
- mobj->floorz = mobj->z;
- mobj->ceilingz = mobj->z+mobj->height;
- P_SetThingPosition(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
- mobj->z = mobj->target->z + mobj->target->height/2 - mobj->height/2;
- 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++;
- }
- break;
- case MT_JETFLAME:
- {
- if (!mobj->target // if you have no target
- || (!(mobj->target->flags & MF_BOSS) && mobj->target->health <= 0)) // or your target isn't a boss and it's popped now
- { // then remove yourself as well!
- P_RemoveMobj(mobj);
- return;
- }
+ droneman->angle += ANG10;
+ if (!flip && droneman->z <= zcomp)
+ droneman->momz = FixedMul(5*FRACUNIT, droneman->scale);
+ else if (flip && droneman->z >= zcomp)
+ droneman->momz = FixedMul(-5*FRACUNIT, droneman->scale);
- P_UnsetThingPosition(mobj);
- mobj->x = mobj->target->x;
- mobj->y = mobj->target->y;
- mobj->z = mobj->target->z - 50*mobj->target->scale;
- mobj->floorz = mobj->z;
- mobj->ceilingz = mobj->z+mobj->height;
- P_SetThingPosition(mobj);
- }
- break;
- case MT_EGGROBO1:
-#define SPECTATORRADIUS (96*mobj->scale)
+ // state switching logic
+ for (i = 0; i < MAXPLAYERS; i++)
+ if (playeringame[i] && players[i].bonustime && players[i].powers[pw_carry] == CR_NIGHTSMODE)
{
- if (!(mobj->flags2 & MF2_STRONGBOX))
- {
- mobj->cusval = mobj->x; // eat my SOCs, p_mobj.h warning, we have lua now
- mobj->cvmem = mobj->y; // ditto
- mobj->movedir = mobj->angle;
- mobj->threshold = P_MobjFlip(mobj)*10*mobj->scale;
- if (mobj->threshold < 0)
- mobj->threshold += (mobj->ceilingz - mobj->height);
- else
- mobj->threshold += mobj->floorz;
- var1 = 4;
- A_BossJetFume(mobj);
- mobj->flags2 |= MF2_STRONGBOX;
- }
+ bonustime = true;
+ break;
+ }
- if (mobj->state == &states[mobj->info->deathstate]) // todo: make map actually set health to 0 for these
+ if (bonustime)
+ {
+ CONS_Debug(DBG_NIGHTSBASIC, "Adding goal post\n");
+ if (!(droneman->flags2 & MF2_DONTDRAW))
+ droneman->flags2 |= MF2_DONTDRAW;
+ if (goalpost->state == &states[S_INVISIBLE])
+ P_SetMobjState(goalpost, mobjinfo[goalpost->type].meleestate);
+ if (sparkle->state == &states[S_INVISIBLE])
+ P_SetMobjState(sparkle, mobjinfo[sparkle->type].meleestate);
+ }
+ else if (!G_IsSpecialStage(gamemap))
+ {
+ for (i = 0; i < MAXPLAYERS; i++)
+ if (playeringame[i] && players[i].powers[pw_carry] != CR_NIGHTSMODE)
{
- if (mobj->movecount)
- {
- if (!(--mobj->movecount))
- S_StartSound(mobj, mobj->info->deathsound);
- }
- else
- {
- mobj->momz += P_MobjFlip(mobj)*mobj->scale;
- if (mobj->momz > 0)
- {
- if (mobj->z + mobj->momz > mobj->ceilingz + (1000<<FRACBITS))
- {
- P_RemoveMobj(mobj);
- return;
- }
- }
- else if (mobj->z + mobj->height + mobj->momz < mobj->floorz - (1000<<FRACBITS))
- {
- P_RemoveMobj(mobj);
- return;
- }
- }
+ bonustime = true; // variable reuse
+ break;
}
- else
- {
- fixed_t basex = mobj->cusval, basey = mobj->cvmem;
-
- if (mobj->spawnpoint && mobj->spawnpoint->options & (MTF_AMBUSH|MTF_OBJECTSPECIAL))
- {
- angle_t sideang = mobj->movedir + ((mobj->spawnpoint->options & MTF_AMBUSH) ? ANGLE_90 : -ANGLE_90);
- fixed_t oscillate = FixedMul(FINESINE(((leveltime*ANG1)>>(ANGLETOFINESHIFT+2)) & FINEMASK), 250*mobj->scale);
- basex += P_ReturnThrustX(mobj, sideang, oscillate);
- basey += P_ReturnThrustY(mobj, sideang, oscillate);
- }
+ if (bonustime)
+ {
+ // show droneman if at least one player is non-nights
+ if (goalpost->state != &states[S_INVISIBLE])
+ P_SetMobjState(goalpost, S_INVISIBLE);
+ if (sparkle->state != &states[S_INVISIBLE])
+ P_SetMobjState(sparkle, S_INVISIBLE);
+ if (droneman->state != &states[mobjinfo[droneman->type].meleestate])
+ P_SetMobjState(droneman, mobjinfo[droneman->type].meleestate);
+ if (droneman->flags2 & MF2_DONTDRAW)
+ droneman->flags2 &= ~MF2_DONTDRAW;
+ }
+ else
+ {
+ // else, hide it
+ if (!(droneman->flags2 & MF2_DONTDRAW))
+ droneman->flags2 |= MF2_DONTDRAW;
+ }
+ }
+ }
+ }
+}
- mobj->z = mobj->threshold + FixedMul(FINESINE(((leveltime + mobj->movecount)*ANG2>>(ANGLETOFINESHIFT-2)) & FINEMASK), 8*mobj->scale);
- if (mobj->state != &states[mobj->info->meleestate])
- {
- boolean didmove = false;
+static boolean P_TurretThink(mobj_t *mobj)
+{
+ P_MobjCheckWater(mobj);
+ P_CheckPosition(mobj, mobj->x, mobj->y);
+ if (P_MobjWasRemoved(mobj))
+ return false;
+ mobj->floorz = tmfloorz;
+ mobj->ceilingz = tmceilingz;
+ mobj->floorrover = tmfloorrover;
+ mobj->ceilingrover = tmceilingrover;
- if (mobj->state == &states[mobj->info->spawnstate])
- {
- UINT8 i;
- fixed_t dist = INT32_MAX;
+ if ((mobj->eflags & MFE_UNDERWATER) && mobj->health > 0)
+ {
+ P_SetMobjState(mobj, mobj->info->deathstate);
+ mobj->health = 0;
+ mobj->flags2 &= ~MF2_FIRING;
+ }
+ else if (mobj->health > 0 && mobj->z + mobj->height > mobj->ceilingz) // Crushed
+ {
+ INT32 i, j;
+ fixed_t ns;
+ fixed_t x, y, z;
+ mobj_t* mo2;
- for (i = 0; i < MAXPLAYERS; i++)
- {
- fixed_t compdist;
- if (!playeringame[i])
- continue;
- if (players[i].spectator)
- continue;
- if (!players[i].mo)
- continue;
- if (!players[i].mo->health)
- continue;
- if (P_PlayerInPain(&players[i]))
- continue;
- if (players[i].mo->z > mobj->z + mobj->height + 8*mobj->scale)
- continue;
- if (players[i].mo->z + players[i].mo->height < mobj->z - 8*mobj->scale)
- continue;
- compdist = P_AproxDistance(
- players[i].mo->x + players[i].mo->momx - basex,
- players[i].mo->y + players[i].mo->momy - basey);
- if (compdist >= dist)
- continue;
- dist = compdist;
- P_SetTarget(&mobj->target, players[i].mo);
- }
+ z = mobj->subsector->sector->floorheight + FixedMul(64*FRACUNIT, mobj->scale);
+ for (j = 0; j < 2; j++)
+ {
+ for (i = 0; i < 32; i++)
+ {
+ const angle_t fa = (i*FINEANGLES/16) & FINEMASK;
+ ns = FixedMul(64*FRACUNIT, mobj->scale);
+ x = mobj->x + FixedMul(FINESINE(fa), ns);
+ y = mobj->y + FixedMul(FINECOSINE(fa), ns);
- if (dist < (SPECTATORRADIUS<<1))
- {
- didmove = true;
- mobj->frame = 3 + ((leveltime & 2)>>1);
- mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
-
- if (P_AproxDistance(
- mobj->x - basex,
- mobj->y - basey)
- < mobj->scale)
- S_StartSound(mobj, mobj->info->seesound);
-
- P_TeleportMove(mobj,
- (15*(mobj->x>>4)) + (basex>>4) + P_ReturnThrustX(mobj, mobj->angle, SPECTATORRADIUS>>4),
- (15*(mobj->y>>4)) + (basey>>4) + P_ReturnThrustY(mobj, mobj->angle, SPECTATORRADIUS>>4),
- mobj->z);
- }
- else
- {
- angle_t diff = (mobj->movedir - mobj->angle);
- if (diff > ANGLE_180)
- diff = InvAngle(InvAngle(diff)/8);
- else
- diff /= 8;
- mobj->angle += diff;
-
- dist = FINECOSINE(((leveltime + mobj->movecount)*ANG2>>(ANGLETOFINESHIFT-2)) & FINEMASK);
-
- if (abs(dist) < FRACUNIT/2)
- mobj->frame = 0;
- else
- mobj->frame = (dist > 0) ? 1 : 2;
- }
- }
+ mo2 = P_SpawnMobj(x, y, z, MT_EXPLODE);
+ ns = FixedMul(16*FRACUNIT, mobj->scale);
+ mo2->momx = FixedMul(FINESINE(fa), ns);
+ mo2->momy = FixedMul(FINECOSINE(fa), ns);
+ }
+ z -= FixedMul(32*FRACUNIT, mobj->scale);
+ }
+ P_SetMobjState(mobj, mobj->info->deathstate);
+ mobj->health = 0;
+ mobj->flags2 &= ~MF2_FIRING;
+ }
+ return true;
+}
- if (!didmove)
- {
- if (P_AproxDistance(mobj->x - basex, mobj->y - basey) < mobj->scale)
- P_TeleportMove(mobj, basex, basey, mobj->z);
- else
- P_TeleportMove(mobj,
- (15*(mobj->x>>4)) + (basex>>4),
- (15*(mobj->y>>4)) + (basey>>4),
- mobj->z);
- }
- }
- }
- }
- break;
-#undef SPECTATORRADIUS
- case MT_EGGROBO1JET:
- {
- if (!mobj->target || P_MobjWasRemoved(mobj->target) // if you have no target
- || (mobj->target->health <= 0)) // or your target isn't a boss and it's popped now
- { // then remove yourself as well!
- P_RemoveMobj(mobj);
- return;
- }
+static void P_SaloonDoorThink(mobj_t *mobj)
+{
+ fixed_t x = mobj->tracer->x;
+ fixed_t y = mobj->tracer->y;
+ fixed_t z = mobj->tracer->z;
+ angle_t oang = FixedAngle(mobj->extravalue1);
+ angle_t fa = (oang >> ANGLETOFINESHIFT) & FINEMASK;
+ fixed_t c0 = -96*FINECOSINE(fa);
+ fixed_t s0 = -96*FINESINE(fa);
+ angle_t fma;
+ fixed_t c, s;
+ angle_t angdiff;
+
+ // Adjust angular speed
+ fixed_t da = AngleFixed(mobj->angle - oang);
+ if (da > 180*FRACUNIT)
+ da -= 360*FRACUNIT;
+ mobj->extravalue2 = 8*(mobj->extravalue2 - da/32)/9;
+
+ // Update angle
+ mobj->angle += FixedAngle(mobj->extravalue2);
+
+ angdiff = mobj->angle - FixedAngle(mobj->extravalue1);
+ if (angdiff > (ANGLE_90 - ANG2) && angdiff < ANGLE_180)
+ {
+ mobj->angle = FixedAngle(mobj->extravalue1) + (ANGLE_90 - ANG2);
+ mobj->extravalue2 /= 2;
+ }
+ else if (angdiff < (ANGLE_270 + ANG2) && angdiff >= ANGLE_180)
+ {
+ mobj->angle = FixedAngle(mobj->extravalue1) + (ANGLE_270 + ANG2);
+ mobj->extravalue2 /= 2;
+ }
+
+ // Update position
+ fma = (mobj->angle >> ANGLETOFINESHIFT) & FINEMASK;
+ c = 48*FINECOSINE(fma);
+ s = 48*FINESINE(fma);
+ P_TeleportMove(mobj, x + c0 + c, y + s0 + s, z);
+}
- mobj->flags2 ^= MF2_DONTDRAW;
-
- P_UnsetThingPosition(mobj);
- mobj->x = mobj->target->x + P_ReturnThrustX(mobj, mobj->target->angle+ANGLE_90, mobj->movefactor*mobj->target->scale) - P_ReturnThrustX(mobj, mobj->target->angle, 19*mobj->target->scale);
- mobj->y = mobj->target->y + P_ReturnThrustY(mobj, mobj->target->angle+ANGLE_90, mobj->movefactor*mobj->target->scale) - P_ReturnThrustY(mobj, mobj->target->angle, 19*mobj->target->scale);
- mobj->z = mobj->target->z;
- if (mobj->target->eflags & MFE_VERTICALFLIP)
- mobj->z += (mobj->target->height - mobj->height);
- mobj->floorz = mobj->z;
- mobj->ceilingz = mobj->z+mobj->height;
- P_SetThingPosition(mobj);
- }
- break;
- case MT_NIGHTSDRONE:
- {
- // variable setup
- mobj_t *goalpost = NULL;
- mobj_t *sparkle = NULL;
- mobj_t *droneman = NULL;
+static void P_PyreFlyThink(mobj_t *mobj)
+{
+ fixed_t hdist;
- boolean flip = mobj->flags2 & MF2_OBJECTFLIP;
- boolean topaligned = (mobj->flags & MF_SLIDEME) && !(mobj->flags & MF_GRENADEBOUNCE);
- boolean middlealigned = (mobj->flags & MF_GRENADEBOUNCE) && !(mobj->flags & MF_SLIDEME);
- boolean bottomoffsetted = !(mobj->flags & MF_SLIDEME) && !(mobj->flags & MF_GRENADEBOUNCE);
- boolean flipchanged = false;
+ mobj->extravalue1 = (mobj->extravalue1 + 3) % 360;
+ mobj->z += FINESINE(((mobj->extravalue1 * ANG1) >> ANGLETOFINESHIFT) & FINEMASK);
- fixed_t dronemanoffset, goaloffset, sparkleoffset, droneboxmandiff, dronemangoaldiff;
+ if (!(mobj->flags2 & MF2_BOSSNOTRAP))
+ P_LookForPlayers(mobj, true, false, 1500*FRACUNIT);
- if (mobj->target && mobj->target->type == MT_NIGHTSDRONE_GOAL)
- {
- goalpost = mobj->target;
- if (goalpost->target && goalpost->target->type == MT_NIGHTSDRONE_SPARKLING)
- sparkle = goalpost->target;
- if (goalpost->tracer && goalpost->tracer->type == MT_NIGHTSDRONE_MAN)
- droneman = goalpost->tracer;
- }
+ if (!mobj->target)
+ return;
- if (!goalpost || !sparkle || !droneman)
- 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) << FRACBITS, 20, MT_FLAMEPARTICLE, 4*FRACUNIT);
+ P_PyreFlyBurn(mobj, fireradius*FRACUNIT, 40, MT_PYREFLY_FIRE, 0);
+ }
- // did NIGHTSDRONE position, scale, flip, or flags change? all elements need to be synced
- droneboxmandiff = max(mobj->height - droneman->height, 0);
- dronemangoaldiff = max(droneman->height - goalpost->height, 0);
+ hdist = R_PointToDist2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
- if (!(goalpost->flags2 & MF2_OBJECTFLIP) && (mobj->flags2 & MF2_OBJECTFLIP))
- {
- goalpost->eflags |= MFE_VERTICALFLIP;
- goalpost->flags2 |= MF2_OBJECTFLIP;
- sparkle->eflags |= MFE_VERTICALFLIP;
- sparkle->flags2 |= MF2_OBJECTFLIP;
- droneman->eflags |= MFE_VERTICALFLIP;
- droneman->flags2 |= MF2_OBJECTFLIP;
- flipchanged = true;
- }
- else if ((goalpost->flags2 & MF2_OBJECTFLIP) && !(mobj->flags2 & MF2_OBJECTFLIP))
- {
- goalpost->eflags &= ~MFE_VERTICALFLIP;
- goalpost->flags2 &= ~MF2_OBJECTFLIP;
- sparkle->eflags &= ~MFE_VERTICALFLIP;
- sparkle->flags2 &= ~MF2_OBJECTFLIP;
- droneman->eflags &= ~MFE_VERTICALFLIP;
- droneman->flags2 &= ~MF2_OBJECTFLIP;
- flipchanged = true;
- }
+ if (hdist > 1500*FRACUNIT)
+ {
+ mobj->flags2 &= ~MF2_BOSSNOTRAP;
+ P_SetTarget(&mobj->target, NULL);
+ return;
+ }
- if (goalpost->destscale != mobj->destscale
- || goalpost->movefactor != mobj->z
- || goalpost->friction != mobj->height
- || flipchanged
- || goalpost->threshold != (INT32)(mobj->flags & (MF_SLIDEME | MF_GRENADEBOUNCE)))
- {
- goalpost->destscale = sparkle->destscale = droneman->destscale = mobj->destscale;
+ if (!(mobj->flags2 & MF2_BOSSNOTRAP) && hdist <= 450*FRACUNIT)
+ mobj->flags2 |= MF2_BOSSNOTRAP;
- // straight copy-pasta from P_SpawnMapThing, case MT_NIGHTSDRONE
- if (!flip)
- {
- if (topaligned) // Align droneman to top of hitbox
- {
- dronemanoffset = droneboxmandiff;
- goaloffset = dronemangoaldiff / 2 + dronemanoffset;
- }
- else if (middlealigned) // Align droneman to center of hitbox
- {
- dronemanoffset = droneboxmandiff / 2;
- goaloffset = dronemangoaldiff / 2 + dronemanoffset;
- }
- else if (bottomoffsetted)
- {
- dronemanoffset = 24*FRACUNIT;
- goaloffset = dronemangoaldiff + dronemanoffset;
- }
- else
- {
- dronemanoffset = 0;
- goaloffset = dronemangoaldiff / 2 + dronemanoffset;
- }
+ if (!(mobj->flags2 & MF2_BOSSNOTRAP))
+ return;
- sparkleoffset = goaloffset - FixedMul(15*FRACUNIT, mobj->scale);
- }
- else
- {
- if (topaligned) // Align droneman to top of hitbox
- {
- dronemanoffset = 0;
- goaloffset = dronemangoaldiff / 2 + dronemanoffset;
- }
- else if (middlealigned) // Align droneman to center of hitbox
- {
- dronemanoffset = droneboxmandiff / 2;
- goaloffset = dronemangoaldiff / 2 + dronemanoffset;
- }
- else if (bottomoffsetted)
- {
- dronemanoffset = droneboxmandiff - FixedMul(24*FRACUNIT, mobj->scale);
- goaloffset = dronemangoaldiff + dronemanoffset;
- }
- else
- {
- dronemanoffset = droneboxmandiff;
- goaloffset = dronemangoaldiff / 2 + dronemanoffset;
- }
+ 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;
+ }
+}
- sparkleoffset = goaloffset + FixedMul(15*FRACUNIT, mobj->scale);
- }
+static void P_PterabyteThink(mobj_t *mobj)
+{
+ if (mobj->extravalue1 & 4) // Cooldown after grabbing
+ {
+ if (mobj->movefactor)
+ mobj->movefactor--;
+ else
+ {
+ P_SetTarget(&mobj->target, NULL);
+ mobj->extravalue1 &= 3;
+ }
+ }
- P_TeleportMove(goalpost, mobj->x, mobj->y, mobj->z + goaloffset);
- P_TeleportMove(sparkle, mobj->x, mobj->y, mobj->z + sparkleoffset);
- if (goalpost->movefactor != mobj->z || goalpost->friction != mobj->height)
- {
- P_TeleportMove(droneman, mobj->x, mobj->y, mobj->z + dronemanoffset);
- goalpost->movefactor = mobj->z;
- goalpost->friction = mobj->height;
- }
- goalpost->threshold = mobj->flags & (MF_SLIDEME | MF_GRENADEBOUNCE);
- }
- else
- {
- if (goalpost->x != mobj->x || goalpost->y != mobj->y)
- {
- P_TeleportMove(goalpost, mobj->x, mobj->y, goalpost->z);
- P_TeleportMove(sparkle, mobj->x, mobj->y, sparkle->z);
- }
+ if ((mobj->extravalue1 & 3) == 0) // Hovering
+ {
+ fixed_t vdist, hdist, time;
+ fixed_t hspeed = 3*mobj->info->speed;
+ angle_t fa;
- if (droneman->x != mobj->x || droneman->y != mobj->y)
- P_TeleportMove(droneman, mobj->x, mobj->y,
- droneman->z >= mobj->floorz && droneman->z <= mobj->ceilingz ? droneman->z : mobj->z);
- }
+ var1 = 1;
+ var2 = 0;
+ A_CapeChase(mobj);
- // now toggle states!
- // GOAL mode?
- if (sparkle->state >= &states[S_NIGHTSDRONE_SPARKLING1] && sparkle->state <= &states[S_NIGHTSDRONE_SPARKLING16])
- {
- INT32 i;
- boolean bonustime = false;
+ if (mobj->target)
+ return; // Still carrying a player or in cooldown
- for (i = 0; i < MAXPLAYERS; i++)
- if (playeringame[i] && players[i].bonustime && players[i].powers[pw_carry] == CR_NIGHTSMODE)
- {
- bonustime = true;
- break;
- }
+ P_LookForPlayers(mobj, true, false, 256*FRACUNIT);
- if (!bonustime)
- {
- CONS_Debug(DBG_NIGHTSBASIC, "Removing goal post\n");
- if (goalpost && goalpost->state != &states[S_INVISIBLE])
- P_SetMobjState(goalpost, S_INVISIBLE);
- if (sparkle && sparkle->state != &states[S_INVISIBLE])
- P_SetMobjState(sparkle, S_INVISIBLE);
- }
- }
- // Invisible/bouncing mode.
- else
- {
- INT32 i;
- boolean bonustime = false;
- fixed_t zcomp;
+ if (!mobj->target)
+ return;
- // Bouncy bouncy!
- if (!flip)
- {
- if (topaligned)
- zcomp = droneboxmandiff + mobj->z;
- else if (middlealigned)
- zcomp = (droneboxmandiff / 2) + mobj->z;
- else if (bottomoffsetted)
- zcomp = mobj->z + FixedMul(24*FRACUNIT, mobj->scale);
- else
- zcomp = mobj->z;
- }
- else
- {
- if (topaligned)
- zcomp = mobj->z;
- else if (middlealigned)
- zcomp = (droneboxmandiff / 2) + mobj->z;
- else if (bottomoffsetted)
- zcomp = mobj->z + droneboxmandiff - FixedMul(24*FRACUNIT, mobj->scale);
- else
- zcomp = mobj->z + droneboxmandiff;
- }
+ if (mobj->target->player->powers[pw_flashing])
+ {
+ P_SetTarget(&mobj->target, NULL);
+ return;
+ }
- droneman->angle += ANG10;
- if (!flip && droneman->z <= zcomp)
- droneman->momz = FixedMul(5*FRACUNIT, droneman->scale);
- else if (flip && droneman->z >= zcomp)
- droneman->momz = FixedMul(-5*FRACUNIT, droneman->scale);
+ vdist = mobj->z - mobj->target->z - mobj->target->height;
+ if (P_MobjFlip(mobj)*vdist <= 0)
+ {
+ P_SetTarget(&mobj->target, NULL);
+ return;
+ }
- // state switching logic
- for (i = 0; i < MAXPLAYERS; i++)
- if (playeringame[i] && players[i].bonustime && players[i].powers[pw_carry] == CR_NIGHTSMODE)
- {
- bonustime = true;
- break;
- }
+ hdist = R_PointToDist2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
+ if (hdist > 450*FRACUNIT)
+ {
+ P_SetTarget(&mobj->target, NULL);
+ return;
+ }
- if (bonustime)
- {
- CONS_Debug(DBG_NIGHTSBASIC, "Adding goal post\n");
- if (!(droneman->flags2 & MF2_DONTDRAW))
- droneman->flags2 |= MF2_DONTDRAW;
- if (goalpost->state == &states[S_INVISIBLE])
- P_SetMobjState(goalpost, mobjinfo[goalpost->type].meleestate);
- if (sparkle->state == &states[S_INVISIBLE])
- P_SetMobjState(sparkle, mobjinfo[sparkle->type].meleestate);
- }
- else if (!G_IsSpecialStage(gamemap))
- {
- for (i = 0; i < MAXPLAYERS; i++)
- if (playeringame[i] && players[i].powers[pw_carry] != CR_NIGHTSMODE)
- {
- bonustime = true; // variable reuse
- 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)
+ return;
- if (bonustime)
- {
- // show droneman if at least one player is non-nights
- if (goalpost->state != &states[S_INVISIBLE])
- P_SetMobjState(goalpost, S_INVISIBLE);
- if (sparkle->state != &states[S_INVISIBLE])
- P_SetMobjState(sparkle, S_INVISIBLE);
- if (droneman->state != &states[mobjinfo[droneman->type].meleestate])
- P_SetMobjState(droneman, mobjinfo[droneman->type].meleestate);
- if (droneman->flags2 & MF2_DONTDRAW)
- droneman->flags2 &= ~MF2_DONTDRAW;
- }
- else
- {
- // else, hide it
- if (!(droneman->flags2 & MF2_DONTDRAW))
- droneman->flags2 |= MF2_DONTDRAW;
- }
- }
- }
- }
- break;
- case MT_PLAYER:
- if (mobj->player)
- P_PlayerMobjThinker(mobj);
- return;
- case MT_SKIM:
- // check mobj against possible water content, before movement code
- P_MobjCheckWater(mobj);
+ 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;
+ }
+ }
+}
- // Keep Skim at water surface
- if (mobj->z <= mobj->watertop)
- {
- mobj->flags |= MF_NOGRAVITY;
- if (mobj->z < mobj->watertop)
- {
- if (mobj->watertop - mobj->z <= FixedMul(mobj->info->speed*FRACUNIT, mobj->scale))
- mobj->z = mobj->watertop;
- else
- mobj->momz = FixedMul(mobj->info->speed*FRACUNIT, mobj->scale);
- }
- }
- else
- {
- mobj->flags &= ~MF_NOGRAVITY;
- if (mobj->z > mobj->watertop && mobj->z - mobj->watertop < FixedMul(MAXSTEPMOVE, mobj->scale))
- mobj->z = mobj->watertop;
- }
- 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:
- // No need to check water. Who cares?
- P_RingThinker(mobj);
- if (mobj->flags2 & MF2_NIGHTSPULL)
- P_NightsItemChase(mobj);
- else
- A_AttractChase(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:
- if (mobj->flags2 & MF2_NIGHTSPULL)
- P_NightsItemChase(mobj);
+static void P_DragonbomberThink(mobj_t *mobj)
+{
+#define DRAGONTURNSPEED ANG2
+ mobj->movecount = (mobj->movecount + 9) % 360;
+ P_SetObjectMomZ(mobj, 4*FINESINE(((mobj->movecount*ANG1) >> ANGLETOFINESHIFT) & FINEMASK), false);
+ if (mobj->threshold > 0) // are we dropping mines?
+ {
+ mobj->threshold--;
+ if (mobj->threshold == 0) // if the timer hits 0, look for a mine to drop!
+ {
+ mobj_t *segment = mobj;
+ while (segment->tracer != NULL && !P_MobjWasRemoved(segment->tracer) && segment->tracer->state == &states[segment->tracer->info->spawnstate])
+ segment = segment->tracer;
+ if (segment != mobj) // found an unactivated segment?
+ {
+ mobj_t *mine = P_SpawnMobjFromMobj(segment, 0, 0, 0, segment->info->painchance);
+ mine->angle = segment->angle;
+ P_InstaThrust(mine, mobj->angle, P_AproxDistance(mobj->momx, mobj->momy) >> 1);
+ P_SetObjectMomZ(mine, -2*FRACUNIT, true);
+ S_StartSound(mine, mine->info->seesound);
+ P_SetMobjState(segment, segment->info->raisestate);
+ mobj->threshold = mobj->info->painchance;
+ }
+ }
+ }
+ if (mobj->target) // Are we chasing a player?
+ {
+ fixed_t dist = P_AproxDistance(mobj->x - mobj->target->x, mobj->y - mobj->target->y);
+ if (dist > 2000*mobj->scale) // Not anymore!
+ P_SetTarget(&mobj->target, NULL);
+ else
+ {
+ fixed_t vspeed = FixedMul(mobj->info->speed >> 3, mobj->scale);
+ fixed_t z = mobj->target->z + (mobj->height >> 1) + (mobj->flags & MFE_VERTICALFLIP ? -128*mobj->scale : 128*mobj->scale + mobj->target->height);
+ angle_t diff = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y) - mobj->angle;
+ if (diff > ANGLE_180)
+ mobj->angle -= DRAGONTURNSPEED;
+ else
+ mobj->angle += DRAGONTURNSPEED;
+ if (!mobj->threshold && dist < 512*mobj->scale) // Close enough to drop bombs
+ {
+ mobj->threshold = mobj->info->painchance;
+ }
+ mobj->momz += max(min(z - mobj->z, vspeed), -vspeed);
+ }
+ }
+ else // Can we find a player to chase?
+ {
+ if (mobj->tracer == NULL || mobj->tracer->state != &states[mobj->tracer->info->spawnstate]
+ || !P_LookForPlayers(mobj, true, false, 2000*mobj->scale)) // if not, circle around the spawnpoint
+ {
+ if (!mobj->spawnpoint) // unless we don't have one, in which case uhhh just circle around wherever we currently are I guess??
+ mobj->angle += DRAGONTURNSPEED;
+ else
+ {
+ fixed_t vspeed = FixedMul(mobj->info->speed >> 3, mobj->scale);
+ fixed_t x = mobj->spawnpoint->x << FRACBITS;
+ fixed_t y = mobj->spawnpoint->y << FRACBITS;
+ fixed_t z = mobj->spawnpoint->z << FRACBITS;
+ angle_t diff = R_PointToAngle2(mobj->x, mobj->y, x, y) - mobj->angle;
+ if (diff > ANGLE_180)
+ mobj->angle -= DRAGONTURNSPEED;
else
- A_AttractChase(mobj);
- break;
- case MT_EMBLEM:
- if (mobj->flags2 & MF2_NIGHTSPULL)
- P_NightsItemChase(mobj);
- break;
- case MT_SHELL:
- if (mobj->threshold && mobj->threshold != TICRATE)
- mobj->threshold--;
+ mobj->angle += DRAGONTURNSPEED;
+ mobj->momz += max(min(z - mobj->z, vspeed), -vspeed);
+ }
+ }
+ }
+ P_InstaThrust(mobj, mobj->angle, FixedMul(mobj->info->speed, mobj->scale));
+#undef DRAGONTURNSPEED
+}
- if (mobj->threshold >= TICRATE)
- {
- mobj->angle += ((mobj->movedir == 1) ? ANGLE_22h : ANGLE_337h);
- P_InstaThrust(mobj, R_PointToAngle2(0, 0, mobj->momx, mobj->momy), (mobj->info->speed*mobj->scale));
- }
- break;
- case MT_TURRET:
- P_MobjCheckWater(mobj);
- P_CheckPosition(mobj, mobj->x, mobj->y);
- if (P_MobjWasRemoved(mobj))
- return;
- mobj->floorz = tmfloorz;
- mobj->ceilingz = tmceilingz;
- mobj->floorrover = tmfloorrover;
- mobj->ceilingrover = tmceilingrover;
+static boolean P_MobjRegularThink(mobj_t *mobj)
+{
+ if ((mobj->flags & MF_ENEMY) && (mobj->state->nextstate == mobj->info->spawnstate && mobj->tics == 1))
+ mobj->flags2 &= ~MF2_FRET;
- if ((mobj->eflags & MFE_UNDERWATER) && mobj->health > 0)
- {
- P_SetMobjState(mobj, mobj->info->deathstate);
- mobj->health = 0;
- mobj->flags2 &= ~MF2_FIRING;
- }
- else if (mobj->health > 0 && mobj->z + mobj->height > mobj->ceilingz) // Crushed
- {
- INT32 i,j;
- fixed_t ns;
- fixed_t x,y,z;
- mobj_t *mo2;
+ if (mobj->eflags & MFE_TRACERANGLE)
+ P_TracerAngleThink(mobj);
- z = mobj->subsector->sector->floorheight + FixedMul(64*FRACUNIT, mobj->scale);
- for (j = 0; j < 2; j++)
- {
- for (i = 0; i < 32; i++)
- {
- const angle_t fa = (i*FINEANGLES/16) & FINEMASK;
- ns = FixedMul(64 * FRACUNIT, mobj->scale);
- x = mobj->x + FixedMul(FINESINE(fa),ns);
- y = mobj->y + FixedMul(FINECOSINE(fa),ns);
-
- mo2 = P_SpawnMobj(x, y, z, MT_EXPLODE);
- ns = FixedMul(16 * FRACUNIT, mobj->scale);
- mo2->momx = FixedMul(FINESINE(fa),ns);
- mo2->momy = FixedMul(FINECOSINE(fa),ns);
- }
- z -= FixedMul(32*FRACUNIT, mobj->scale);
- }
- P_SetMobjState(mobj, mobj->info->deathstate);
- mobj->health = 0;
- mobj->flags2 &= ~MF2_FIRING;
- }
- break;
- case MT_BLUEFLAG:
- case MT_REDFLAG:
- {
- sector_t *sec2;
- sec2 = P_ThingOnSpecial3DFloor(mobj);
- if ((sec2 && GETSECSPECIAL(sec2->special, 4) == 2) || (GETSECSPECIAL(mobj->subsector->sector->special, 4) == 2))
- mobj->fuse = 1; // Return to base.
- break;
- }
- case MT_CANNONBALL:
-#ifdef FLOORSPLATS
- R_AddFloorSplat(mobj->tracer->subsector, mobj->tracer, "TARGET", mobj->tracer->x,
- mobj->tracer->y, mobj->tracer->floorz, SPLATDRAWMODE_SHADE);
+ switch (mobj->type)
+ {
+ case MT_WALLSPIKEBASE:
+ if (!mobj->target) {
+ P_RemoveMobj(mobj);
+ return false;
+ }
+ mobj->frame = (mobj->frame & ~FF_FRAMEMASK)|(mobj->target->frame & FF_FRAMEMASK);
+#if 0
+ if (mobj->angle != mobj->target->angle + ANGLE_90) // reposition if not the correct angle
+ {
+ mobj_t* target = mobj->target; // shortcut
+ const fixed_t baseradius = target->radius - (target->scale/2); //FixedMul(FRACUNIT/2, target->scale);
+ P_UnsetThingPosition(mobj);
+ mobj->x = target->x - P_ReturnThrustX(target, target->angle, baseradius);
+ mobj->y = target->y - P_ReturnThrustY(target, target->angle, baseradius);
+ P_SetThingPosition(mobj);
+ mobj->angle = target->angle + ANGLE_90;
+ }
#endif
- break;
- case MT_SPINDUST: // Spindash dust
- mobj->momx = FixedMul(mobj->momx, (3*FRACUNIT)/4); // originally 50000
- mobj->momy = FixedMul(mobj->momy, (3*FRACUNIT)/4); // same
- //mobj->momz = mobj->momz+P_MobjFlip(mobj)/3; // no meaningful change in value to be frank
- if (mobj->state >= &states[S_SPINDUST_BUBBLE1] && mobj->state <= &states[S_SPINDUST_BUBBLE4]) // bubble dust!
- {
- P_MobjCheckWater(mobj);
- if (mobj->watertop != mobj->subsector->sector->floorheight - 1000*FRACUNIT
- && mobj->z+mobj->height >= mobj->watertop - 5*FRACUNIT)
- mobj->flags2 |= MF2_DONTDRAW;
- }
- break;
- case MT_TRAINDUSTSPAWNER:
- if (leveltime % 5 == 0) {
- mobj_t *traindust = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_PARTICLE);
- traindust->flags = MF_SCENERY;
- P_SetMobjState(traindust, S_TRAINDUST);
- traindust->frame = P_RandomRange(0, 8) | FF_TRANS90;
- traindust->angle = mobj->angle;
- traindust->tics = TICRATE * 4;
- traindust->destscale = FRACUNIT * 64;
- traindust->scalespeed = FRACUNIT / 24;
- P_SetScale(traindust, FRACUNIT * 6);
- }
- break;
- case MT_TRAINSTEAMSPAWNER:
- if (leveltime % 5 == 0) {
- mobj_t *steam = P_SpawnMobj(mobj->x + FRACUNIT*P_SignedRandom() / 2, mobj->y + FRACUNIT*P_SignedRandom() / 2, mobj->z, MT_PARTICLE);
- P_SetMobjState(steam, S_TRAINSTEAM);
- steam->frame = P_RandomRange(0, 1) | FF_TRANS90;
- steam->tics = TICRATE * 8;
- steam->destscale = FRACUNIT * 64;
- steam->scalespeed = FRACUNIT / 8;
- P_SetScale(steam, FRACUNIT * 16);
- steam->momx = P_SignedRandom() * 32;
- steam->momy = -64 * FRACUNIT;
- steam->momz = 2 * FRACUNIT;
- }
- break;
- case MT_CANARIVORE_GAS:
- {
- fixed_t momz;
+ break;
+ case MT_FALLINGROCK:
+ // Despawn rocks here in case zmovement code can't do so (blame slopes)
+ if (!mobj->momx && !mobj->momy && !mobj->momz
+ && ((mobj->eflags & MFE_VERTICALFLIP) ?
+ mobj->z + mobj->height >= mobj->ceilingz
+ : mobj->z <= mobj->floorz))
+ {
+ P_RemoveMobj(mobj);
+ return false;
+ }
+ P_MobjCheckWater(mobj);
+ break;
+ case MT_ARROW:
+ P_ArrowThink(mobj);
+ break;
+ case MT_EMERALDSPAWN:
+ if (mobj->threshold)
+ {
+ mobj->threshold--;
- if (mobj->flags2 & MF2_AMBUSH)
- {
- mobj->momx = FixedMul(mobj->momx, 50 * FRACUNIT / 51);
- mobj->momy = FixedMul(mobj->momy, 50 * FRACUNIT / 51);
- break;
- }
+ if (!mobj->threshold && !mobj->target && mobj->reactiontime)
+ {
+ mobj_t *emerald = P_SpawnMobj(mobj->x, mobj->y, mobj->z, mobj->reactiontime);
+ emerald->threshold = 42;
+ P_SetTarget(&mobj->target, emerald);
+ P_SetTarget(&emerald->target, mobj);
+ }
+ }
+ break;
+ 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
+ && P_AproxDistance(P_AproxDistance(mobj->tracer->x - mobj->x, mobj->tracer->y - mobj->y), mobj->tracer->z - mobj->z) <= mobj->radius*16)
+ {
+ // Home in on the target.
+ P_HomingAttack(mobj, mobj->tracer);
- if (mobj->eflags & MFE_VERTICALFLIP)
- {
- if ((mobj->z + mobj->height + mobj->momz) <= mobj->ceilingz)
- break;
- }
- else
- {
- if ((mobj->z + mobj->momz) >= mobj->floorz)
- break;
- }
+ if (mobj->z < mobj->floorz)
+ mobj->z = mobj->floorz;
- momz = abs(mobj->momz);
- if (R_PointToDist2(0, 0, mobj->momx, mobj->momy) < momz)
- P_InstaThrust(mobj, R_PointToAngle2(0, 0, mobj->momx, mobj->momy), momz);
- mobj->flags2 |= MF2_AMBUSH;
- break;
- }
- case MT_SALOONDOOR:
- {
- fixed_t x = mobj->tracer->x;
- fixed_t y = mobj->tracer->y;
- fixed_t z = mobj->tracer->z;
- angle_t oang = FixedAngle(mobj->extravalue1);
- angle_t fa = (oang >> ANGLETOFINESHIFT) & FINEMASK;
- fixed_t c0 = -96*FINECOSINE(fa);
- fixed_t s0 = -96*FINESINE(fa);
- angle_t fma;
- fixed_t c, s;
- angle_t angdiff;
-
- // Adjust angular speed
- fixed_t da = AngleFixed(mobj->angle - oang);
- if (da > 180*FRACUNIT)
- da -= 360*FRACUNIT;
- mobj->extravalue2 = 8*(mobj->extravalue2 - da/32)/9;
-
- // Update angle
- mobj->angle += FixedAngle(mobj->extravalue2);
-
- angdiff = mobj->angle - FixedAngle(mobj->extravalue1);
- if (angdiff > (ANGLE_90 - ANG2) && angdiff < ANGLE_180)
- {
- mobj->angle = FixedAngle(mobj->extravalue1) + (ANGLE_90 - ANG2);
- mobj->extravalue2 /= 2;
- }
- else if (angdiff < (ANGLE_270 + ANG2) && angdiff >= ANGLE_180)
- {
- mobj->angle = FixedAngle(mobj->extravalue1) + (ANGLE_270 + ANG2);
- mobj->extravalue2 /= 2;
- }
+ if (leveltime % mobj->info->painchance == 0)
+ S_StartSound(mobj, mobj->info->activesound);
- // Update position
- fma = (mobj->angle >> ANGLETOFINESHIFT) & FINEMASK;
- c = 48*FINECOSINE(fma);
- s = 48*FINESINE(fma);
- P_TeleportMove(mobj, x + c0 + c, y + s0 + s, z);
- break;
- }
- case MT_MINECARTSPAWNER:
- P_HandleMinecartSegments(mobj);
- if (!mobj->fuse || mobj->fuse > TICRATE)
- break;
- if (mobj->fuse == 2)
- {
- mobj->fuse = 0;
- break;
- }
- mobj->flags2 ^= MF2_DONTDRAW;
- break;
- case MT_LAVAFALLROCK:
- if (P_IsObjectOnGround(mobj))
- P_RemoveMobj(mobj);
- break;
- case MT_PYREFLY:
+ if ((statenum_t)(mobj->state - states) != mobj->info->seestate)
+ P_SetMobjState(mobj, mobj->info->seestate);
+ }
+ else
+ {
+ // Try to find a player
+ P_LookForPlayers(mobj, true, true, mobj->radius*16);
+ 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;
+ case MT_BUMBLEBORE:
+ P_BumbleboreThink(mobj);
+ break;
+ case MT_BIGMINE:
+ mobj->extravalue1 += 3;
+ mobj->extravalue1 %= 360;
+ P_UnsetThingPosition(mobj);
+ mobj->z += FINESINE(mobj->extravalue1*(FINEMASK + 1)/360);
+ P_SetThingPosition(mobj);
+ break;
+ case MT_FLAME:
+ if (mobj->flags2 & MF2_BOSSNOTRAP)
+ {
+ if (!mobj->target || P_MobjWasRemoved(mobj->target))
+ {
+ if (mobj->tracer && !P_MobjWasRemoved(mobj->tracer))
+ P_RemoveMobj(mobj->tracer);
+ P_RemoveMobj(mobj);
+ return false;
+ }
+ mobj->z = mobj->target->z + mobj->target->momz;
+ if (!(mobj->eflags & MFE_VERTICALFLIP))
+ mobj->z += mobj->target->height;
+ }
+ if (mobj->tracer && !P_MobjWasRemoved(mobj->tracer))
+ {
+ mobj->tracer->z = mobj->z + P_MobjFlip(mobj)*20*mobj->scale;
+ if (mobj->eflags & MFE_VERTICALFLIP)
+ mobj->tracer->z += mobj->height;
+ }
+ break;
+ case MT_WAVINGFLAG1:
+ case MT_WAVINGFLAG2:
+ {
+ fixed_t base = (leveltime << (FRACBITS + 1));
+ mobj_t *seg = mobj->tracer, *prev = mobj;
+ mobj->movedir = mobj->angle
+ + ((((FINESINE((FixedAngle(base << 1) >> ANGLETOFINESHIFT) & FINEMASK)
+ + FINESINE((FixedAngle(base << 4) >> ANGLETOFINESHIFT) & FINEMASK)) >> 1)
+ + FINESINE((FixedAngle(base*9) >> ANGLETOFINESHIFT) & FINEMASK)
+ + FINECOSINE(((FixedAngle(base*9)) >> ANGLETOFINESHIFT) & FINEMASK)) << 12); //*2^12
+ while (seg)
+ {
+ seg->movedir = seg->angle;
+ seg->angle = prev->movedir;
+ P_UnsetThingPosition(seg);
+ seg->x = prev->x + P_ReturnThrustX(prev, prev->angle, prev->radius);
+ seg->y = prev->y + P_ReturnThrustY(prev, prev->angle, prev->radius);
+ seg->z = prev->z + prev->height - (seg->scale >> 1);
+ P_SetThingPosition(seg);
+ prev = seg;
+ seg = seg->tracer;
+ }
+ }
+ break;
+ case MT_SPINCUSHION:
+ if (mobj->target && mobj->state - states >= S_SPINCUSHION_AIM1 && mobj->state - states <= S_SPINCUSHION_AIM5)
+ mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
+ break;
+ case MT_CRUSHCLAW:
+ if (mobj->state - states == S_CRUSHCLAW_STAY && mobj->target)
+ {
+ mobj_t *chain = mobj->target->target;
+ SINT8 sign = ((mobj->tics & 1) ? mobj->tics : -(SINT8)(mobj->tics));
+ while (chain)
+ {
+ chain->z = chain->movefactor + sign*mobj->scale;
+ sign = -sign;
+ chain = chain->target;
+ }
+ }
+ break;
+ case MT_SMASHINGSPIKEBALL:
+ mobj->momx = mobj->momy = 0;
+ if (mobj->state - states == S_SMASHSPIKE_FALL && P_IsObjectOnGround(mobj))
+ {
+ P_SetMobjState(mobj, S_SMASHSPIKE_STOMP1);
+ S_StartSound(mobj, sfx_spsmsh);
+ }
+ else if (mobj->state - states == S_SMASHSPIKE_RISE2 && P_MobjFlip(mobj)*(mobj->z - mobj->movecount) >= 0)
+ {
+ mobj->momz = 0;
+ P_SetMobjState(mobj, S_SMASHSPIKE_FLOAT);
+ }
+ break;
+ case MT_HANGSTER:
+ if (!P_HangsterThink(mobj))
+ return false;
+ break;
+ case MT_LHRT:
+ mobj->momx = FixedMul(mobj->momx, mobj->extravalue2);
+ mobj->momy = FixedMul(mobj->momy, mobj->extravalue2);
+ break;
+ case MT_EGGCAPSULE:
+ if (!mobj->reactiontime)
+ {
+ // Target nearest player on your mare.
+ // (You can make it float up/down by adding MF_FLOAT,
+ // but beware level design pitfalls.)
+ fixed_t shortest = 1024*FRACUNIT;
+ INT32 i;
+ P_SetTarget(&mobj->target, NULL);
+ for (i = 0; i < MAXPLAYERS; i++)
+ if (playeringame[i] && players[i].mo
+ && players[i].mare == mobj->threshold && players[i].spheres > 0)
{
- 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)
+ fixed_t dist = P_AproxDistance(players[i].mo->x - mobj->x, players[i].mo->y - mobj->y);
+ if (dist < shortest)
{
- 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);
+ P_SetTarget(&mobj->target, players[i].mo);
+ shortest = dist;
}
+ }
+ }
+ break;
+ case MT_EGGMOBILE2_POGO:
+ if (!mobj->target
+ || !mobj->target->health
+ || mobj->target->state == &states[mobj->target->info->spawnstate]
+ || mobj->target->state == &states[mobj->target->info->raisestate])
+ {
+ P_RemoveMobj(mobj);
+ return false;
+ }
+ P_TeleportMove(mobj, mobj->target->x, mobj->target->y, mobj->target->z - mobj->height);
+ break;
+ case MT_HAMMER:
+ if (mobj->z <= mobj->floorz)
+ {
+ P_RemoveMobj(mobj);
+ return false;
+ }
+ break;
+ case MT_KOOPA:
+ P_KoopaThinker(mobj);
+ break;
+ case MT_FIREBALL:
+ if (P_AproxDistance(mobj->momx, mobj->momy) <= 16*FRACUNIT) // Once fireballs lose enough speed, kill them
+ {
+ P_KillMobj(mobj, NULL, NULL, 0);
+ return false;
+ }
+ break;
+ case MT_REDRING:
+ if (((mobj->z < mobj->floorz) || (mobj->z + mobj->height > mobj->ceilingz))
+ && mobj->flags & MF_MISSILE)
+ {
+ P_ExplodeMissile(mobj);
+ return false;
+ }
+ break;
+ case MT_BOSSFLYPOINT:
+ return false;
+ case MT_NIGHTSCORE:
+ mobj->color = (UINT8)(leveltime % SKINCOLOR_WHITE);
+ break;
+ case MT_JETFUME1:
+ if (!P_JetFume1Think(mobj))
+ return false;
+ break;
+ case MT_JETFLAME:
+ {
+ if (!mobj->target // if you have no target
+ || (!(mobj->target->flags & MF_BOSS) && mobj->target->health <= 0)) // or your target isn't a boss and it's popped now
+ { // then remove yourself as well!
+ P_RemoveMobj(mobj);
+ return false;
+ }
- hdist = R_PointToDist2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
+ P_UnsetThingPosition(mobj);
+ mobj->x = mobj->target->x;
+ mobj->y = mobj->target->y;
+ mobj->z = mobj->target->z - 50*mobj->target->scale;
+ mobj->floorz = mobj->z;
+ mobj->ceilingz = mobj->z + mobj->height;
+ P_SetThingPosition(mobj);
+ }
+ break;
+ case MT_EGGROBO1:
+ if (!P_EggRobo1Think(mobj))
+ return false;
+ break;
+ case MT_EGGROBO1JET:
+ {
+ if (!mobj->target || P_MobjWasRemoved(mobj->target) // if you have no target
+ || (mobj->target->health <= 0)) // or your target isn't a boss and it's popped now
+ { // then remove yourself as well!
+ P_RemoveMobj(mobj);
+ return false;
+ }
- if (hdist > 1500*FRACUNIT)
- {
- mobj->flags2 &= ~MF2_BOSSNOTRAP;
- P_SetTarget(&mobj->target, NULL);
- break;
- }
+ mobj->flags2 ^= MF2_DONTDRAW;
- if (!(mobj->flags2 & MF2_BOSSNOTRAP) && hdist <= 450*FRACUNIT)
- mobj->flags2 |= MF2_BOSSNOTRAP;
+ P_UnsetThingPosition(mobj);
+ mobj->x = mobj->target->x + P_ReturnThrustX(mobj, mobj->target->angle + ANGLE_90, mobj->movefactor*mobj->target->scale) - P_ReturnThrustX(mobj, mobj->target->angle, 19*mobj->target->scale);
+ mobj->y = mobj->target->y + P_ReturnThrustY(mobj, mobj->target->angle + ANGLE_90, mobj->movefactor*mobj->target->scale) - P_ReturnThrustY(mobj, mobj->target->angle, 19*mobj->target->scale);
+ mobj->z = mobj->target->z;
+ if (mobj->target->eflags & MFE_VERTICALFLIP)
+ mobj->z += (mobj->target->height - mobj->height);
+ mobj->floorz = mobj->z;
+ mobj->ceilingz = mobj->z + mobj->height;
+ P_SetThingPosition(mobj);
+ }
+ break;
+ case MT_NIGHTSDRONE:
+ P_NiGHTSDroneThink(mobj);
+ break;
+ case MT_PLAYER:
+ if (mobj->player)
+ P_PlayerMobjThinker(mobj);
+ return false;
+ case MT_SKIM:
+ // check mobj against possible water content, before movement code
+ P_MobjCheckWater(mobj);
- if (!(mobj->flags2 & MF2_BOSSNOTRAP))
- break;
+ // Keep Skim at water surface
+ if (mobj->z <= mobj->watertop)
+ {
+ mobj->flags |= MF_NOGRAVITY;
+ if (mobj->z < mobj->watertop)
+ {
+ if (mobj->watertop - mobj->z <= FixedMul(mobj->info->speed*FRACUNIT, mobj->scale))
+ mobj->z = mobj->watertop;
+ else
+ mobj->momz = FixedMul(mobj->info->speed*FRACUNIT, mobj->scale);
+ }
+ }
+ else
+ {
+ mobj->flags &= ~MF_NOGRAVITY;
+ if (mobj->z > mobj->watertop && mobj->z - mobj->watertop < FixedMul(MAXSTEPMOVE, mobj->scale))
+ mobj->z = mobj->watertop;
+ }
+ break;
+ case MT_RING:
+ case MT_REDTEAMRING:
+ case MT_BLUETEAMRING:
+ P_KillRingsInLava(mobj);
+ if (P_MobjWasRemoved(mobj))
+ return false;
+ /* FALLTHRU */
+ case MT_COIN:
+ case MT_BLUESPHERE:
+ case MT_BOMBSPHERE:
+ case MT_NIGHTSCHIP:
+ case MT_NIGHTSSTAR:
+ // No need to check water. Who cares?
+ P_RingThinker(mobj);
+ if (mobj->flags2 & MF2_NIGHTSPULL)
+ P_NightsItemChase(mobj);
+ else
+ A_AttractChase(mobj);
+ return false;
+ // Flung items
+ case MT_FLINGRING:
+ P_KillRingsInLava(mobj);
+ if (P_MobjWasRemoved(mobj))
+ return false;
+ /* FALLTHRU */
+ case MT_FLINGCOIN:
+ case MT_FLINGBLUESPHERE:
+ case MT_FLINGNIGHTSCHIP:
+ if (mobj->flags2 & MF2_NIGHTSPULL)
+ P_NightsItemChase(mobj);
+ else
+ A_AttractChase(mobj);
+ break;
+ case MT_EMBLEM:
+ if (mobj->flags2 & MF2_NIGHTSPULL)
+ P_NightsItemChase(mobj);
+ break;
+ case MT_SHELL:
+ if (mobj->threshold && mobj->threshold != TICRATE)
+ mobj->threshold--;
- 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->threshold >= TICRATE)
+ {
+ mobj->angle += ((mobj->movedir == 1) ? ANGLE_22h : ANGLE_337h);
+ P_InstaThrust(mobj, R_PointToAngle2(0, 0, mobj->momx, mobj->momy), (mobj->info->speed*mobj->scale));
+ }
+ break;
+ case MT_TURRET:
+ if (!P_TurretThink(mobj))
+ return false;
+ break;
+ case MT_BLUEFLAG:
+ case MT_REDFLAG:
+ {
+ sector_t* sec2;
+ sec2 = P_ThingOnSpecial3DFloor(mobj);
+ if ((sec2 && GETSECSPECIAL(sec2->special, 4) == 2) || (GETSECSPECIAL(mobj->subsector->sector->special, 4) == 2))
+ mobj->fuse = 1; // Return to base.
+ break;
+ }
+ case MT_CANNONBALL:
+#ifdef FLOORSPLATS
+ R_AddFloorSplat(mobj->tracer->subsector, mobj->tracer, "TARGET", mobj->tracer->x,
+ mobj->tracer->y, mobj->tracer->floorz, SPLATDRAWMODE_SHADE);
+#endif
+ break;
+ case MT_SPINDUST: // Spindash dust
+ mobj->momx = FixedMul(mobj->momx, (3*FRACUNIT)/4); // originally 50000
+ mobj->momy = FixedMul(mobj->momy, (3*FRACUNIT)/4); // same
+ //mobj->momz = mobj->momz+P_MobjFlip(mobj)/3; // no meaningful change in value to be frank
+ if (mobj->state >= &states[S_SPINDUST_BUBBLE1] && mobj->state <= &states[S_SPINDUST_BUBBLE4]) // bubble dust!
+ {
+ P_MobjCheckWater(mobj);
+ if (mobj->watertop != mobj->subsector->sector->floorheight - 1000*FRACUNIT
+ && mobj->z + mobj->height >= mobj->watertop - 5*FRACUNIT)
+ mobj->flags2 |= MF2_DONTDRAW;
+ }
+ break;
+ case MT_TRAINDUSTSPAWNER:
+ if (leveltime % 5 == 0) {
+ mobj_t* traindust = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_PARTICLE);
+ traindust->flags = MF_SCENERY;
+ P_SetMobjState(traindust, S_TRAINDUST);
+ traindust->frame = P_RandomRange(0, 8)|FF_TRANS90;
+ traindust->angle = mobj->angle;
+ traindust->tics = TICRATE*4;
+ traindust->destscale = FRACUNIT*64;
+ traindust->scalespeed = FRACUNIT/24;
+ P_SetScale(traindust, FRACUNIT*6);
+ }
+ break;
+ case MT_TRAINSTEAMSPAWNER:
+ if (leveltime % 5 == 0) {
+ mobj_t *steam = P_SpawnMobj(mobj->x + FRACUNIT*P_SignedRandom()/2, mobj->y + FRACUNIT*P_SignedRandom()/2, mobj->z, MT_PARTICLE);
+ P_SetMobjState(steam, S_TRAINSTEAM);
+ steam->frame = P_RandomRange(0, 1)|FF_TRANS90;
+ steam->tics = TICRATE*8;
+ steam->destscale = FRACUNIT*64;
+ steam->scalespeed = FRACUNIT/8;
+ P_SetScale(steam, FRACUNIT*16);
+ steam->momx = P_SignedRandom()*32;
+ steam->momy = -64*FRACUNIT;
+ steam->momz = 2*FRACUNIT;
+ }
+ break;
+ case MT_CANARIVORE_GAS:
+ {
+ fixed_t momz;
- if ((mobj->extravalue1 & 3) == 0) // Hovering
- {
- fixed_t vdist, hdist, time;
- fixed_t hspeed = 3*mobj->info->speed;
- angle_t fa;
+ if (mobj->flags2 & MF2_AMBUSH)
+ {
+ mobj->momx = FixedMul(mobj->momx, 50*FRACUNIT/51);
+ mobj->momy = FixedMul(mobj->momy, 50*FRACUNIT/51);
+ break;
+ }
- var1 = 1;
- var2 = 0;
- A_CapeChase(mobj);
+ if (mobj->eflags & MFE_VERTICALFLIP)
+ {
+ if ((mobj->z + mobj->height + mobj->momz) <= mobj->ceilingz)
+ break;
+ }
+ else
+ {
+ if ((mobj->z + mobj->momz) >= mobj->floorz)
+ break;
+ }
- if (mobj->target)
- break; // Still carrying a player or in cooldown
+ momz = abs(mobj->momz);
+ if (R_PointToDist2(0, 0, mobj->momx, mobj->momy) < momz)
+ P_InstaThrust(mobj, R_PointToAngle2(0, 0, mobj->momx, mobj->momy), momz);
+ mobj->flags2 |= MF2_AMBUSH;
+ break;
+ }
+ case MT_SALOONDOOR:
+ P_SaloonDoorThink(mobj);
+ break;
+ case MT_MINECARTSPAWNER:
+ P_HandleMinecartSegments(mobj);
+ if (!mobj->fuse || mobj->fuse > TICRATE)
+ break;
+ if (mobj->fuse == 2)
+ {
+ mobj->fuse = 0;
+ break;
+ }
+ mobj->flags2 ^= MF2_DONTDRAW;
+ break;
+ case MT_LAVAFALLROCK:
+ if (P_IsObjectOnGround(mobj))
+ P_RemoveMobj(mobj);
+ break;
+ case MT_PYREFLY:
+ P_PyreFlyThink(mobj);
+ break;
+ case MT_PTERABYTE:
+ P_PterabyteThink(mobj);
+ break;
+ case MT_DRAGONBOMBER:
+ P_DragonbomberThink(mobj);
+ break;
+ case MT_MINUS:
+ if (P_IsObjectOnGround(mobj))
+ mobj->rollangle = 0;
+ else
+ mobj->rollangle = R_PointToAngle2(0, 0, mobj->momz, (mobj->scale << 1) - min(abs(mobj->momz), mobj->scale << 1));
+ break;
+ case MT_SPINFIRE:
+ if (mobj->flags & MF_NOGRAVITY)
+ {
+ if (mobj->eflags & MFE_VERTICALFLIP)
+ mobj->z = mobj->ceilingz - mobj->height;
+ 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
+ P_MobjCheckWater(mobj);
- P_LookForPlayers(mobj, true, false, 256*FRACUNIT);
+ // Extinguish fire objects in water
+ if (mobj->flags & MF_FIRE && mobj->type != MT_PUMA && mobj->type != MT_FIREBALL
+ && (mobj->eflags & (MFE_UNDERWATER|MFE_TOUCHWATER)))
+ {
+ P_KillMobj(mobj, NULL, NULL, 0);
+ return false;
+ }
+ break;
+ }
+ return true;
+}
- if (!mobj->target)
- break;
+static void P_FiringThink(mobj_t *mobj)
+{
+ if (!mobj->target)
+ return;
- if (mobj->target->player->powers[pw_flashing])
- {
- P_SetTarget(&mobj->target, NULL);
- break;
- }
+ if (mobj->health <= 0)
+ return;
- vdist = mobj->z - mobj->target->z - mobj->target->height;
- if (P_MobjFlip(mobj)*vdist <= 0)
- {
- P_SetTarget(&mobj->target, NULL);
- break;
- }
+ if (mobj->state->action.acp1 == (actionf_p1)A_Boss1Laser)
+ {
+ if (mobj->state->tics > 1)
+ {
+ var1 = mobj->state->var1;
+ var2 = mobj->state->var2 & 65535;
+ mobj->state->action.acp1(mobj);
+ }
+ }
+ else if (leveltime & 1) // Fire mode
+ {
+ mobj_t *missile;
- hdist = R_PointToDist2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
- if (hdist > 450*FRACUNIT)
- {
- P_SetTarget(&mobj->target, NULL);
- break;
- }
+ if (mobj->target->player && mobj->target->player->powers[pw_carry] == CR_NIGHTSMODE)
+ {
+ fixed_t oldval = mobjinfo[mobj->extravalue1].speed;
- 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;
+ mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x + mobj->target->momx, mobj->target->y + mobj->target->momy);
+ mobjinfo[mobj->extravalue1].speed = FixedMul(60*FRACUNIT, mobj->scale);
+ missile = P_SpawnMissile(mobj, mobj->target, mobj->extravalue1);
+ mobjinfo[mobj->extravalue1].speed = oldval;
+ }
+ else
+ {
+ mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
+ missile = P_SpawnMissile(mobj, mobj->target, mobj->extravalue1);
+ }
- 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_DRAGONBOMBER:
- {
-#define DRAGONTURNSPEED ANG2
- mobj->movecount = (mobj->movecount + 9) % 360;
- P_SetObjectMomZ(mobj, 4*FINESINE(((mobj->movecount*ANG1) >> ANGLETOFINESHIFT) & FINEMASK), false);
- if (mobj->threshold > 0) // are we dropping mines?
- {
- mobj->threshold--;
- if (mobj->threshold == 0) // if the timer hits 0, look for a mine to drop!
- {
- mobj_t *segment = mobj;
- while (segment->tracer != NULL && !P_MobjWasRemoved(segment->tracer) && segment->tracer->state == &states[segment->tracer->info->spawnstate])
- {
- segment = segment->tracer;
- }
- if (segment != mobj) // found an unactivated segment?
- {
- mobj_t *mine = P_SpawnMobjFromMobj(segment, 0, 0, 0, segment->info->painchance);
- mine->angle = segment->angle;
- P_InstaThrust(mine, mobj->angle, P_AproxDistance(mobj->momx, mobj->momy) >> 1);
- P_SetObjectMomZ(mine, -2*FRACUNIT, true);
- S_StartSound(mine, mine->info->seesound);
- P_SetMobjState(segment, segment->info->raisestate);
- mobj->threshold = mobj->info->painchance;
- }
- }
- }
- if (mobj->target != NULL) // Are we chasing a player?
- {
- fixed_t dist = P_AproxDistance(mobj->x - mobj->target->x, mobj->y - mobj->target->y);
- if (dist > 2000 * mobj->scale) // Not anymore!
- P_SetTarget(&mobj->target, NULL);
- else
- {
- fixed_t vspeed = FixedMul(mobj->info->speed >> 3, mobj->scale);
- fixed_t z = mobj->target->z + (mobj->height >> 1) + (mobj->flags & MFE_VERTICALFLIP ? -128*mobj->scale : 128*mobj->scale + mobj->target->height);
- angle_t diff = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y) - mobj->angle;
- if (diff > ANGLE_180)
- mobj->angle -= DRAGONTURNSPEED;
- else
- mobj->angle += DRAGONTURNSPEED;
- if (!mobj->threshold && dist < 512 * mobj->scale) // Close enough to drop bombs
- {
- mobj->threshold = mobj->info->painchance;
- }
- mobj->momz += max(min(z - mobj->z, vspeed), -vspeed);
- }
- }
- else // Can we find a player to chase?
- {
- if (mobj->tracer == NULL || mobj->tracer->state != &states[mobj->tracer->info->spawnstate]
- || !P_LookForPlayers(mobj, true, false, 2000*mobj->scale)) // if not, circle around the spawnpoint
- {
- if (!mobj->spawnpoint) // unless we don't have one, in which case uhhh just circle around wherever we currently are I guess??
- mobj->angle += DRAGONTURNSPEED;
- else
- {
- fixed_t vspeed = FixedMul(mobj->info->speed >> 3, mobj->scale);
- fixed_t x = mobj->spawnpoint->x << FRACBITS;
- fixed_t y = mobj->spawnpoint->y << FRACBITS;
- fixed_t z = mobj->spawnpoint->z << FRACBITS;
- angle_t diff = R_PointToAngle2(mobj->x, mobj->y, x, y) - mobj->angle;
- if (diff > ANGLE_180)
- mobj->angle -= DRAGONTURNSPEED;
- else
- mobj->angle += DRAGONTURNSPEED;
- mobj->momz += max(min(z - mobj->z, vspeed), -vspeed);
- }
- }
- }
- P_InstaThrust(mobj, mobj->angle, FixedMul(mobj->info->speed, mobj->scale));
-#undef DRAGONTURNSPEED
- }
- break;
- case MT_MINUS:
-#ifdef ROTSPRITE
- {
- if (P_IsObjectOnGround(mobj))
- mobj->rollangle = 0;
- else
- mobj->rollangle = R_PointToAngle2(0, 0, mobj->momz, (mobj->scale << 1) - min(abs(mobj->momz), mobj->scale << 1));
- }
-#endif
- break;
- case MT_SPINFIRE:
- if (mobj->flags & MF_NOGRAVITY)
- {
- if (mobj->eflags & MFE_VERTICALFLIP)
- mobj->z = mobj->ceilingz - mobj->height;
- 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
- P_MobjCheckWater(mobj);
+ if (missile)
+ {
+ if (mobj->flags2 & MF2_SUPERFIRE)
+ missile->flags2 |= MF2_SUPERFIRE;
- // Extinguish fire objects in water
- if (mobj->flags & MF_FIRE && mobj->type != MT_PUMA && mobj->type != MT_FIREBALL
- && (mobj->eflags & (MFE_UNDERWATER|MFE_TOUCHWATER)))
- {
- P_KillMobj(mobj, NULL, NULL, 0);
- return;
- }
- break;
+ if (mobj->info->attacksound)
+ S_StartSound(missile, mobj->info->attacksound);
}
}
- if (P_MobjWasRemoved(mobj))
- return;
+ else
+ mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
+}
+
+static void P_MonitorFuseThink(mobj_t *mobj)
+{
+ mobj_t *newmobj;
- if (mobj->flags2 & MF2_FIRING && mobj->target && mobj->health > 0)
+ // Special case for ALL monitors.
+ // If a box's speed is nonzero, it's allowed to respawn as a WRM/SRM.
+ if (mobj->info->speed != 0 && (mobj->flags2 & (MF2_AMBUSH|MF2_STRONGBOX)))
{
- if (mobj->state->action.acp1 == (actionf_p1)A_Boss1Laser)
- {
- if (mobj->state->tics > 1)
- {
- var1 = mobj->state->var1;
- var2 = mobj->state->var2 & 65535;
- mobj->state->action.acp1(mobj);
- }
- }
- else if (leveltime & 1) // Fire mode
- {
- mobj_t *missile;
+ mobjtype_t spawnchance[64];
+ INT32 numchoices = 0, i = 0;
- if (mobj->target->player && mobj->target->player->powers[pw_carry] == CR_NIGHTSMODE)
- {
- fixed_t oldval = mobjinfo[mobj->extravalue1].speed;
+ // This define should make it a lot easier to organize and change monitor weights
+#define SETMONITORCHANCES(type, strongboxamt, weakboxamt) \
+for (i = ((mobj->flags2 & MF2_STRONGBOX) ? strongboxamt : weakboxamt); i; --i) spawnchance[numchoices++] = type
- mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x+mobj->target->momx, mobj->target->y+mobj->target->momy);
- mobjinfo[mobj->extravalue1].speed = FixedMul(60*FRACUNIT, mobj->scale);
- missile = P_SpawnMissile(mobj, mobj->target, mobj->extravalue1);
- mobjinfo[mobj->extravalue1].speed = oldval;
- }
- else
- {
- mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
- missile = P_SpawnMissile(mobj, mobj->target, mobj->extravalue1);
- }
+ // Type SRM WRM
+ SETMONITORCHANCES(MT_SNEAKERS_BOX, 0, 10); // Super Sneakers
+ SETMONITORCHANCES(MT_INVULN_BOX, 2, 0); // Invincibility
+ SETMONITORCHANCES(MT_WHIRLWIND_BOX, 3, 8); // Whirlwind Shield
+ SETMONITORCHANCES(MT_ELEMENTAL_BOX, 3, 8); // Elemental Shield
+ SETMONITORCHANCES(MT_ATTRACT_BOX, 2, 0); // Attraction Shield
+ SETMONITORCHANCES(MT_FORCE_BOX, 3, 3); // Force Shield
+ SETMONITORCHANCES(MT_ARMAGEDDON_BOX, 2, 0); // Armageddon Shield
+ SETMONITORCHANCES(MT_MIXUP_BOX, 0, 1); // Teleporters
+ SETMONITORCHANCES(MT_RECYCLER_BOX, 0, 1); // Recycler
+ SETMONITORCHANCES(MT_1UP_BOX, 1, 1); // 1-Up
+ // =======================================
+ // Total 16 32
- if (missile)
- {
- if (mobj->flags2 & MF2_SUPERFIRE)
- missile->flags2 |= MF2_SUPERFIRE;
+#undef SETMONITORCHANCES
- if (mobj->info->attacksound)
- S_StartSound(missile, mobj->info->attacksound);
- }
- }
- else
- mobj->angle = R_PointToAngle2(mobj->x, mobj->y, mobj->target->x, mobj->target->y);
+ i = P_RandomKey(numchoices); // Gotta love those random numbers!
+ newmobj = P_SpawnMobj(mobj->x, mobj->y, mobj->z, spawnchance[i]);
}
+ else
+ newmobj = P_SpawnMobj(mobj->x, mobj->y, mobj->z, mobj->type);
- if (mobj->flags & MF_AMBIENT)
- {
- if (!(leveltime % mobj->health) && mobj->info->seesound)
- S_StartSound(mobj, mobj->info->seesound);
+ // Transfer flags2 (ambush, strongbox, objectflip)
+ newmobj->flags2 = mobj->flags2;
+ P_RemoveMobj(mobj); // make sure they disappear
+}
+
+static void P_FlagFuseThink(mobj_t *mobj)
+{
+ subsector_t *ss;
+ fixed_t x, y, z;
+ mobj_t* flagmo;
+
+ if (!mobj->spawnpoint)
return;
+
+ x = mobj->spawnpoint->x << FRACBITS;
+ y = mobj->spawnpoint->y << FRACBITS;
+ z = mobj->spawnpoint->z << FRACBITS;
+ ss = R_PointInSubsector(x, y);
+ if (mobj->spawnpoint->options & MTF_OBJECTFLIP)
+ z = ss->sector->ceilingheight - mobjinfo[mobj->type].height - z;
+ else
+ z = ss->sector->floorheight + z;
+ flagmo = P_SpawnMobj(x, y, z, mobj->type);
+ flagmo->spawnpoint = mobj->spawnpoint;
+ if (mobj->spawnpoint->options & MTF_OBJECTFLIP)
+ {
+ flagmo->eflags |= MFE_VERTICALFLIP;
+ flagmo->flags2 |= MF2_OBJECTFLIP;
}
- // Check fuse
- if (mobj->fuse)
+ if (mobj->type == MT_REDFLAG)
{
+ if (!(mobj->flags2 & MF2_JUSTATTACKED))
+ CONS_Printf(M_GetText("The %c%s%c has returned to base.\n"), 0x85, M_GetText("Red flag"), 0x80);
- if (mobj->type == MT_SNAPPER_HEAD || mobj->type == MT_SNAPPER_LEG || mobj->type == MT_MINECARTSEG)
- mobj->flags2 ^= MF2_DONTDRAW;
+ // Assumedly in splitscreen players will be on opposing teams
+ if (players[consoleplayer].ctfteam == 1 || splitscreen)
+ S_StartSound(NULL, sfx_hoop1);
+ else if (players[consoleplayer].ctfteam == 2)
+ S_StartSound(NULL, sfx_hoop3);
- mobj->fuse--;
- if (!mobj->fuse)
- {
- subsector_t *ss;
- fixed_t x, y, z;
- mobj_t *flagmo, *newmobj;
+ redflag = flagmo;
+ }
+ else // MT_BLUEFLAG
+ {
+ if (!(mobj->flags2 & MF2_JUSTATTACKED))
+ CONS_Printf(M_GetText("The %c%s%c has returned to base.\n"), 0x84, M_GetText("Blue flag"), 0x80);
+
+ // Assumedly in splitscreen players will be on opposing teams
+ if (players[consoleplayer].ctfteam == 2 || splitscreen)
+ S_StartSound(NULL, sfx_hoop1);
+ else if (players[consoleplayer].ctfteam == 1)
+ S_StartSound(NULL, sfx_hoop3);
+
+ blueflag = flagmo;
+ }
+}
+
+static boolean P_FuseThink(mobj_t *mobj)
+{
+ if (mobj->type == MT_SNAPPER_HEAD || mobj->type == MT_SNAPPER_LEG || mobj->type == MT_MINECARTSEG)
+ mobj->flags2 ^= MF2_DONTDRAW;
+
+ mobj->fuse--;
+
+ if (mobj->fuse)
+ return true;
#ifdef HAVE_BLUA
- if (LUAh_MobjFuse(mobj) || P_MobjWasRemoved(mobj))
- ;
- else
+ if (LUAh_MobjFuse(mobj) || P_MobjWasRemoved(mobj))
+ ;
+ else
#endif
- if (mobj->info->flags & MF_MONITOR)
+ if (mobj->info->flags & MF_MONITOR)
+ {
+ P_MonitorFuseThink(mobj);
+ return false;
+ }
+ else switch (mobj->type)
+ {
+ // gargoyle and snowman handled in P_PushableThinker, not here
+ case MT_THROWNGRENADE:
+ case MT_CYBRAKDEMON_NAPALM_BOMB_LARGE:
+ P_SetMobjState(mobj, mobj->info->deathstate);
+ break;
+ case MT_LHRT:
+ P_KillMobj(mobj, NULL, NULL, 0);
+ break;
+ case MT_BLUEFLAG:
+ case MT_REDFLAG:
+ P_FlagFuseThink(mobj);
+ P_RemoveMobj(mobj);
+ return false;
+ case MT_FANG:
+ if (mobj->flags2 & MF2_SLIDEPUSH)
{
- // Special case for ALL monitors.
- // If a box's speed is nonzero, it's allowed to respawn as a WRM/SRM.
- if (mobj->info->speed != 0 && (mobj->flags2 & (MF2_AMBUSH|MF2_STRONGBOX)))
- {
- mobjtype_t spawnchance[64];
- INT32 numchoices = 0, i = 0;
+ var1 = 0;
+ var2 = 0;
+ A_BossDeath(mobj);
+ return false;
+ }
+ P_SetMobjState(mobj, mobj->state->nextstate);
+ if (P_MobjWasRemoved(mobj))
+ return false;
+ break;
+ case MT_METALSONIC_BATTLE:
+ break; // don't remove
+ case MT_SPIKE:
+ P_SetMobjState(mobj, mobj->state->nextstate);
+ mobj->fuse = mobj->info->speed;
+ if (mobj->spawnpoint)
+ mobj->fuse += mobj->spawnpoint->angle;
+ break;
+ case MT_WALLSPIKE:
+ P_SetMobjState(mobj, mobj->state->nextstate);
+ mobj->fuse = mobj->info->speed;
+ if (mobj->spawnpoint)
+ mobj->fuse += (mobj->spawnpoint->angle / 360);
+ break;
+ case MT_NIGHTSCORE:
+ P_RemoveMobj(mobj);
+ return false;
+ 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 false;
+ case MT_PYREFLY:
+ if (mobj->health <= 0)
+ break;
-// This define should make it a lot easier to organize and change monitor weights
-#define SETMONITORCHANCES(type, strongboxamt, weakboxamt) \
-for (i = ((mobj->flags2 & MF2_STRONGBOX) ? strongboxamt : weakboxamt); i; --i) spawnchance[numchoices++] = type
+ 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 false;
+ case MT_PLAYER:
+ break; // don't remove
+ default:
+ P_SetMobjState(mobj, mobj->info->xdeathstate); // will remove the mobj if S_NULL.
+ break;
+ // Looking for monitors? They moved to a special condition above.
+ }
- // Type SRM WRM
- SETMONITORCHANCES(MT_SNEAKERS_BOX, 0, 10); // Super Sneakers
- SETMONITORCHANCES(MT_INVULN_BOX, 2, 0); // Invincibility
- SETMONITORCHANCES(MT_WHIRLWIND_BOX, 3, 8); // Whirlwind Shield
- SETMONITORCHANCES(MT_ELEMENTAL_BOX, 3, 8); // Elemental Shield
- SETMONITORCHANCES(MT_ATTRACT_BOX, 2, 0); // Attraction Shield
- SETMONITORCHANCES(MT_FORCE_BOX, 3, 3); // Force Shield
- SETMONITORCHANCES(MT_ARMAGEDDON_BOX, 2, 0); // Armageddon Shield
- SETMONITORCHANCES(MT_MIXUP_BOX, 0, 1); // Teleporters
- SETMONITORCHANCES(MT_RECYCLER_BOX, 0, 1); // Recycler
- SETMONITORCHANCES(MT_1UP_BOX, 1, 1); // 1-Up
- // =======================================
- // Total 16 32
+ return !P_MobjWasRemoved(mobj);
+}
-#undef SETMONITORCHANCES
+//
+// P_MobjThinker
+//
+void P_MobjThinker(mobj_t *mobj)
+{
+ I_Assert(mobj != NULL);
+ I_Assert(!P_MobjWasRemoved(mobj));
- i = P_RandomKey(numchoices); // Gotta love those random numbers!
- newmobj = P_SpawnMobj(mobj->x, mobj->y, mobj->z, spawnchance[i]);
- }
- else
- newmobj = P_SpawnMobj(mobj->x, mobj->y, mobj->z, mobj->type);
+ if (mobj->flags & MF_NOTHINK)
+ return;
- // Transfer flags2 (ambush, strongbox, objectflip)
- newmobj->flags2 = mobj->flags2;
- P_RemoveMobj(mobj); // make sure they disappear
- return;
- }
- else switch (mobj->type)
- {
- // gargoyle and snowman handled in P_PushableThinker, not here
- case MT_THROWNGRENADE:
- case MT_CYBRAKDEMON_NAPALM_BOMB_LARGE:
- P_SetMobjState(mobj, mobj->info->deathstate);
- break;
- case MT_LHRT:
- P_KillMobj(mobj, NULL, NULL, 0);
- break;
- case MT_BLUEFLAG:
- case MT_REDFLAG:
- if (mobj->spawnpoint)
- {
- x = mobj->spawnpoint->x << FRACBITS;
- y = mobj->spawnpoint->y << FRACBITS;
- ss = R_PointInSubsector(x, y);
- if (mobj->spawnpoint->options & MTF_OBJECTFLIP)
- {
- z = ss->sector->ceilingheight - mobjinfo[mobj->type].height;
- if (mobj->spawnpoint->options >> ZSHIFT)
- z -= (mobj->spawnpoint->options >> ZSHIFT) << FRACBITS;
- }
- else
- {
- z = ss->sector->floorheight;
- if (mobj->spawnpoint->options >> ZSHIFT)
- z += (mobj->spawnpoint->options >> ZSHIFT) << FRACBITS;
- }
- flagmo = P_SpawnMobj(x, y, z, mobj->type);
- flagmo->spawnpoint = mobj->spawnpoint;
- if (mobj->spawnpoint->options & MTF_OBJECTFLIP)
- {
- flagmo->eflags |= MFE_VERTICALFLIP;
- flagmo->flags2 |= MF2_OBJECTFLIP;
- }
+ if ((mobj->flags & MF_BOSS) && mobj->spawnpoint && (bossdisabled & (1<<mobj->spawnpoint->extrainfo)))
+ return;
- if (mobj->type == MT_REDFLAG)
- {
- if (!(mobj->flags2 & MF2_JUSTATTACKED))
- CONS_Printf(M_GetText("The %c%s%c has returned to base.\n"), 0x85, M_GetText("Red flag"), 0x80);
+ // Remove dead target/tracer.
+ if (mobj->target && P_MobjWasRemoved(mobj->target))
+ P_SetTarget(&mobj->target, NULL);
+ if (mobj->tracer && P_MobjWasRemoved(mobj->tracer))
+ P_SetTarget(&mobj->tracer, NULL);
+ if (mobj->hnext && P_MobjWasRemoved(mobj->hnext))
+ P_SetTarget(&mobj->hnext, NULL);
+ if (mobj->hprev && P_MobjWasRemoved(mobj->hprev))
+ P_SetTarget(&mobj->hprev, NULL);
- // Assumedly in splitscreen players will be on opposing teams
- if (players[consoleplayer].ctfteam == 1 || splitscreen)
- S_StartSound(NULL, sfx_hoop1);
- else if (players[consoleplayer].ctfteam == 2)
- S_StartSound(NULL, sfx_hoop3);
+ mobj->eflags &= ~(MFE_PUSHED|MFE_SPRUNG);
- redflag = flagmo;
- }
- else // MT_BLUEFLAG
- {
- if (!(mobj->flags2 & MF2_JUSTATTACKED))
- CONS_Printf(M_GetText("The %c%s%c has returned to base.\n"), 0x84, M_GetText("Blue flag"), 0x80);
+ tmfloorthing = tmhitthing = NULL;
- // Assumedly in splitscreen players will be on opposing teams
- if (players[consoleplayer].ctfteam == 2 || splitscreen)
- S_StartSound(NULL, sfx_hoop1);
- else if (players[consoleplayer].ctfteam == 1)
- S_StartSound(NULL, sfx_hoop3);
+ // Sector special (2,8) allows ANY mobj to trigger a linedef exec
+ if (mobj->subsector && GETSECSPECIAL(mobj->subsector->sector->special, 2) == 8)
+ {
+ sector_t *sec2;
- blueflag = flagmo;
- }
- }
- P_RemoveMobj(mobj);
- return;
- case MT_FANG:
- if (mobj->flags2 & MF2_SLIDEPUSH)
- {
- var1 = 0;
- var2 = 0;
- A_BossDeath(mobj);
- return;
- }
- P_SetMobjState(mobj, mobj->state->nextstate);
- if (P_MobjWasRemoved(mobj))
- return;
- break;
- case MT_METALSONIC_BATTLE:
- break; // don't remove
- case MT_SPIKE:
- P_SetMobjState(mobj, mobj->state->nextstate);
- mobj->fuse = mobj->info->speed;
- if (mobj->spawnpoint)
- mobj->fuse += mobj->spawnpoint->angle;
- break;
- case MT_WALLSPIKE:
- P_SetMobjState(mobj, mobj->state->nextstate);
- mobj->fuse = mobj->info->speed;
- if (mobj->spawnpoint)
- mobj->fuse += (mobj->spawnpoint->angle/360);
- break;
- 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;
+ sec2 = P_ThingOnSpecial3DFloor(mobj);
+ if (sec2 && GETSECSPECIAL(sec2->special, 2) == 1)
+ P_LinedefExecute(sec2->tag, mobj, sec2);
+ }
- 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:
- P_SetMobjState(mobj, mobj->info->xdeathstate); // will remove the mobj if S_NULL.
- break;
- // Looking for monitors? They moved to a special condition above.
- }
- if (P_MobjWasRemoved(mobj))
- return;
+ if (mobj->scale != mobj->destscale)
+ P_MobjScaleThink(mobj); // Slowly scale up/down to reach your destscale.
+
+ if ((mobj->type == MT_GHOST || mobj->type == MT_THOK) && mobj->fuse > 0) // Not guaranteed to be MF_SCENERY or not MF_SCENERY!
+ {
+ if (mobj->flags2 & MF2_BOSSNOTRAP) // "fast" flag
+ {
+ if ((signed)((mobj->frame & FF_TRANSMASK) >> FF_TRANSSHIFT) < (NUMTRANSMAPS-1) - (2*mobj->fuse)/3)
+ // fade out when nearing the end of fuse...
+ mobj->frame = (mobj->frame & ~FF_TRANSMASK) | (((NUMTRANSMAPS-1) - (2*mobj->fuse)/3) << FF_TRANSSHIFT);
}
+ else
+ {
+ if ((signed)((mobj->frame & FF_TRANSMASK) >> FF_TRANSSHIFT) < (NUMTRANSMAPS-1) - mobj->fuse / 2)
+ // fade out when nearing the end of fuse...
+ mobj->frame = (mobj->frame & ~FF_TRANSMASK) | (((NUMTRANSMAPS-1) - mobj->fuse / 2) << FF_TRANSSHIFT);
+ }
+ }
+
+ // Special thinker for scenery objects
+ if (mobj->flags & MF_SCENERY)
+ {
+ P_MobjSceneryThink(mobj);
+ return;
+ }
+
+#ifdef HAVE_BLUA
+ // Check for a Lua thinker first
+ if (!mobj->player)
+ {
+ if (LUAh_MobjThinker(mobj) || P_MobjWasRemoved(mobj))
+ return;
+ }
+ else if (!mobj->player->spectator)
+ {
+ // You cannot short-circuit the player thinker like you can other thinkers.
+ LUAh_MobjThinker(mobj);
+ if (P_MobjWasRemoved(mobj))
+ return;
+ }
+#endif
+ // if it's pushable, or if it would be pushable other than temporary disablement, use the
+ // separate thinker
+ if (mobj->flags & MF_PUSHABLE || (mobj->info->flags & MF_PUSHABLE && mobj->fuse))
+ {
+ if (!P_MobjPushableThink(mobj))
+ return;
+ }
+ else if (mobj->flags & MF_BOSS)
+ {
+ if (!P_MobjBossThink(mobj))
+ return;
+ }
+ else if (mobj->health <= 0) // Dead things think differently than the living.
+ {
+ if (!P_MobjDeadThink(mobj))
+ return;
+ }
+ else
+ {
+ if (!P_MobjRegularThink(mobj))
+ return;
+ }
+ if (P_MobjWasRemoved(mobj))
+ return;
+
+ if (mobj->flags2 & MF2_FIRING)
+ P_FiringThink(mobj);
+
+ if (mobj->flags & MF_AMBIENT)
+ {
+ if (!(leveltime % mobj->health) && mobj->info->seesound)
+ S_StartSound(mobj, mobj->info->seesound);
+ return;
}
+ // Check fuse
+ if (mobj->fuse && !P_FuseThink(mobj))
+ return;
+
I_Assert(mobj != NULL);
I_Assert(!P_MobjWasRemoved(mobj));
@@ -11120,14 +11264,24 @@ void P_PrecipitationEffects(void)
}
}
+/** Returns corresponding mobj type from mapthing number.
+ * \param mthingtype Mapthing number in question.
+ * \return Mobj type; MT_UNKNOWN if nothing found.
+ */
+static mobjtype_t P_GetMobjtype(UINT16 mthingtype)
+{
+ mobjtype_t i;
+ for (i = 0; i < NUMMOBJTYPES; i++)
+ if (mthingtype == mobjinfo[i].doomednum)
+ return i;
+ return MT_UNKNOWN;
+}
+
//
// P_RespawnSpecials
//
void P_RespawnSpecials(void)
{
- fixed_t x, y, z;
- subsector_t *ss;
- mobj_t *mo = NULL;
mapthing_t *mthing = NULL;
// only respawn items when cv_itemrespawn is on
@@ -11157,68 +11311,8 @@ void P_RespawnSpecials(void)
#endif
if (mthing)
- {
- mobjtype_t i;
- x = mthing->x << FRACBITS;
- y = mthing->y << FRACBITS;
- ss = R_PointInSubsector(x, y);
-
- // find which type to spawn
- for (i = 0; i < NUMMOBJTYPES; i++)
- if (mthing->type == mobjinfo[i].doomednum)
- break;
-
- if (i == NUMMOBJTYPES) // prevent creation of objects with this type -- Monster Iestyn 17/12/17
- {
- // 3D Mode start Thing is unlikely to be added to the que,
- // so don't bother checking for that specific type
- CONS_Alert(CONS_WARNING, M_GetText("P_RespawnSpecials: Unknown thing type %d attempted to respawn at (%d, %d)\n"), mthing->type, mthing->x, mthing->y);
- // pull it from the que
- iquetail = (iquetail+1)&(ITEMQUESIZE-1);
- return;
- }
-
- //CTF rings should continue to respawn as normal rings outside of CTF.
- if (gametype != GT_CTF)
- {
- if (i == MT_REDTEAMRING || i == MT_BLUETEAMRING)
- i = MT_RING;
- }
-
- if (mthing->options & MTF_OBJECTFLIP)
- {
- z = (
-#ifdef ESLOPE
- ss->sector->c_slope ? P_GetZAt(ss->sector->c_slope, x, y) :
-#endif
- ss->sector->ceilingheight) - (mthing->options >> ZSHIFT) * FRACUNIT;
- if (mthing->options & MTF_AMBUSH
- && (i == MT_RING || i == MT_REDTEAMRING || i == MT_BLUETEAMRING || i == MT_COIN || i == MT_NIGHTSSTAR || P_WeaponOrPanel(i)))
- z -= 24*FRACUNIT;
- z -= mobjinfo[i].height; // Don't forget the height!
- }
- else
- {
- z = (
-#ifdef ESLOPE
- ss->sector->f_slope ? P_GetZAt(ss->sector->f_slope, x, y) :
-#endif
- ss->sector->floorheight) + (mthing->options >> ZSHIFT) * FRACUNIT;
- if (mthing->options & MTF_AMBUSH
- && (i == MT_RING || i == MT_REDTEAMRING || i == MT_BLUETEAMRING || i == MT_COIN || i == MT_NIGHTSSTAR || P_WeaponOrPanel(i)))
- z += 24*FRACUNIT;
- }
-
- mo = P_SpawnMobj(x, y, z, i);
- mo->spawnpoint = mthing;
- mo->angle = ANGLE_45 * (mthing->angle/45);
+ P_SpawnMapThing(mthing);
- if (mthing->options & MTF_OBJECTFLIP)
- {
- mo->eflags |= MFE_VERTICALFLIP;
- mo->flags2 |= MF2_OBJECTFLIP;
- }
- }
// pull it from the que
iquetail = (iquetail+1)&(ITEMQUESIZE-1);
}
@@ -11250,7 +11344,10 @@ void P_SpawnPlayer(INT32 playernum)
{
p->outofcoop = false;
if (netgame && p->jointime < 1)
- p->spectator = true;
+ {
+ // Averted by GTR_NOSPECTATORSPAWN.
+ p->spectator = (gametyperules & GTR_NOSPECTATORSPAWN) ? false : true;
+ }
else if (multiplayer && !netgame)
{
// If you're in a team game and you don't have a team assigned yet...
@@ -11293,7 +11390,7 @@ void P_SpawnPlayer(INT32 playernum)
p->skincolor = skincolor_blueteam;
}
- if ((netgame || multiplayer) && (gametype != GT_COOP || leveltime) && !p->spectator && !(maptol & TOL_NIGHTS))
+ if ((netgame || multiplayer) && ((gametyperules & GTR_SPAWNINVUL) || leveltime) && !p->spectator && !(maptol & TOL_NIGHTS))
p->powers[pw_flashing] = flashingtics-1; // Babysitting deterrent
mobj = P_SpawnMobj(0, 0, 0, MT_PLAYER);
@@ -11401,7 +11498,7 @@ void P_MovePlayerToSpawn(INT32 playernum, mapthing_t *mthing)
fixed_t z;
sector_t *sector;
- fixed_t floor, ceiling;
+ fixed_t floor, ceiling, ceilingspawn;
player_t *p = &players[playernum];
mobj_t *mobj = p->mo;
@@ -11428,23 +11525,18 @@ void P_MovePlayerToSpawn(INT32 playernum, mapthing_t *mthing)
sector->c_slope ? P_GetZAt(sector->c_slope, x, y) :
#endif
sector->ceilingheight;
+ ceilingspawn = ceiling - mobjinfo[MT_PLAYER].height;
if (mthing)
{
+ fixed_t offset = mthing->z << FRACBITS;
+
// Flagging a player's ambush will make them start on the ceiling
// Objectflip inverts
if (!!(mthing->options & MTF_AMBUSH) ^ !!(mthing->options & MTF_OBJECTFLIP))
- {
- z = ceiling - mobjinfo[MT_PLAYER].height;
- if (mthing->options >> ZSHIFT)
- z -= ((mthing->options >> ZSHIFT) << FRACBITS);
- }
+ z = ceilingspawn - offset;
else
- {
- z = floor;
- if (mthing->options >> ZSHIFT)
- z += ((mthing->options >> ZSHIFT) << FRACBITS);
- }
+ z = floor + offset;
if (mthing->options & MTF_OBJECTFLIP) // flip the player!
{
@@ -11461,8 +11553,8 @@ void P_MovePlayerToSpawn(INT32 playernum, mapthing_t *mthing)
if (z < floor)
z = floor;
- else if (z > ceiling - mobjinfo[MT_PLAYER].height)
- z = ceiling - mobjinfo[MT_PLAYER].height;
+ else if (z > ceilingspawn)
+ z = ceilingspawn;
mobj->floorz = floor;
mobj->ceilingz = ceiling;
@@ -11550,442 +11642,980 @@ void P_MovePlayerToStarpost(INT32 playernum)
mapthing_t *huntemeralds[MAXHUNTEMERALDS];
INT32 numhuntemeralds;
-//
-// P_SpawnMapThing
-// The fields of the mapthing should
-// already be in host byte order.
-//
-void P_SpawnMapThing(mapthing_t *mthing)
+static fixed_t P_GetMobjSpawnHeight(const mobjtype_t mobjtype, const fixed_t x, const fixed_t y, const fixed_t offset, const boolean flip)
{
- mobjtype_t i;
- mobj_t *mobj;
- fixed_t x, y, z;
- subsector_t *ss;
- boolean doangle = true;
+ const subsector_t *ss = R_PointInSubsector(x, y);
+
+ // Axis objects snap to the floor.
+ if (mobjtype == MT_AXIS || mobjtype == MT_AXISTRANSFER || mobjtype == MT_AXISTRANSFERLINE)
+ return ONFLOORZ;
+
+ // Establish height.
+ if (flip)
+ return (
+#ifdef ESLOPE
+ ss->sector->c_slope ? P_GetZAt(ss->sector->c_slope, x, y) :
+#endif
+ ss->sector->ceilingheight) - offset - mobjinfo[mobjtype].height;
+ else
+ return (
+#ifdef ESLOPE
+ ss->sector->f_slope ? P_GetZAt(ss->sector->f_slope, x, y) :
+#endif
+ ss->sector->floorheight) + offset;
+}
+
+static fixed_t P_GetMapThingSpawnHeight(const mobjtype_t mobjtype, const mapthing_t* mthing, const fixed_t x, const fixed_t y)
+{
+ fixed_t offset = mthing->z << FRACBITS;
+ boolean flip = (!!(mobjinfo[mobjtype].flags & MF_SPAWNCEILING) ^ !!(mthing->options & MTF_OBJECTFLIP));
+
+ switch (mobjtype)
+ {
+ // Bumpers never spawn flipped.
+ case MT_NIGHTSBUMPER:
+ flip = false;
+ break;
+
+ // Objects with a non-zero default height.
+ case MT_CRAWLACOMMANDER:
+ case MT_DETON:
+ case MT_JETTBOMBER:
+ case MT_JETTGUNNER:
+ case MT_EGGMOBILE2:
+ if (!offset)
+ offset = 33*FRACUNIT;
+ break;
+ case MT_EGGMOBILE:
+ if (!offset)
+ offset = 128*FRACUNIT;
+ break;
+ case MT_GOLDBUZZ:
+ case MT_REDBUZZ:
+ if (!offset)
+ offset = 288*FRACUNIT;
+ break;
+
+ // Horizontal springs, may float additional units with MTF_AMBUSH.
+ case MT_YELLOWHORIZ:
+ case MT_REDHORIZ:
+ case MT_BLUEHORIZ:
+ offset += mthing->options & MTF_AMBUSH ? 16*FRACUNIT : 0;
+ break;
+
+ // Ring-like items, may float additional units with MTF_AMBUSH.
+ case MT_SPIKEBALL:
+ case MT_EMERALDSPAWN:
+ case MT_TOKEN:
+ case MT_EMBLEM:
+ case MT_RING:
+ case MT_REDTEAMRING:
+ case MT_BLUETEAMRING:
+ case MT_COIN:
+ case MT_BLUESPHERE:
+ case MT_BOMBSPHERE:
+ case MT_NIGHTSCHIP:
+ case MT_NIGHTSSTAR:
+ offset += mthing->options & MTF_AMBUSH ? 24*FRACUNIT : 0;
+ break;
+
+ // Remaining objects.
+ default:
+ if (P_WeaponOrPanel(mobjtype))
+ offset += mthing->options & MTF_AMBUSH ? 24*FRACUNIT : 0;
+ }
+
+ if (!offset) // Snap to the surfaces when there's no offset set.
+ {
+ if (flip)
+ return ONCEILINGZ;
+ else
+ return ONFLOORZ;
+ }
+
+ return P_GetMobjSpawnHeight(mobjtype, x, y, offset, flip);
+}
+
+static boolean P_SpawnNonMobjMapThing(mapthing_t *mthing)
+{
+#if MAXPLAYERS > 32
+ You should think about modifying the deathmatch starts to take full advantage of this!
+#endif
+ if (mthing->type <= MAXPLAYERS) // Player starts
+ {
+ // save spots for respawning in network games
+ if (!metalrecording)
+ playerstarts[mthing->type - 1] = mthing;
+ return true;
+ }
+ else if (mthing->type == 33) // Match starts
+ {
+ if (numdmstarts < MAX_DM_STARTS)
+ {
+ deathmatchstarts[numdmstarts] = mthing;
+ mthing->type = 0;
+ numdmstarts++;
+ }
+ return true;
+ }
+ else if (mthing->type == 34) // Red CTF starts
+ {
+ if (numredctfstarts < MAXPLAYERS)
+ {
+ redctfstarts[numredctfstarts] = mthing;
+ mthing->type = 0;
+ numredctfstarts++;
+ }
+ return true;
+ }
+ else if (mthing->type == 35) // Blue CTF starts
+ {
+ if (numbluectfstarts < MAXPLAYERS)
+ {
+ bluectfstarts[numbluectfstarts] = mthing;
+ mthing->type = 0;
+ numbluectfstarts++;
+ }
+ return true;
+ }
+ else if (metalrecording && mthing->type == mobjinfo[MT_METALSONIC_RACE].doomednum)
+ { // If recording, you ARE Metal Sonic. Do not spawn it, do not save normal spawnpoints.
+ playerstarts[0] = mthing;
+ return true;
+ }
+ else if (mthing->type == 750 // Slope vertex point (formerly chaos spawn)
+ || (mthing->type >= 600 && mthing->type <= 609) // Special placement patterns
+ || mthing->type == 1705 || mthing->type == 1713) // Hoops
+ return true; // These are handled elsewhere.
+ else if (mthing->type == mobjinfo[MT_EMERHUNT].doomednum)
+ {
+ // Emerald Hunt is Coop only. Don't spawn the emerald yet, but save the spawnpoint for later.
+ if ((gametyperules & GTR_EMERALDHUNT) && numhuntemeralds < MAXHUNTEMERALDS)
+ huntemeralds[numhuntemeralds++] = mthing;
+ return true;
+ }
+
+ return false;
+}
+
+static boolean P_AllowMobjSpawn(mapthing_t* mthing, mobjtype_t i)
+{
+ switch (i)
+ {
+ case MT_EMERALD1:
+ case MT_EMERALD2:
+ case MT_EMERALD3:
+ case MT_EMERALD4:
+ case MT_EMERALD5:
+ case MT_EMERALD6:
+ case MT_EMERALD7:
+ if (gametype != GT_COOP) // Don't place emeralds in non-coop modes
+ return false;
+
+ if (metalrecording)
+ return false; // Metal Sonic isn't for collecting emeralds.
+
+ if (emeralds & mobjinfo[i].speed) // You already have this emerald!
+ return false;
+
+ break;
+ case MT_EMERALDSPAWN:
+ if (!cv_powerstones.value)
+ return false;
+
+ if (!(gametyperules & GTR_MATCHEMERALDS))
+ return false;
+
+ runemeraldmanager = true;
+ break;
+ case MT_ROSY:
+ if (!(gametype == GT_COOP || (mthing->options & MTF_EXTRA)))
+ return false; // she doesn't hang out here
+
+ if (!mariomode && !(netgame || multiplayer) && players[consoleplayer].skin == 3)
+ return false; // no doubles
+
+ break;
+ case MT_TOKEN:
+ if (!(gametyperules & GTR_EMERALDTOKENS))
+ return false; // Gametype's not right
+
+ if (tokenbits == 30)
+ return false; // Too many tokens
+
+ if (tokenlist & (1 << tokenbits++))
+ return false; // You already got this token
+
+ break;
+ case MT_EMBLEM:
+ if (netgame || multiplayer)
+ return false; // Single player
+
+ if (modifiedgame && !savemoddata)
+ return false; // No cheating!!
+
+ break;
+ default:
+ break;
+ }
+
+ if (metalrecording) // Metal Sonic can't use these things.
+ {
+ if ((mobjinfo[i].flags & (MF_ENEMY|MF_BOSS)) || i == MT_TOKEN || i == MT_STARPOST
+ || i == MT_RING || i == MT_BLUETEAMRING || i == MT_REDTEAMRING || i == MT_COIN
+ || i == MT_BLUESPHERE || i == MT_BOMBSPHERE || i == MT_NIGHTSCHIP || i == MT_NIGHTSSTAR)
+ return false;
+ }
+
+ if (((mobjinfo[i].flags & MF_ENEMY) || (mobjinfo[i].flags & MF_BOSS)) && !(gametyperules & GTR_SPAWNENEMIES))
+ return false; // No enemies in ringslinger modes
+
+ if (!(gametyperules & GTR_ALLOWEXIT) && (i == MT_SIGN))
+ return false; // Don't spawn exit signs in wrong game modes
+
+ if (!G_PlatformGametype() && (i == MT_STARPOST))
+ return false; // Don't spawn starposts in wrong game modes
+
+ if (!G_RingSlingerGametype() || !cv_specialrings.value)
+ if (P_WeaponOrPanel(i))
+ return false; // Don't place weapons/panels in non-ringslinger modes
+
+ if (!(gametyperules & GTR_TEAMFLAGS)) // CTF specific things
+ {
+ if (i == MT_BLUEFLAG || i == MT_REDFLAG)
+ return false; // No flags in non-CTF modes!
+ }
+ else
+ {
+ if ((i == MT_BLUEFLAG && blueflag) || (i == MT_REDFLAG && redflag))
+ {
+ CONS_Alert(CONS_ERROR, M_GetText("Only one flag per team allowed in CTF!\n"));
+ return false;
+ }
+ }
+
+ if (modeattacking) // Record Attack special stuff
+ {
+ // Don't spawn starposts that wouldn't be usable
+ if (i == MT_STARPOST)
+ return false;
+ }
+
+ if (ultimatemode)
+ {
+ if (i == MT_RING || i == MT_REDTEAMRING || i == MT_BLUETEAMRING
+ || i == MT_COIN || i == MT_NIGHTSSTAR || i == MT_NIGHTSCHIP
+ || i == MT_PITY_BOX || i == MT_ELEMENTAL_BOX || i == MT_ATTRACT_BOX
+ || i == MT_FORCE_BOX || i == MT_ARMAGEDDON_BOX || i == MT_WHIRLWIND_BOX
+ || i == MT_FLAMEAURA_BOX || i == MT_BUBBLEWRAP_BOX || i == MT_THUNDERCOIN_BOX
+ || i == MT_RING_BOX || i == MT_STARPOST)
+ return false; // No rings or shields in Ultimate mode
+
+ // Don't include the gold repeating boxes here please.
+ // They're likely facets of the level's design and therefore required to progress.
+ }
+
+ return true;
+}
+
+#define nightsreplace ((maptol & TOL_NIGHTS) && !G_IsSpecialStage(gamemap))
+
+static mobjtype_t P_GetMobjtypeSubstitute(mapthing_t *mthing, mobjtype_t i)
+{
+ // Altering monitor spawns via cvars
+ // If MF_GRENADEBOUNCE is set in the monitor's info,
+ // skip this step. (Used for gold monitors)
+ // Yeah, this is a dirty hack.
+ if ((mobjinfo[i].flags & (MF_MONITOR|MF_GRENADEBOUNCE)) == MF_MONITOR)
+ {
+ if (gametyperules & GTR_RACE)
+ {
+ // Set powerup boxes to user settings for competition.
+ switch (cv_competitionboxes.value)
+ {
+ case 1: // Mystery
+ return MT_MYSTERY_BOX;
+ case 2: // Teleport
+ return MT_MIXUP_BOX;
+ case 3: // None
+ return MT_NULL; // Don't spawn!
+ default:
+ return i;
+ }
+ }
+ // Set powerup boxes to user settings for other netplay modes
+ else if (gametype != GT_COOP)
+ {
+ switch (cv_matchboxes.value)
+ {
+ case 1: // Mystery
+ return MT_MYSTERY_BOX;
+ case 2: // Unchanging
+ if (i == MT_MYSTERY_BOX)
+ return MT_NULL; // don't spawn
+ mthing->options &= ~(MTF_AMBUSH|MTF_OBJECTSPECIAL); // no random respawning!
+ return i;
+ case 3: // Don't spawn
+ return MT_NULL;
+ default:
+ return i;
+ }
+ }
+ }
- if (!mthing->type)
- return; // Ignore type-0 things as NOPs
+ if (nightsreplace)
+ {
+ if (i == MT_RING || i == MT_REDTEAMRING || i == MT_BLUETEAMRING || i == MT_COIN)
+ return MT_NIGHTSSTAR;
+
+ if (i == MT_BLUESPHERE)
+ return MT_NIGHTSCHIP;
+ }
- // Always spawn in objectplace.
- // Skip all returning code.
- if (objectplacing)
+ if (!(gametyperules & GTR_TEAMS))
{
- // find which type to spawn
- for (i = 0; i < NUMMOBJTYPES; i++)
- if (mthing->type == mobjinfo[i].doomednum)
- break;
+ if (i == MT_BLUETEAMRING || i == MT_REDTEAMRING)
+ return MT_RING;
- if (i == NUMMOBJTYPES)
- {
- if (mthing->type == 3328) // 3D Mode start Thing
- return;
- CONS_Alert(CONS_WARNING, M_GetText("Unknown thing type %d placed at (%d, %d)\n"), mthing->type, mthing->x, mthing->y);
- i = MT_UNKNOWN;
- }
- goto noreturns;
+ if (i == MT_RING_BLUEBOX || i == MT_RING_REDBOX)
+ return MT_RING_BOX;
}
- // count deathmatch start positions
- if (mthing->type == 33)
+ if (modeattacking && i == MT_1UP_BOX) // 1UPs -->> Score TVs
{
- if (numdmstarts < MAX_DM_STARTS)
- {
- deathmatchstarts[numdmstarts] = mthing;
- mthing->type = 0;
- numdmstarts++;
- }
- return;
+ // Either or, doesn't matter which.
+ if (mthing->options & (MTF_AMBUSH | MTF_OBJECTSPECIAL))
+ return MT_SCORE10K_BOX; // 10,000
+ else
+ return MT_SCORE1K_BOX; // 1,000
}
- else if (mthing->type == 34) // Red CTF Starts
+ if (mariomode && i == MT_ROSY)
+ return MT_TOAD; // don't remove on penalty of death
+
+ return i;
+}
+
+static boolean P_SetupEmblem(mapthing_t *mthing, mobj_t *mobj)
+{
+ INT32 j;
+ emblem_t* emblem = M_GetLevelEmblems(gamemap);
+ skincolors_t emcolor;
+
+ while (emblem)
{
- if (numredctfstarts < MAXPLAYERS)
- {
- redctfstarts[numredctfstarts] = mthing;
- mthing->type = 0;
- numredctfstarts++;
- }
- return;
+ if ((emblem->type == ET_GLOBAL || emblem->type == ET_SKIN) && emblem->tag == mthing->angle)
+ break;
+
+ emblem = M_GetLevelEmblems(-1);
}
- else if (mthing->type == 35) // Blue CTF Starts
+ if (!emblem)
{
- if (numbluectfstarts < MAXPLAYERS)
- {
- bluectfstarts[numbluectfstarts] = mthing;
- mthing->type = 0;
- numbluectfstarts++;
- }
- return;
+ CONS_Debug(DBG_GAMELOGIC, "No map emblem for map %d with tag %d found!\n", gamemap, mthing->angle);
+ return false;
}
- else if (mthing->type == 750) // Slope vertex point (formerly chaos spawn)
- return;
+ j = emblem - emblemlocations;
+
+ I_Assert(emblemlocations[j].sprite >= 'A' && emblemlocations[j].sprite <= 'Z');
+ P_SetMobjState(mobj, mobj->info->spawnstate + (emblemlocations[j].sprite - 'A'));
- else if (mthing->type == mobjinfo[MT_RING].doomednum || mthing->type == mobjinfo[MT_COIN].doomednum
- || mthing->type == mobjinfo[MT_REDTEAMRING].doomednum || mthing->type == mobjinfo[MT_BLUETEAMRING].doomednum
- || mthing->type == mobjinfo[MT_BLUESPHERE].doomednum || mthing->type == mobjinfo[MT_BOMBSPHERE].doomednum
- || (mthing->type >= 600 && mthing->type <= 609) // circles and diagonals
- || mthing->type == 1705 || mthing->type == 1713) // hoops
+ mobj->health = j + 1;
+ emcolor = M_GetEmblemColor(&emblemlocations[j]); // workaround for compiler complaint about bad function casting
+ mobj->color = (UINT8)emcolor;
+
+ if (emblemlocations[j].collected
+ || (emblemlocations[j].type == ET_SKIN && emblemlocations[j].var != players[0].skin))
{
- // Don't spawn hoops, wings, or rings yet!
- return;
+ P_UnsetThingPosition(mobj);
+ mobj->flags |= MF_NOCLIP;
+ mobj->flags &= ~MF_SPECIAL;
+ mobj->flags |= MF_NOBLOCKMAP;
+ mobj->frame |= (tr_trans50 << FF_TRANSSHIFT);
+ P_SetThingPosition(mobj);
}
-
- // check for players specially
-#if MAXPLAYERS > 32
-You should think about modifying the deathmatch starts to take full advantage of this!
-#endif
- if (mthing->type > 0 && mthing->type <= MAXPLAYERS)
+ else
{
- // save spots for respawning in network games
- if (!metalrecording)
- playerstarts[mthing->type-1] = mthing;
- return;
+ mobj->frame &= ~FF_TRANSMASK;
+
+ if (emblemlocations[j].type == ET_GLOBAL)
+ {
+ mobj->reactiontime = emblemlocations[j].var;
+ if (emblemlocations[j].var & GE_NIGHTSITEM)
+ {
+ mobj->flags |= MF_NIGHTSITEM;
+ mobj->flags &= ~MF_SPECIAL;
+ mobj->flags2 |= MF2_DONTDRAW;
+ }
+ }
}
+ return true;
+}
- if (metalrecording && mthing->type == mobjinfo[MT_METALSONIC_RACE].doomednum)
- { // If recording, you ARE Metal Sonic. Do not spawn it, do not save normal spawnpoints.
- playerstarts[0] = mthing;
- return;
+static boolean P_SetupMace(mapthing_t *mthing, mobj_t *mobj, boolean *doangle)
+{
+ fixed_t mlength, mmaxlength, mlengthset, mspeed, mphase, myaw, mpitch, mminlength, mnumspokes, mpinch, mroll, mnumnospokes, mwidth, mwidthset, mmin, msound, radiusfactor, widthfactor;
+ angle_t mspokeangle;
+ mobjtype_t chainlink, macetype, firsttype, linktype;
+ boolean mdosound, mdocenter, mchainlike = false;
+ mobj_t *spawnee = NULL, *hprev = mobj;
+ mobjflag_t mflagsapply;
+ mobjflag2_t mflags2apply;
+ mobjeflag_t meflagsapply;
+ INT32 line;
+ const size_t mthingi = (size_t)(mthing - mapthings);
+
+ // Find the corresponding linedef special, using angle as tag
+ // P_FindSpecialLineFromTag works here now =D
+ line = P_FindSpecialLineFromTag(9, mthing->angle, -1);
+
+ if (line == -1)
+ {
+ CONS_Debug(DBG_GAMELOGIC, "Mace chain (mapthing #%s) needs to be tagged to a #9 parameter line (trying to find tag %d).\n", sizeu1(mthingi), mthing->angle);
+ return false;
+ }
+ /*
+ mapthing -
+ MTF_AMBUSH :
+ MT_SPRINGBALLPOINT - upgrade from yellow to red spring
+ anything else - bigger mace/chain theory
+ MTF_OBJECTSPECIAL - force silent
+ MTF_GRAVFLIP - flips objects, doesn't affect chain arrangements
+ Parameter value : number of "spokes"
+
+ linedef -
+ ML_NOCLIMB :
+ MT_CHAINPOINT/MT_CHAINMACEPOINT with ML_EFFECT1 applied - Direction not controllable
+ anything else - no functionality
+ ML_EFFECT1 : Swings instead of spins
+ ML_EFFECT2 : Linktype is replaced with macetype for all spokes not ending in chains (inverted for MT_FIREBARPOINT)
+ ML_EFFECT3 : Spawn a bonus linktype at the hinge point
+ ML_EFFECT4 : Don't clip inside the ground
+ ML_EFFECT5 : Don't stop thinking when too far away
+ */
+ mlength = abs(lines[line].dx >> FRACBITS);
+ mspeed = abs(lines[line].dy >> (FRACBITS - 4));
+ mphase = (sides[lines[line].sidenum[0]].textureoffset >> FRACBITS) % 360;
+ if ((mminlength = -sides[lines[line].sidenum[0]].rowoffset >> FRACBITS) < 0)
+ mminlength = 0;
+ else if (mminlength > mlength - 1)
+ mminlength = mlength - 1;
+ mpitch = (lines[line].frontsector->floorheight >> FRACBITS) % 360;
+ myaw = (lines[line].frontsector->ceilingheight >> FRACBITS) % 360;
+
+ mnumspokes = mthing->extrainfo + 1;
+ mspokeangle = FixedAngle((360*FRACUNIT)/mnumspokes) >> ANGLETOFINESHIFT;
+
+ if (lines[line].backsector)
+ {
+ mpinch = (lines[line].backsector->floorheight >> FRACBITS) % 360;
+ mroll = (lines[line].backsector->ceilingheight >> FRACBITS) % 360;
+ mnumnospokes = (sides[lines[line].sidenum[1]].textureoffset >> FRACBITS);
+ if ((mwidth = sides[lines[line].sidenum[1]].rowoffset >> FRACBITS) < 0)
+ mwidth = 0;
}
+ else
+ mpinch = mroll = mnumnospokes = mwidth = 0;
+
+ CONS_Debug(DBG_GAMELOGIC, "Mace/Chain (mapthing #%s):\n"
+ "Length is %d (minus %d)\n"
+ "Speed is %d\n"
+ "Phase is %d\n"
+ "Yaw is %d\n"
+ "Pitch is %d\n"
+ "No. of spokes is %d (%d antispokes)\n"
+ "Pinch is %d\n"
+ "Roll is %d\n"
+ "Width is %d\n",
+ sizeu1(mthingi), mlength, mminlength, mspeed, mphase, myaw, mpitch, mnumspokes, mnumnospokes, mpinch, mroll, mwidth);
+
+ if (mnumnospokes > 0 && (mnumnospokes < mnumspokes))
+ mnumnospokes = mnumspokes/mnumnospokes;
+ else
+ mnumnospokes = ((mobj->type == MT_CHAINMACEPOINT) ? (mnumspokes) : 0);
- // find which type to spawn
- for (i = 0; i < NUMMOBJTYPES; i++)
- if (mthing->type == mobjinfo[i].doomednum)
- break;
+ mobj->lastlook = mspeed;
+ mobj->movecount = mobj->lastlook;
+ mobj->angle = FixedAngle(myaw << FRACBITS);
+ *doangle = false;
+ mobj->threshold = (FixedAngle(mpitch << FRACBITS) >> ANGLETOFINESHIFT);
+ mobj->movefactor = mpinch;
+ mobj->movedir = 0;
- if (i == NUMMOBJTYPES)
+ // Mobjtype selection
+ switch (mobj->type)
{
- if (mthing->type == 3328) // 3D Mode start Thing
- return;
- CONS_Alert(CONS_WARNING, M_GetText("Unknown thing type %d placed at (%d, %d)\n"), mthing->type, mthing->x, mthing->y);
- i = MT_UNKNOWN;
+ case MT_SPRINGBALLPOINT:
+ macetype = ((mthing->options & MTF_AMBUSH)
+ ? MT_REDSPRINGBALL
+ : MT_YELLOWSPRINGBALL);
+ chainlink = MT_SMALLMACECHAIN;
+ break;
+ case MT_FIREBARPOINT:
+ macetype = ((mthing->options & MTF_AMBUSH)
+ ? MT_BIGFIREBAR
+ : MT_SMALLFIREBAR);
+ chainlink = MT_NULL;
+ break;
+ case MT_CUSTOMMACEPOINT:
+ macetype = (mobjtype_t)sides[lines[line].sidenum[0]].toptexture;
+ if (lines[line].backsector)
+ chainlink = (mobjtype_t)sides[lines[line].sidenum[1]].toptexture;
+ else
+ chainlink = MT_NULL;
+ break;
+ case MT_CHAINPOINT:
+ if (mthing->options & MTF_AMBUSH)
+ {
+ macetype = MT_BIGGRABCHAIN;
+ chainlink = MT_BIGMACECHAIN;
+ }
+ else
+ {
+ macetype = MT_SMALLGRABCHAIN;
+ chainlink = MT_SMALLMACECHAIN;
+ }
+ mchainlike = true;
+ break;
+ default:
+ if (mthing->options & MTF_AMBUSH)
+ {
+ macetype = MT_BIGMACE;
+ chainlink = MT_BIGMACECHAIN;
+ }
+ else
+ {
+ macetype = MT_SMALLMACE;
+ chainlink = MT_SMALLMACECHAIN;
+ }
+ break;
}
- if (metalrecording) // Metal Sonic can't use these things.
- if (mobjinfo[i].flags & (MF_ENEMY|MF_BOSS) || i == MT_TOKEN || i == MT_STARPOST)
- return;
+ if (!macetype && !chainlink)
+ return true;
- if (i >= MT_EMERALD1 && i <= MT_EMERALD7) // Pickupable Emeralds
+ if (mobj->type == MT_CHAINPOINT)
{
- if (gametype != GT_COOP) // Don't place emeralds in non-coop modes
- return;
+ if (!mlength)
+ return true;
+ }
+ else
+ mlength++;
- if (metalrecording)
- return; // Metal Sonic isn't for collecting emeralds.
+ firsttype = macetype;
- if (emeralds & mobjinfo[i].speed) // You already have this emerald!
- return;
- }
+ // Adjustable direction
+ if (lines[line].flags & ML_NOCLIMB)
+ mobj->flags |= MF_SLIDEME;
- if (i == MT_EMERHUNT)
+ // Swinging
+ if (lines[line].flags & ML_EFFECT1)
{
- // Emerald Hunt is Coop only.
- if (gametype != GT_COOP)
- return;
+ mobj->flags2 |= MF2_STRONGBOX;
+ mmin = ((mnumnospokes > 1) ? 1 : 0);
+ }
+ else
+ mmin = mnumspokes;
- ss = R_PointInSubsector(mthing->x << FRACBITS, mthing->y << FRACBITS);
- mthing->z = (INT16)(((
-#ifdef ESLOPE
- ss->sector->f_slope ? P_GetZAt(ss->sector->f_slope, mthing->x << FRACBITS, mthing->y << FRACBITS) :
-#endif
- ss->sector->floorheight)>>FRACBITS) + (mthing->options >> ZSHIFT));
+ // If over distance away, don't move UNLESS this flag is applied
+ if (lines[line].flags & ML_EFFECT5)
+ mobj->flags2 |= MF2_BOSSNOTRAP;
- if (numhuntemeralds < MAXHUNTEMERALDS)
- huntemeralds[numhuntemeralds++] = mthing;
- return;
+ // Make the links the same type as the end - repeated below
+ if ((mobj->type != MT_CHAINPOINT) && (((lines[line].flags & ML_EFFECT2) == ML_EFFECT2) != (mobj->type == MT_FIREBARPOINT))) // exclusive or
+ {
+ linktype = macetype;
+ radiusfactor = 2; // Double the radius.
}
+ else
+ radiusfactor = (((linktype = chainlink) == MT_NULL) ? 2 : 1);
- if (i == MT_EMERALDSPAWN)
- {
- if (!cv_powerstones.value)
- return;
+ if (!mchainlike)
+ mchainlike = (firsttype == chainlink);
+ widthfactor = (mchainlike ? 1 : 2);
- if (!(gametype == GT_MATCH || gametype == GT_CTF))
- return;
+ mflagsapply = ((lines[line].flags & ML_EFFECT4) ? 0 : (MF_NOCLIP | MF_NOCLIPHEIGHT));
+ mflags2apply = ((mthing->options & MTF_OBJECTFLIP) ? MF2_OBJECTFLIP : 0);
+ meflagsapply = ((mthing->options & MTF_OBJECTFLIP) ? MFE_VERTICALFLIP : 0);
- runemeraldmanager = true;
- }
+ msound = (mchainlike ? 0 : (mwidth & 1));
- if (!G_PlatformGametype()) // No enemies in match or CTF modes
- if ((mobjinfo[i].flags & MF_ENEMY) || (mobjinfo[i].flags & MF_BOSS))
- return;
+ // Quick and easy preparatory variable setting
+ mphase = (FixedAngle(mphase << FRACBITS) >> ANGLETOFINESHIFT);
+ mroll = (FixedAngle(mroll << FRACBITS) >> ANGLETOFINESHIFT);
- if (!G_RingSlingerGametype() || !cv_specialrings.value)
- if (P_WeaponOrPanel(i))
- return; // Don't place weapons/panels in non-ringslinger modes
+#define makemace(mobjtype, dist, moreflags2) {\
+ spawnee = P_SpawnMobj(mobj->x, mobj->y, mobj->z, mobjtype);\
+ P_SetTarget(&spawnee->tracer, mobj);\
+ spawnee->threshold = mphase;\
+ spawnee->friction = mroll;\
+ spawnee->movefactor = mwidthset;\
+ spawnee->movecount = dist;\
+ spawnee->angle = myaw;\
+ spawnee->flags |= (MF_NOGRAVITY|mflagsapply);\
+ spawnee->flags2 |= (mflags2apply|moreflags2);\
+ spawnee->eflags |= meflagsapply;\
+ P_SetTarget(&hprev->hnext, spawnee);\
+ P_SetTarget(&spawnee->hprev, hprev);\
+ hprev = spawnee;\
+}
- // Altering monitor spawns via cvars
- // If MF_GRENADEBOUNCE is set in the monitor's info,
- // skip this step. (Used for gold monitors)
- // Yeah, this is a dirty hack.
- if ((mobjinfo[i].flags & (MF_MONITOR|MF_GRENADEBOUNCE)) == MF_MONITOR)
+ mdosound = (mspeed && !(mthing->options & MTF_OBJECTSPECIAL));
+ mdocenter = (macetype && (lines[line].flags & ML_EFFECT3));
+
+ // The actual spawning of spokes
+ while (mnumspokes-- > 0)
{
- if (gametype == GT_COMPETITION || gametype == GT_RACE)
+ // Offsets
+ if (lines[line].flags & ML_EFFECT1) // Swinging
+ mroll = (mroll - mspokeangle) & FINEMASK;
+ else // Spinning
+ mphase = (mphase - mspokeangle) & FINEMASK;
+
+ if (mnumnospokes && !(mnumspokes % mnumnospokes)) // Skipping a "missing" spoke
{
- // Set powerup boxes to user settings for competition.
- if (cv_competitionboxes.value == 1) // Mystery
- i = MT_MYSTERY_BOX;
- else if (cv_competitionboxes.value == 2) // Teleport
- i = MT_MIXUP_BOX;
- else if (cv_competitionboxes.value == 3) // None
- return; // Don't spawn!
- // default case: normal
+ if (mobj->type != MT_CHAINMACEPOINT)
+ continue;
+
+ linktype = chainlink;
+ firsttype = ((mthing->options & MTF_AMBUSH) ? MT_BIGGRABCHAIN : MT_SMALLGRABCHAIN);
+ mmaxlength = 1 + (mlength - 1) * radiusfactor;
+ radiusfactor = widthfactor = 1;
}
- // Set powerup boxes to user settings for other netplay modes
- else if (gametype != GT_COOP)
+ else
{
- if (cv_matchboxes.value == 1) // Mystery
- i = MT_MYSTERY_BOX;
- else if (cv_matchboxes.value == 2) // Unchanging
+ if (mobj->type == MT_CHAINMACEPOINT)
{
- if (i == MT_MYSTERY_BOX)
- return; // don't spawn
- mthing->options &= ~(MTF_AMBUSH|MTF_OBJECTSPECIAL); // no random respawning!
+ // Make the links the same type as the end - repeated above
+ if (lines[line].flags & ML_EFFECT2)
+ {
+ linktype = macetype;
+ radiusfactor = 2;
+ }
+ else
+ radiusfactor = (((linktype = chainlink) == MT_NULL) ? 2 : 1);
+
+ firsttype = macetype;
+ widthfactor = 2;
}
- else if (cv_matchboxes.value == 3) // Don't spawn
- return;
- // default case: normal
+
+ mmaxlength = mlength;
}
- }
- if (gametype != GT_CTF) // CTF specific things
- {
- if (i == MT_RING_BLUEBOX || i == MT_RING_REDBOX)
- i = MT_RING_BOX;
- else if (i == MT_BLUEFLAG || i == MT_REDFLAG)
- return; // No flags in non-CTF modes!
- }
- else
- {
- if ((i == MT_BLUEFLAG && blueflag) || (i == MT_REDFLAG && redflag))
+ mwidthset = mwidth;
+ mlengthset = mminlength;
+
+ if (mdocenter) // Innermost link
+ makemace(linktype, 0, 0);
+
+ // Out from the center...
+ if (linktype)
{
- CONS_Alert(CONS_ERROR, M_GetText("Only one flag per team allowed in CTF!\n"));
- return;
+ while ((++mlengthset) < mmaxlength)
+ makemace(linktype, radiusfactor*mlengthset, 0);
}
- }
-
- if (!G_PlatformGametype() && (i == MT_SIGN || i == MT_STARPOST))
- return; // Don't spawn exit signs or starposts in wrong game modes
+ else
+ mlengthset = mmaxlength;
- if (modeattacking) // Record Attack special stuff
- {
- // Don't spawn starposts that wouldn't be usable
- if (i == MT_STARPOST)
- return;
+ // Outermost mace/link
+ if (firsttype)
+ makemace(firsttype, radiusfactor*mlengthset, MF2_AMBUSH);
- // 1UPs -->> Score TVs
- else if (i == MT_1UP_BOX) // 1UP
+ if (!mwidth)
+ {
+ if (mdosound && mnumspokes <= mmin) // Can it make a sound?
+ spawnee->flags2 |= MF2_BOSSNOTRAP;
+ }
+ else
{
- // Either or, doesn't matter which.
- if (mthing->options & (MTF_AMBUSH|MTF_OBJECTSPECIAL))
- i = MT_SCORE10K_BOX; // 10,000
+ // Across the bar!
+ if (!firsttype)
+ mwidthset = -mwidth;
+ else if (mwidth > 0)
+ {
+ while ((mwidthset -= widthfactor) > -mwidth)
+ {
+ makemace(firsttype, radiusfactor*mlengthset, MF2_AMBUSH);
+ if (mdosound && (mwidthset == msound) && mnumspokes <= mmin) // Can it make a sound?
+ spawnee->flags2 |= MF2_BOSSNOTRAP;
+ }
+ }
else
- i = MT_SCORE1K_BOX; // 1,000
+ {
+ while ((mwidthset += widthfactor) < -mwidth)
+ {
+ makemace(firsttype, radiusfactor*mlengthset, MF2_AMBUSH);
+ if (mdosound && (mwidthset == msound) && mnumspokes <= mmin) // Can it make a sound?
+ spawnee->flags2 |= MF2_BOSSNOTRAP;
+ }
+ }
+ mwidth = -mwidth;
+
+ // Outermost mace/link again!
+ if (firsttype)
+ makemace(firsttype, radiusfactor*(mlengthset--), MF2_AMBUSH);
+
+ // ...and then back into the center!
+ if (linktype)
+ while (mlengthset > mminlength)
+ makemace(linktype, radiusfactor*(mlengthset--), 0);
+
+ if (mdocenter) // Innermost link
+ makemace(linktype, 0, 0);
}
}
+#undef makemace
+ return true;
+}
- if (ultimatemode)
- {
- if (i == MT_PITY_BOX || i == MT_ELEMENTAL_BOX || i == MT_ATTRACT_BOX
- || i == MT_FORCE_BOX || i == MT_ARMAGEDDON_BOX || i == MT_WHIRLWIND_BOX
- || i == MT_FLAMEAURA_BOX || i == MT_BUBBLEWRAP_BOX || i == MT_THUNDERCOIN_BOX
- || i == MT_RING_BOX || i == MT_STARPOST)
- return; // No rings or shields in Ultimate mode
+static boolean P_SetupParticleGen(mapthing_t *mthing, mobj_t *mobj)
+{
+ fixed_t radius, speed;
+ INT32 type, numdivisions, anglespeed, ticcount;
+ angle_t angledivision;
+ INT32 line;
+ const size_t mthingi = (size_t)(mthing - mapthings);
- // Don't include the gold repeating boxes here please.
- // They're likely facets of the level's design and therefore required to progress.
+ // Find the corresponding linedef special, using angle as tag
+ line = P_FindSpecialLineFromTag(15, mthing->angle, -1);
+
+ if (line == -1)
+ {
+ CONS_Debug(DBG_GAMELOGIC, "Particle generator (mapthing #%s) needs to be tagged to a #15 parameter line (trying to find tag %d).\n", sizeu1(mthingi), mthing->angle);
+ return false;
}
- if (i == MT_ROSY)
+ if (sides[lines[line].sidenum[0]].toptexture)
+ type = sides[lines[line].sidenum[0]].toptexture; // Set as object type in p_setup.c...
+ else
+ type = (INT32)MT_PARTICLE;
+
+ if (!lines[line].backsector
+ || (ticcount = (sides[lines[line].sidenum[1]].textureoffset >> FRACBITS)) < 1)
+ ticcount = 3;
+
+ numdivisions = mthing->z;
+
+ if (numdivisions)
{
- 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
+ radius = R_PointToDist2(lines[line].v1->x, lines[line].v1->y, lines[line].v2->x, lines[line].v2->y);
+ anglespeed = (sides[lines[line].sidenum[0]].rowoffset >> FRACBITS) % 360;
+ angledivision = 360/numdivisions;
}
+ else
+ {
+ numdivisions = 1; // Simple trick to make A_ParticleSpawn simpler.
+ radius = 0;
+ anglespeed = 0;
+ angledivision = 0;
+ }
+
+ speed = abs(sides[lines[line].sidenum[0]].textureoffset);
+ if (mthing->options & MTF_OBJECTFLIP)
+ speed *= -1;
+
+ CONS_Debug(DBG_GAMELOGIC, "Particle Generator (mapthing #%s):\n"
+ "Radius is %d\n"
+ "Speed is %d\n"
+ "Anglespeed is %d\n"
+ "Numdivisions is %d\n"
+ "Angledivision is %d\n"
+ "Type is %d\n"
+ "Tic seperation is %d\n",
+ sizeu1(mthingi), radius, speed, anglespeed, numdivisions, angledivision, type, ticcount);
- if (i == MT_TOKEN && ((gametype != GT_COOP && gametype != GT_COMPETITION) || tokenbits == 30 || tokenlist & (1 << tokenbits++)))
- return; // you already got this token, or there are too many, or the gametype's not right
+ mobj->angle = 0;
+ mobj->movefactor = speed;
+ mobj->lastlook = numdivisions;
+ mobj->movedir = angledivision*ANG1;
+ mobj->movecount = anglespeed*ANG1;
+ mobj->friction = radius;
+ mobj->threshold = type;
+ mobj->reactiontime = ticcount;
+ mobj->cvmem = line;
+ mobj->watertop = mobj->waterbottom = 0;
+ return true;
+}
- if (i == MT_EMBLEM && (netgame || multiplayer || (modifiedgame && !savemoddata))) // No cheating!!
- return;
+static boolean P_SetupNiGHTSDrone(mapthing_t* mthing, mobj_t* mobj)
+{
+ boolean flip = mthing->options & MTF_OBJECTFLIP;
+ boolean topaligned = (mthing->options & MTF_OBJECTSPECIAL) && !(mthing->options & MTF_EXTRA);
+ boolean middlealigned = (mthing->options & MTF_EXTRA) && !(mthing->options & MTF_OBJECTSPECIAL);
+ boolean bottomoffsetted = !(mthing->options & MTF_OBJECTSPECIAL) && !(mthing->options & MTF_EXTRA);
- // Objectplace landing point
- noreturns:
+ INT16 timelimit = mthing->angle & 0xFFF;
+ fixed_t hitboxradius = ((mthing->angle & 0xF000) >> 12)*32*FRACUNIT;
+ fixed_t hitboxheight = mthing->extrainfo*32*FRACUNIT;
+ fixed_t oldheight = mobj->height;
+ fixed_t dronemanoffset, goaloffset, sparkleoffset, droneboxmandiff, dronemangoaldiff;
- // spawn it
- x = mthing->x << FRACBITS;
- y = mthing->y << FRACBITS;
- ss = R_PointInSubsector(x, y);
+ if (timelimit > 0)
+ mobj->health = timelimit;
- if (i == MT_NIGHTSBUMPER)
- z = (
-#ifdef ESLOPE
- ss->sector->f_slope ? P_GetZAt(ss->sector->f_slope, x, y) :
-#endif
- ss->sector->floorheight) + ((mthing->options >> ZSHIFT) << FRACBITS);
- else if (i == MT_AXIS || i == MT_AXISTRANSFER || i == MT_AXISTRANSFERLINE)
- z = ONFLOORZ;
- else if (i == MT_SPIKEBALL || P_WeaponOrPanel(i) || i == MT_EMERALDSPAWN || i == MT_TOKEN || i == MT_EMBLEM)
- {
- if (mthing->options & MTF_OBJECTFLIP)
- {
- z = (
-#ifdef ESLOPE
- ss->sector->c_slope ? P_GetZAt(ss->sector->c_slope, x, y) :
-#endif
- ss->sector->ceilingheight);
+ if (hitboxradius > 0)
+ mobj->radius = hitboxradius;
+
+ if (hitboxheight > 0)
+ mobj->height = hitboxheight;
+ else
+ mobj->height = mobjinfo[MT_NIGHTSDRONE].height;
- if (mthing->options & MTF_AMBUSH) // Special flag for rings
- z -= 24*FRACUNIT;
- if (mthing->options >> ZSHIFT)
- z -= (mthing->options >> ZSHIFT)*FRACUNIT;
+ droneboxmandiff = max(mobj->height - mobjinfo[MT_NIGHTSDRONE_MAN].height, 0);
+ dronemangoaldiff = max(mobjinfo[MT_NIGHTSDRONE_MAN].height - mobjinfo[MT_NIGHTSDRONE_GOAL].height, 0);
- z -= mobjinfo[i].height; //Don't forget the height!
+ if (flip && mobj->height != oldheight)
+ P_TeleportMove(mobj, mobj->x, mobj->y, mobj->z - (mobj->height - oldheight));
+
+ if (!flip)
+ {
+ if (topaligned) // Align droneman to top of hitbox
+ {
+ dronemanoffset = droneboxmandiff;
+ goaloffset = dronemangoaldiff/2 + dronemanoffset;
}
- else
+ else if (middlealigned) // Align droneman to center of hitbox
{
- z = (
-#ifdef ESLOPE
- ss->sector->f_slope ? P_GetZAt(ss->sector->f_slope, x, y) :
-#endif
- ss->sector->floorheight);
-
- if (mthing->options & MTF_AMBUSH) // Special flag for rings
- z += 24*FRACUNIT;
- if (mthing->options >> ZSHIFT)
- z += (mthing->options >> ZSHIFT)*FRACUNIT;
+ dronemanoffset = droneboxmandiff/2;
+ goaloffset = dronemangoaldiff/2 + dronemanoffset;
+ }
+ else if (bottomoffsetted)
+ {
+ dronemanoffset = 24*FRACUNIT;
+ goaloffset = dronemangoaldiff + dronemanoffset;
+ }
+ else
+ {
+ dronemanoffset = 0;
+ goaloffset = dronemangoaldiff/2 + dronemanoffset;
}
- if (z == ONFLOORZ)
- mthing->z = 0;
- else
- mthing->z = (INT16)(z>>FRACBITS);
+ sparkleoffset = goaloffset - FixedMul(15*FRACUNIT, mobj->scale);
}
else
{
- fixed_t offset = 0;
- boolean flip = (!!(mobjinfo[i].flags & MF_SPAWNCEILING) ^ !!(mthing->options & MTF_OBJECTFLIP));
-
- // base positions
- if (flip)
- z = (
-#ifdef ESLOPE
- ss->sector->c_slope ? P_GetZAt(ss->sector->c_slope, x, y) :
-#endif
- ss->sector->ceilingheight) - mobjinfo[i].height;
- else
- z = (
-#ifdef ESLOPE
- ss->sector->f_slope ? P_GetZAt(ss->sector->f_slope, x, y) :
-#endif
- ss->sector->floorheight);
-
- // offsetting
- if (mthing->options >> ZSHIFT)
- offset = ((mthing->options >> ZSHIFT) << FRACBITS);
- else if (i == MT_CRAWLACOMMANDER || i == MT_DETON || i == MT_JETTBOMBER || i == MT_JETTGUNNER || i == MT_EGGMOBILE2)
- offset = 33*FRACUNIT;
- else if (i == MT_EGGMOBILE)
- offset = 128*FRACUNIT;
- else if (i == MT_GOLDBUZZ || i == MT_REDBUZZ)
- offset = 288*FRACUNIT;
+ mobj->eflags |= MFE_VERTICALFLIP;
+ mobj->flags2 |= MF2_OBJECTFLIP;
- // applying offsets! (if any)
- if (flip)
+ if (topaligned) // Align droneman to top of hitbox
{
- if (offset)
- z -= offset;
- else
- z = ONCEILINGZ;
+ dronemanoffset = 0;
+ goaloffset = dronemangoaldiff/2 + dronemanoffset;
+ }
+ else if (middlealigned) // Align droneman to center of hitbox
+ {
+ dronemanoffset = droneboxmandiff/2;
+ goaloffset = dronemangoaldiff/2 + dronemanoffset;
+ }
+ else if (bottomoffsetted)
+ {
+ dronemanoffset = droneboxmandiff - FixedMul(24*FRACUNIT, mobj->scale);
+ goaloffset = dronemangoaldiff + dronemanoffset;
}
else
{
- if (offset)
- z += offset;
- else
- z = ONFLOORZ;
+ dronemanoffset = droneboxmandiff;
+ goaloffset = dronemangoaldiff/2 + dronemanoffset;
}
- if (z == ONFLOORZ)
- mthing->z = 0;
- else
- mthing->z = (INT16)(z>>FRACBITS);
+ sparkleoffset = goaloffset + FixedMul(15*FRACUNIT, mobj->scale);
}
- mobj = P_SpawnMobj(x, y, z, i);
- mobj->spawnpoint = mthing;
-
-#ifdef HAVE_BLUA
- if (LUAh_MapThingSpawn(mobj, mthing))
- {
- if (P_MobjWasRemoved(mobj))
- return;
- }
- else if (P_MobjWasRemoved(mobj))
- return;
- else
-#endif
- switch(mobj->type)
- {
- case MT_EMBLEM:
+ // spawn visual elements
{
- INT32 j;
- emblem_t *emblem = M_GetLevelEmblems(gamemap);
- skincolors_t emcolor;
-
- while (emblem)
- {
- if ((emblem->type == ET_GLOBAL || emblem->type == ET_SKIN) && emblem->tag == mthing->angle)
- break;
+ mobj_t* goalpost = P_SpawnMobjFromMobj(mobj, 0, 0, goaloffset, MT_NIGHTSDRONE_GOAL);
+ mobj_t* sparkle = P_SpawnMobjFromMobj(mobj, 0, 0, sparkleoffset, MT_NIGHTSDRONE_SPARKLING);
+ mobj_t* droneman = P_SpawnMobjFromMobj(mobj, 0, 0, dronemanoffset, MT_NIGHTSDRONE_MAN);
- emblem = M_GetLevelEmblems(-1);
- }
+ P_SetTarget(&mobj->target, goalpost);
+ P_SetTarget(&goalpost->target, sparkle);
+ P_SetTarget(&goalpost->tracer, droneman);
- if (!emblem)
+ // correct Z position
+ if (flip)
{
- CONS_Debug(DBG_GAMELOGIC, "No map emblem for map %d with tag %d found!\n", gamemap, mthing->angle);
- break;
+ P_TeleportMove(goalpost, goalpost->x, goalpost->y, mobj->z + goaloffset);
+ P_TeleportMove(sparkle, sparkle->x, sparkle->y, mobj->z + sparkleoffset);
+ P_TeleportMove(droneman, droneman->x, droneman->y, mobj->z + dronemanoffset);
}
- j = emblem - emblemlocations;
+ // Remember position preference for later
+ mobj->flags &= ~(MF_SLIDEME|MF_GRENADEBOUNCE);
+ if (topaligned)
+ mobj->flags |= MF_SLIDEME;
+ else if (middlealigned)
+ mobj->flags |= MF_GRENADEBOUNCE;
+ else if (!bottomoffsetted)
+ mobj->flags |= MF_SLIDEME|MF_GRENADEBOUNCE;
- I_Assert(emblemlocations[j].sprite >= 'A' && emblemlocations[j].sprite <= 'Z');
- P_SetMobjState(mobj, mobj->info->spawnstate + (emblemlocations[j].sprite - 'A'));
+ // Remember old Z position and flags for correction detection
+ goalpost->movefactor = mobj->z;
+ goalpost->friction = mobj->height;
+ goalpost->threshold = mobj->flags & (MF_SLIDEME|MF_GRENADEBOUNCE);
+ }
+ return true;
+}
- mobj->health = j + 1;
- emcolor = M_GetEmblemColor(&emblemlocations[j]); // workaround for compiler complaint about bad function casting
- mobj->color = (UINT8)emcolor;
+static boolean P_SetupBooster(mapthing_t* mthing, mobj_t* mobj, boolean strong)
+{
+ 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);
+ statenum_t facestate = strong ? S_REDBOOSTERSEG_FACE : S_YELLOWBOOSTERSEG_FACE;
+ statenum_t leftstate = strong ? S_REDBOOSTERSEG_LEFT : S_YELLOWBOOSTERSEG_LEFT;
+ statenum_t rightstate = strong ? S_REDBOOSTERSEG_RIGHT : S_YELLOWBOOSTERSEG_RIGHT;
+ statenum_t rollerstate = strong ? S_REDBOOSTERROLLER : S_YELLOWBOOSTERROLLER;
+
+ mobj_t *seg = P_SpawnMobjFromMobj(mobj, 26*x1, 26*y1, 0, MT_BOOSTERSEG);
+ seg->angle = angle - ANGLE_90;
+ P_SetMobjState(seg, facestate);
+ seg = P_SpawnMobjFromMobj(mobj, -26*x1, -26*y1, 0, MT_BOOSTERSEG);
+ seg->angle = angle + ANGLE_90;
+ P_SetMobjState(seg, facestate);
+ seg = P_SpawnMobjFromMobj(mobj, 21*x2, 21*y2, 0, MT_BOOSTERSEG);
+ seg->angle = angle;
+ P_SetMobjState(seg, leftstate);
+ seg = P_SpawnMobjFromMobj(mobj, -21*x2, -21*y2, 0, MT_BOOSTERSEG);
+ seg->angle = angle;
+ P_SetMobjState(seg, rightstate);
+
+ seg = P_SpawnMobjFromMobj(mobj, 13*(x1 + x2), 13*(y1 + y2), 0, MT_BOOSTERROLLER);
+ seg->angle = angle;
+ P_SetMobjState(seg, rollerstate);
+ seg = P_SpawnMobjFromMobj(mobj, 13*(x1 - x2), 13*(y1 - y2), 0, MT_BOOSTERROLLER);
+ seg->angle = angle;
+ P_SetMobjState(seg, rollerstate);
+ seg = P_SpawnMobjFromMobj(mobj, -13*(x1 + x2), -13*(y1 + y2), 0, MT_BOOSTERROLLER);
+ seg->angle = angle;
+ P_SetMobjState(seg, rollerstate);
+ seg = P_SpawnMobjFromMobj(mobj, -13*(x1 - x2), -13*(y1 - y2), 0, MT_BOOSTERROLLER);
+ seg->angle = angle;
+ P_SetMobjState(seg, rollerstate);
- if (emblemlocations[j].collected
- || (emblemlocations[j].type == ET_SKIN && emblemlocations[j].var != players[0].skin))
- {
- P_UnsetThingPosition(mobj);
- mobj->flags |= MF_NOCLIP;
- mobj->flags &= ~MF_SPECIAL;
- mobj->flags |= MF_NOBLOCKMAP;
- mobj->frame |= (tr_trans50 << FF_TRANSSHIFT);
- P_SetThingPosition(mobj);
- }
- else
- {
- mobj->frame &= ~FF_TRANSMASK;
+ return true;
+}
- if (emblemlocations[j].type == ET_GLOBAL)
- {
- mobj->reactiontime = emblemlocations[j].var;
- if (emblemlocations[j].var & GE_NIGHTSITEM)
- {
- mobj->flags |= MF_NIGHTSITEM;
- mobj->flags &= ~MF_SPECIAL;
- mobj->flags2 |= MF2_DONTDRAW;
- }
- }
- }
+static boolean P_SetupSpawnedMapThing(mapthing_t *mthing, mobj_t *mobj, boolean *doangle)
+{
+#ifdef HAVE_BLUA
+ boolean override = LUAh_MapThingSpawn(mobj, mthing);
+
+ if (P_MobjWasRemoved(mobj))
+ return false;
+
+ if (override)
+ return true;
+#endif
+
+ switch (mobj->type)
+ {
+ case MT_EMBLEM:
+ {
+ if (!P_SetupEmblem(mthing, mobj))
+ return false;
break;
}
case MT_SKYBOX:
@@ -12019,7 +12649,7 @@ You should think about modifying the deathmatch starts to take full advantage of
if (mthing->angle)
mobj->health = mthing->angle;
else
- mobj->health = FixedMul(ss->sector->ceilingheight-ss->sector->floorheight, 3*(FRACUNIT/4))>>FRACBITS;
+ mobj->health = FixedMul(mobj->subsector->sector->ceilingheight - mobj->subsector->sector->floorheight, 3*(FRACUNIT/4)) >> FRACBITS;
break;
case MT_METALSONIC_RACE:
case MT_METALSONIC_BATTLE:
@@ -12034,7 +12664,7 @@ You should think about modifying the deathmatch starts to take full advantage of
break;
case MT_BALLOON:
if (mthing->angle > 0)
- mobj->color = ((mthing->angle-1) % (MAXSKINCOLORS-1))+1;
+ mobj->color = ((mthing->angle - 1) % (MAXSKINCOLORS - 1)) + 1;
break;
#define makesoftwarecorona(mo, h) \
corona = P_SpawnMobjFromMobj(mo, 0, 0, h<<FRACBITS, MT_PARTICLE);\
@@ -12055,442 +12685,61 @@ You should think about modifying the deathmatch starts to take full advantage of
{
mobj_t *flame = P_SpawnMobjFromMobj(mobj, 0, 0, mobj->height, MT_FLAME);
P_SetTarget(&flame->target, mobj);
- flame->flags2 |= MF2_BOSSNOTRAP;
- if (mthing->options & MTF_EXTRA)
- {
- mobj_t *corona;
- makesoftwarecorona(flame, 20);
- P_SetScale(corona, (corona->destscale = flame->scale*3));
- P_SetTarget(&flame->tracer, corona);
- }
- }
- break;
- case MT_CANDLE:
- case MT_CANDLEPRICKET:
- if (mthing->options & MTF_EXTRA)
- {
- mobj_t *corona;
- makesoftwarecorona(mobj, ((mobj->type == MT_CANDLE) ? 42 : 176));
- }
- break;
-#undef makesoftwarecorona
- case MT_JACKO1:
- case MT_JACKO2:
- case MT_JACKO3:
- if (!(mthing->options & MTF_EXTRA)) // take the torch out of the crafting recipe
- {
- mobj_t *overlay = P_SpawnMobjFromMobj(mobj, 0, 0, 0, MT_OVERLAY);
- P_SetTarget(&overlay->target, mobj);
- P_SetMobjState(overlay, mobj->info->raisestate);
- }
- break;
- case MT_WATERDRIP:
- if (mthing->angle)
- mobj->tics = 3*TICRATE + mthing->angle;
- else
- mobj->tics = 3*TICRATE;
- break;
- case MT_FLAMEJET:
- case MT_VERTICALFLAMEJET:
- mobj->threshold = (mthing->angle >> 10) & 7;
- mobj->movecount = (mthing->angle >> 13);
-
- mobj->threshold *= (TICRATE/2);
- mobj->movecount *= (TICRATE/2);
-
- mobj->movedir = mthing->extrainfo;
- break;
- case MT_MACEPOINT:
- case MT_CHAINMACEPOINT:
- case MT_SPRINGBALLPOINT:
- case MT_CHAINPOINT:
- case MT_FIREBARPOINT:
- case MT_CUSTOMMACEPOINT:
- {
- fixed_t mlength, mmaxlength, mlengthset, mspeed, mphase, myaw, mpitch, mminlength, mnumspokes, mpinch, mroll, mnumnospokes, mwidth, mwidthset, mmin, msound, radiusfactor, widthfactor;
- angle_t mspokeangle;
- mobjtype_t chainlink, macetype, firsttype, linktype;
- boolean mdosound, mdocenter, mchainlike = false;
- mobj_t *spawnee = NULL, *hprev = mobj;
- mobjflag_t mflagsapply;
- mobjflag2_t mflags2apply;
- mobjeflag_t meflagsapply;
- INT32 line;
- const size_t mthingi = (size_t)(mthing - mapthings);
-
- // Find the corresponding linedef special, using angle as tag
- // P_FindSpecialLineFromTag works here now =D
- line = P_FindSpecialLineFromTag(9, mthing->angle, -1);
-
- if (line == -1)
- {
- CONS_Debug(DBG_GAMELOGIC, "Mace chain (mapthing #%s) needs to be tagged to a #9 parameter line (trying to find tag %d).\n", sizeu1(mthingi), mthing->angle);
- return;
- }
-/*
-mapthing -
-MTF_AMBUSH :
- MT_SPRINGBALLPOINT - upgrade from yellow to red spring
- anything else - bigger mace/chain theory
-MTF_OBJECTSPECIAL - force silent
-MTF_GRAVFLIP - flips objects, doesn't affect chain arrangements
-Parameter value : number of "spokes"
-
-linedef -
-ML_NOCLIMB :
- MT_CHAINPOINT/MT_CHAINMACEPOINT with ML_EFFECT1 applied - Direction not controllable
- anything else - no functionality
-ML_EFFECT1 : Swings instead of spins
-ML_EFFECT2 : Linktype is replaced with macetype for all spokes not ending in chains (inverted for MT_FIREBARPOINT)
-ML_EFFECT3 : Spawn a bonus linktype at the hinge point
-ML_EFFECT4 : Don't clip inside the ground
-ML_EFFECT5 : Don't stop thinking when too far away
-*/
- mlength = abs(lines[line].dx >> FRACBITS);
- mspeed = abs(lines[line].dy >> (FRACBITS - 4));
- mphase = (sides[lines[line].sidenum[0]].textureoffset >> FRACBITS) % 360;
- if ((mminlength = -sides[lines[line].sidenum[0]].rowoffset>>FRACBITS) < 0)
- mminlength = 0;
- else if (mminlength > mlength-1)
- mminlength = mlength-1;
- mpitch = (lines[line].frontsector->floorheight >> FRACBITS) % 360;
- myaw = (lines[line].frontsector->ceilingheight >> FRACBITS) % 360;
-
- mnumspokes = mthing->extrainfo + 1;
- mspokeangle = FixedAngle((360*FRACUNIT)/mnumspokes)>>ANGLETOFINESHIFT;
-
- if (lines[line].backsector)
- {
- mpinch = (lines[line].backsector->floorheight >> FRACBITS) % 360;
- mroll = (lines[line].backsector->ceilingheight >> FRACBITS) % 360;
- mnumnospokes = (sides[lines[line].sidenum[1]].textureoffset >> FRACBITS);
- if ((mwidth = sides[lines[line].sidenum[1]].rowoffset >> FRACBITS) < 0)
- mwidth = 0;
- }
- else
- mpinch = mroll = mnumnospokes = mwidth = 0;
-
- CONS_Debug(DBG_GAMELOGIC, "Mace/Chain (mapthing #%s):\n"
- "Length is %d (minus %d)\n"
- "Speed is %d\n"
- "Phase is %d\n"
- "Yaw is %d\n"
- "Pitch is %d\n"
- "No. of spokes is %d (%d antispokes)\n"
- "Pinch is %d\n"
- "Roll is %d\n"
- "Width is %d\n",
- sizeu1(mthingi), mlength, mminlength, mspeed, mphase, myaw, mpitch, mnumspokes, mnumnospokes, mpinch, mroll, mwidth);
-
- if (mnumnospokes > 0 && (mnumnospokes < mnumspokes))
- mnumnospokes = mnumspokes/mnumnospokes;
- else
- mnumnospokes = ((mobj->type == MT_CHAINMACEPOINT) ? (mnumspokes) : 0);
-
- mobj->lastlook = mspeed;
- mobj->movecount = mobj->lastlook;
- mobj->angle = FixedAngle(myaw*FRACUNIT);
- doangle = false;
- mobj->threshold = (FixedAngle(mpitch*FRACUNIT)>>ANGLETOFINESHIFT);
- mobj->movefactor = mpinch;
- mobj->movedir = 0;
-
- // Mobjtype selection
- switch(mobj->type)
- {
- case MT_SPRINGBALLPOINT:
- macetype = ((mthing->options & MTF_AMBUSH)
- ? MT_REDSPRINGBALL
- : MT_YELLOWSPRINGBALL);
- chainlink = MT_SMALLMACECHAIN;
- break;
- case MT_FIREBARPOINT:
- macetype = ((mthing->options & MTF_AMBUSH)
- ? MT_BIGFIREBAR
- : MT_SMALLFIREBAR);
- chainlink = MT_NULL;
- break;
- case MT_CUSTOMMACEPOINT:
- macetype = (mobjtype_t)sides[lines[line].sidenum[0]].toptexture;
- if (lines[line].backsector)
- chainlink = (mobjtype_t)sides[lines[line].sidenum[1]].toptexture;
- else
- chainlink = MT_NULL;
- break;
- case MT_CHAINPOINT:
- if (mthing->options & MTF_AMBUSH)
- {
- macetype = MT_BIGGRABCHAIN;
- chainlink = MT_BIGMACECHAIN;
- }
- else
- {
- macetype = MT_SMALLGRABCHAIN;
- chainlink = MT_SMALLMACECHAIN;
- }
- mchainlike = true;
- break;
- default:
- if (mthing->options & MTF_AMBUSH)
- {
- macetype = MT_BIGMACE;
- chainlink = MT_BIGMACECHAIN;
- }
- else
- {
- macetype = MT_SMALLMACE;
- chainlink = MT_SMALLMACECHAIN;
- }
- break;
- }
-
- if (!macetype && !chainlink)
- break;
-
- if (mobj->type == MT_CHAINPOINT)
- {
- if (!mlength)
- break;
- }
- else
- mlength++;
-
- firsttype = macetype;
-
- // Adjustable direction
- if (lines[line].flags & ML_NOCLIMB)
- mobj->flags |= MF_SLIDEME;
-
- // Swinging
- if (lines[line].flags & ML_EFFECT1)
- {
- mobj->flags2 |= MF2_STRONGBOX;
- mmin = ((mnumnospokes > 1) ? 1 : 0);
- }
- else
- mmin = mnumspokes;
-
- // If over distance away, don't move UNLESS this flag is applied
- if (lines[line].flags & ML_EFFECT5)
- mobj->flags2 |= MF2_BOSSNOTRAP;
-
- // Make the links the same type as the end - repeated below
- if ((mobj->type != MT_CHAINPOINT) && (((lines[line].flags & ML_EFFECT2) == ML_EFFECT2) != (mobj->type == MT_FIREBARPOINT))) // exclusive or
- {
- linktype = macetype;
- radiusfactor = 2; // Double the radius.
- }
- else
- radiusfactor = (((linktype = chainlink) == MT_NULL) ? 2 : 1);
-
- if (!mchainlike)
- mchainlike = (firsttype == chainlink);
- widthfactor = (mchainlike ? 1 : 2);
-
- mflagsapply = ((lines[line].flags & ML_EFFECT4) ? 0 : (MF_NOCLIP|MF_NOCLIPHEIGHT));
- mflags2apply = ((mthing->options & MTF_OBJECTFLIP) ? MF2_OBJECTFLIP : 0);
- meflagsapply = ((mthing->options & MTF_OBJECTFLIP) ? MFE_VERTICALFLIP : 0);
-
- msound = (mchainlike ? 0 : (mwidth & 1));
-
- // Quick and easy preparatory variable setting
- mphase = (FixedAngle(mphase*FRACUNIT)>>ANGLETOFINESHIFT);
- mroll = (FixedAngle(mroll*FRACUNIT)>>ANGLETOFINESHIFT);
-
-#define makemace(mobjtype, dist, moreflags2) {\
- spawnee = P_SpawnMobj(mobj->x, mobj->y, mobj->z, mobjtype);\
- P_SetTarget(&spawnee->tracer, mobj);\
- spawnee->threshold = mphase;\
- spawnee->friction = mroll;\
- spawnee->movefactor = mwidthset;\
- spawnee->movecount = dist;\
- spawnee->angle = myaw;\
- spawnee->flags |= (MF_NOGRAVITY|mflagsapply);\
- spawnee->flags2 |= (mflags2apply|moreflags2);\
- spawnee->eflags |= meflagsapply;\
- P_SetTarget(&hprev->hnext, spawnee);\
- P_SetTarget(&spawnee->hprev, hprev);\
- hprev = spawnee;\
-}
-
- mdosound = (mspeed && !(mthing->options & MTF_OBJECTSPECIAL));
- mdocenter = (macetype && (lines[line].flags & ML_EFFECT3));
-
- // The actual spawning of spokes
- while (mnumspokes-- > 0)
- {
- // Offsets
- if (lines[line].flags & ML_EFFECT1) // Swinging
- mroll = (mroll - mspokeangle) & FINEMASK;
- else // Spinning
- mphase = (mphase - mspokeangle) & FINEMASK;
-
- if (mnumnospokes && !(mnumspokes % mnumnospokes)) // Skipping a "missing" spoke
- {
- if (mobj->type != MT_CHAINMACEPOINT)
- continue;
-
- linktype = chainlink;
- firsttype = ((mthing->options & MTF_AMBUSH) ? MT_BIGGRABCHAIN : MT_SMALLGRABCHAIN);
- mmaxlength = 1 + (mlength - 1)*radiusfactor;
- radiusfactor = widthfactor = 1;
- }
- else
- {
- if (mobj->type == MT_CHAINMACEPOINT)
- {
- // Make the links the same type as the end - repeated above
- if (lines[line].flags & ML_EFFECT2)
- {
- linktype = macetype;
- radiusfactor = 2;
- }
- else
- radiusfactor = (((linktype = chainlink) == MT_NULL) ? 2 : 1);
-
- firsttype = macetype;
- widthfactor = 2;
- }
-
- mmaxlength = mlength;
- }
-
- mwidthset = mwidth;
- mlengthset = mminlength;
-
- if (mdocenter) // Innermost link
- makemace(linktype, 0, 0);
-
- // Out from the center...
- if (linktype)
- {
- while ((++mlengthset) < mmaxlength)
- makemace(linktype, radiusfactor*mlengthset, 0);
- }
- else
- mlengthset = mmaxlength;
-
- // Outermost mace/link
- if (firsttype)
- makemace(firsttype, radiusfactor*mlengthset, MF2_AMBUSH);
-
- if (!mwidth)
- {
- if (mdosound && mnumspokes <= mmin) // Can it make a sound?
- spawnee->flags2 |= MF2_BOSSNOTRAP;
- }
- else
- {
- // Across the bar!
- if (!firsttype)
- mwidthset = -mwidth;
- else if (mwidth > 0)
- {
- while ((mwidthset -= widthfactor) > -mwidth)
- {
- makemace(firsttype, radiusfactor*mlengthset, MF2_AMBUSH);
- if (mdosound && (mwidthset == msound) && mnumspokes <= mmin) // Can it make a sound?
- spawnee->flags2 |= MF2_BOSSNOTRAP;
- }
- }
- else
- {
- while ((mwidthset += widthfactor) < -mwidth)
- {
- makemace(firsttype, radiusfactor*mlengthset, MF2_AMBUSH);
- if (mdosound && (mwidthset == msound) && mnumspokes <= mmin) // Can it make a sound?
- spawnee->flags2 |= MF2_BOSSNOTRAP;
- }
- }
- mwidth = -mwidth;
-
- // Outermost mace/link again!
- if (firsttype)
- makemace(firsttype, radiusfactor*(mlengthset--), MF2_AMBUSH);
-
- // ...and then back into the center!
- if (linktype)
- while (mlengthset > mminlength)
- makemace(linktype, radiusfactor*(mlengthset--), 0);
-
- if (mdocenter) // Innermost link
- makemace(linktype, 0, 0);
- }
- }
-
-#undef makemace
-
- break;
- }
- case MT_PARTICLEGEN:
- {
- fixed_t radius, speed;
- INT32 type, numdivisions, anglespeed, ticcount;
- angle_t angledivision;
- INT32 line;
- const size_t mthingi = (size_t)(mthing - mapthings);
-
- // Find the corresponding linedef special, using angle as tag
- line = P_FindSpecialLineFromTag(15, mthing->angle, -1);
-
- if (line == -1)
- {
- CONS_Debug(DBG_GAMELOGIC, "Particle generator (mapthing #%s) needs to be tagged to a #15 parameter line (trying to find tag %d).\n", sizeu1(mthingi), mthing->angle);
- return;
+ flame->flags2 |= MF2_BOSSNOTRAP;
+ if (mthing->options & MTF_EXTRA)
+ {
+ mobj_t *corona;
+ makesoftwarecorona(flame, 20);
+ P_SetScale(corona, (corona->destscale = flame->scale*3));
+ P_SetTarget(&flame->tracer, corona);
+ }
}
-
- if (sides[lines[line].sidenum[0]].toptexture)
- type = sides[lines[line].sidenum[0]].toptexture; // Set as object type in p_setup.c...
- else
- type = (INT32)MT_PARTICLE;
-
- if (!lines[line].backsector
- || (ticcount = (sides[lines[line].sidenum[1]].textureoffset >> FRACBITS)) < 1)
- ticcount = 3;
-
- numdivisions = (mthing->options >> ZSHIFT);
-
- if (numdivisions)
+ break;
+ case MT_CANDLE:
+ case MT_CANDLEPRICKET:
+ if (mthing->options & MTF_EXTRA)
{
- radius = R_PointToDist2(lines[line].v1->x, lines[line].v1->y, lines[line].v2->x, lines[line].v2->y);
- anglespeed = (sides[lines[line].sidenum[0]].rowoffset >> FRACBITS) % 360;
- angledivision = 360/numdivisions;
+ mobj_t *corona;
+ makesoftwarecorona(mobj, ((mobj->type == MT_CANDLE) ? 42 : 176));
}
- else
+ break;
+#undef makesoftwarecorona
+ case MT_JACKO1:
+ case MT_JACKO2:
+ case MT_JACKO3:
+ if (!(mthing->options & MTF_EXTRA)) // take the torch out of the crafting recipe
{
- numdivisions = 1; // Simple trick to make A_ParticleSpawn simpler.
- radius = 0;
- anglespeed = 0;
- angledivision = 0;
+ mobj_t *overlay = P_SpawnMobjFromMobj(mobj, 0, 0, 0, MT_OVERLAY);
+ P_SetTarget(&overlay->target, mobj);
+ P_SetMobjState(overlay, mobj->info->raisestate);
}
+ break;
+ case MT_WATERDRIP:
+ mobj->tics = 3*TICRATE + mthing->angle;
+ break;
+ case MT_FLAMEJET:
+ case MT_VERTICALFLAMEJET:
+ mobj->threshold = (mthing->angle >> 10) & 7;
+ mobj->movecount = (mthing->angle >> 13);
- speed = abs(sides[lines[line].sidenum[0]].textureoffset);
- if (mthing->options & MTF_OBJECTFLIP)
- speed *= -1;
-
- CONS_Debug(DBG_GAMELOGIC, "Particle Generator (mapthing #%s):\n"
- "Radius is %d\n"
- "Speed is %d\n"
- "Anglespeed is %d\n"
- "Numdivisions is %d\n"
- "Angledivision is %d\n"
- "Type is %d\n"
- "Tic seperation is %d\n",
- sizeu1(mthingi), radius, speed, anglespeed, numdivisions, angledivision, type, ticcount);
-
- mobj->angle = 0;
- mobj->movefactor = speed;
- mobj->lastlook = numdivisions;
- mobj->movedir = angledivision*ANG1;
- mobj->movecount = anglespeed*ANG1;
- mobj->friction = radius;
- mobj->threshold = type;
- mobj->reactiontime = ticcount;
- mobj->cvmem = line;
- mobj->watertop = mobj->waterbottom = 0;
+ mobj->threshold *= (TICRATE/2);
+ mobj->movecount *= (TICRATE/2);
+ mobj->movedir = mthing->extrainfo;
+ break;
+ case MT_MACEPOINT:
+ case MT_CHAINMACEPOINT:
+ case MT_SPRINGBALLPOINT:
+ case MT_CHAINPOINT:
+ case MT_FIREBARPOINT:
+ case MT_CUSTOMMACEPOINT:
+ if (!P_SetupMace(mthing, mobj, doangle))
+ return false;
+ break;
+ case MT_PARTICLEGEN:
+ if (!P_SetupParticleGen(mthing, mobj))
+ return false;
break;
- }
case MT_ROCKSPAWNER:
mobj->threshold = mthing->angle;
mobj->movecount = mthing->extrainfo;
@@ -12505,7 +12754,7 @@ ML_EFFECT5 : Don't stop thinking when too far away
// Lower 4 bits specify the angle of
// the bumper in 30 degree increments.
mobj->threshold = (mthing->options & 15) % 12; // It loops over, etc
- P_SetMobjState(mobj, mobj->info->spawnstate+mobj->threshold);
+ P_SetMobjState(mobj, mobj->info->spawnstate + mobj->threshold);
break;
case MT_EGGCAPSULE:
if (mthing->angle <= 0)
@@ -12522,122 +12771,8 @@ ML_EFFECT5 : Don't stop thinking when too far away
mobj->health = mthing->extrainfo;
break;
case MT_NIGHTSDRONE:
- {
- boolean flip = mthing->options & MTF_OBJECTFLIP;
- boolean topaligned = (mthing->options & MTF_OBJECTSPECIAL) && !(mthing->options & MTF_EXTRA);
- boolean middlealigned = (mthing->options & MTF_EXTRA) && !(mthing->options & MTF_OBJECTSPECIAL);
- boolean bottomoffsetted = !(mthing->options & MTF_OBJECTSPECIAL) && !(mthing->options & MTF_EXTRA);
-
- INT16 timelimit = mthing->angle & 0xFFF;
- fixed_t hitboxradius = ((mthing->angle & 0xF000) >> 12) * 32 * FRACUNIT;
- fixed_t hitboxheight = mthing->extrainfo * 32 * FRACUNIT;
- fixed_t oldheight = mobj->height;
- fixed_t dronemanoffset, goaloffset, sparkleoffset, droneboxmandiff, dronemangoaldiff;
-
- if (timelimit > 0)
- mobj->health = timelimit;
-
- if (hitboxradius > 0)
- mobj->radius = hitboxradius;
-
- if (hitboxheight > 0)
- mobj->height = hitboxheight;
- else
- mobj->height = mobjinfo[MT_NIGHTSDRONE].height;
-
- droneboxmandiff = max(mobj->height - mobjinfo[MT_NIGHTSDRONE_MAN].height, 0);
- dronemangoaldiff = max(mobjinfo[MT_NIGHTSDRONE_MAN].height - mobjinfo[MT_NIGHTSDRONE_GOAL].height, 0);
-
- if (flip && mobj->height != oldheight)
- P_TeleportMove(mobj, mobj->x, mobj->y, mobj->z - (mobj->height - oldheight));
-
- if (!flip)
- {
- if (topaligned) // Align droneman to top of hitbox
- {
- dronemanoffset = droneboxmandiff;
- goaloffset = dronemangoaldiff / 2 + dronemanoffset;
- }
- else if (middlealigned) // Align droneman to center of hitbox
- {
- dronemanoffset = droneboxmandiff / 2;
- goaloffset = dronemangoaldiff / 2 + dronemanoffset;
- }
- else if (bottomoffsetted)
- {
- dronemanoffset = 24*FRACUNIT;
- goaloffset = dronemangoaldiff + dronemanoffset;
- }
- else
- {
- dronemanoffset = 0;
- goaloffset = dronemangoaldiff / 2 + dronemanoffset;
- }
-
- sparkleoffset = goaloffset - FixedMul(15*FRACUNIT, mobj->scale);
- }
- else
- {
- mobj->eflags |= MFE_VERTICALFLIP;
- mobj->flags2 |= MF2_OBJECTFLIP;
-
- if (topaligned) // Align droneman to top of hitbox
- {
- dronemanoffset = 0;
- goaloffset = dronemangoaldiff / 2 + dronemanoffset;
- }
- else if (middlealigned) // Align droneman to center of hitbox
- {
- dronemanoffset = droneboxmandiff / 2;
- goaloffset = dronemangoaldiff / 2 + dronemanoffset;
- }
- else if (bottomoffsetted)
- {
- dronemanoffset = droneboxmandiff - FixedMul(24*FRACUNIT, mobj->scale);
- goaloffset = dronemangoaldiff + dronemanoffset;
- }
- else
- {
- dronemanoffset = droneboxmandiff;
- goaloffset = dronemangoaldiff / 2 + dronemanoffset;
- }
-
- sparkleoffset = goaloffset + FixedMul(15*FRACUNIT, mobj->scale);
- }
-
- // spawn visual elements
- {
- mobj_t *goalpost = P_SpawnMobjFromMobj(mobj, 0, 0, goaloffset, MT_NIGHTSDRONE_GOAL);
- mobj_t *sparkle = P_SpawnMobjFromMobj(mobj, 0, 0, sparkleoffset, MT_NIGHTSDRONE_SPARKLING);
- mobj_t *droneman = P_SpawnMobjFromMobj(mobj, 0, 0, dronemanoffset, MT_NIGHTSDRONE_MAN);
-
- P_SetTarget(&mobj->target, goalpost);
- P_SetTarget(&goalpost->target, sparkle);
- P_SetTarget(&goalpost->tracer, droneman);
-
- // correct Z position
- if (flip)
- {
- P_TeleportMove(goalpost, goalpost->x, goalpost->y, mobj->z + goaloffset);
- P_TeleportMove(sparkle, sparkle->x, sparkle->y, mobj->z + sparkleoffset);
- P_TeleportMove(droneman, droneman->x, droneman->y, mobj->z + dronemanoffset);
- }
-
- // Remember position preference for later
- mobj->flags &= ~(MF_SLIDEME | MF_GRENADEBOUNCE);
- if (topaligned)
- mobj->flags |= MF_SLIDEME;
- else if (middlealigned)
- mobj->flags |= MF_GRENADEBOUNCE;
- else if (!bottomoffsetted)
- mobj->flags |= MF_SLIDEME | MF_GRENADEBOUNCE;
-
- // Remember old Z position and flags for correction detection
- goalpost->movefactor = mobj->z;
- goalpost->friction = mobj->height;
- goalpost->threshold = mobj->flags & (MF_SLIDEME | MF_GRENADEBOUNCE);
- }
- }
+ if (!P_SetupNiGHTSDrone(mthing, mobj))
+ return false;
break;
case MT_HIVEELEMENTAL:
if (mthing->extrainfo)
@@ -12648,7 +12783,7 @@ ML_EFFECT5 : Don't stop thinking when too far away
case MT_GLAREGOYLEDOWN:
case MT_GLAREGOYLELONG:
if (mthing->angle >= 360)
- mobj->tics += 7*(mthing->angle / 360) + 1; // starting delay
+ mobj->tics += 7*(mthing->angle/360) + 1; // starting delay
break;
case MT_DSZSTALAGMITE:
case MT_DSZ2STALAGMITE:
@@ -12659,39 +12794,39 @@ ML_EFFECT5 : Don't stop thinking when too far away
}
break;
case MT_THZTREE:
- { // Spawn the branches
- angle_t mobjangle = FixedAngle((mthing->angle % 113)<<FRACBITS);
- P_SpawnMobjFromMobj(mobj, 1*FRACUNIT, 0, 0, MT_THZTREEBRANCH)->angle = mobjangle + ANGLE_22h;
- P_SpawnMobjFromMobj(mobj, 0, 1*FRACUNIT, 0, MT_THZTREEBRANCH)->angle = mobjangle + ANGLE_157h;
- P_SpawnMobjFromMobj(mobj, -1*FRACUNIT, 0, 0, MT_THZTREEBRANCH)->angle = mobjangle + ANGLE_270;
- }
- break;
+ { // Spawn the branches
+ angle_t mobjangle = FixedAngle((mthing->angle % 113) << FRACBITS);
+ P_SpawnMobjFromMobj(mobj, FRACUNIT, 0, 0, MT_THZTREEBRANCH)->angle = mobjangle + ANGLE_22h;
+ P_SpawnMobjFromMobj(mobj, 0, FRACUNIT, 0, MT_THZTREEBRANCH)->angle = mobjangle + ANGLE_157h;
+ P_SpawnMobjFromMobj(mobj, -FRACUNIT, 0, 0, MT_THZTREEBRANCH)->angle = mobjangle + ANGLE_270;
+ }
+ break;
case MT_CEZPOLE1:
case MT_CEZPOLE2:
- { // Spawn the banner
- angle_t mobjangle = FixedAngle(mthing->angle<<FRACBITS);
- P_SpawnMobjFromMobj(mobj,
- P_ReturnThrustX(mobj, mobjangle, 4<<FRACBITS),
- P_ReturnThrustY(mobj, mobjangle, 4<<FRACBITS),
- 0, ((mobj->type == MT_CEZPOLE1) ? MT_CEZBANNER1 : MT_CEZBANNER2))->angle = mobjangle + ANGLE_90;
- }
- break;
+ { // Spawn the banner
+ angle_t mobjangle = FixedAngle(mthing->angle << FRACBITS);
+ P_SpawnMobjFromMobj(mobj,
+ P_ReturnThrustX(mobj, mobjangle, 4 << FRACBITS),
+ P_ReturnThrustY(mobj, mobjangle, 4 << FRACBITS),
+ 0, ((mobj->type == MT_CEZPOLE1) ? MT_CEZBANNER1 : MT_CEZBANNER2))->angle = mobjangle + ANGLE_90;
+ }
+ break;
case MT_HHZTREE_TOP:
- { // Spawn the branches
- angle_t mobjangle = FixedAngle(mthing->angle<<FRACBITS) & (ANGLE_90-1);
- mobj_t *leaf;
+ { // Spawn the branches
+ angle_t mobjangle = FixedAngle(mthing->angle << FRACBITS) & (ANGLE_90 - 1);
+ mobj_t* leaf;
#define doleaf(x, y) \
leaf = P_SpawnMobjFromMobj(mobj, x, y, 0, MT_HHZTREE_PART);\
leaf->angle = mobjangle;\
P_SetMobjState(leaf, leaf->info->seestate);\
mobjangle += ANGLE_90
- doleaf(1*FRACUNIT, 0);
- doleaf(0, 1*FRACUNIT);
- doleaf(-1*FRACUNIT, 0);
- doleaf(0, -1*FRACUNIT);
+ doleaf(FRACUNIT, 0);
+ doleaf(0, FRACUNIT);
+ doleaf(-FRACUNIT, 0);
+ doleaf(0, -FRACUNIT);
#undef doleaf
- }
- break;
+ }
+ break;
case MT_SMASHINGSPIKEBALL:
if (mthing->angle > 0)
mobj->tics += mthing->angle;
@@ -12722,94 +12857,27 @@ ML_EFFECT5 : Don't stop thinking when too far away
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);
+ 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:
+ if (!P_SetupBooster(mthing, mobj, mobj->type == MT_REDBOOSTER))
+ return false;
break;
- }
-
- if (mobj->flags & MF_BOSS)
- {
- if (mthing->options & MTF_OBJECTSPECIAL) // No egg trap for this boss
- mobj->flags2 |= MF2_BOSSNOTRAP;
- }
+ case MT_AXIS:
+ // Inverted if uppermost bit is set
+ if (mthing->angle & 16384)
+ mobj->flags2 |= MF2_AMBUSH;
- if (i == MT_AXIS || i == MT_AXISTRANSFER || i == MT_AXISTRANSFERLINE) // Axis Points
- {
+ if (mthing->angle > 0)
+ mobj->radius = (mthing->angle & 16383) << FRACBITS;
+ // FALLTHRU
+ case MT_AXISTRANSFER:
+ case MT_AXISTRANSFERLINE:
// Mare it belongs to
mobj->threshold = min(mthing->extrainfo, 7);
@@ -12817,38 +12885,29 @@ ML_EFFECT5 : Don't stop thinking when too far away
mobj->health = mthing->options;
mobj->flags2 |= MF2_AXIS;
-
- if (i == MT_AXIS)
- {
- // Inverted if uppermost bit is set
- if (mthing->angle & 16384)
- mobj->flags2 |= MF2_AMBUSH;
-
- if (mthing->angle > 0)
- mobj->radius = (mthing->angle & 16383)*FRACUNIT;
- }
- }
- else if (i == MT_TOKEN)
- {
+ break;
+ case MT_TOKEN:
// We advanced tokenbits earlier due to the return check.
// Subtract 1 here for the correct value.
mobj->health = 1 << (tokenbits - 1);
- }
- else if (i == MT_CYBRAKDEMON && mthing->options & MTF_AMBUSH)
- {
- mobj_t *elecmobj;
- elecmobj = P_SpawnMobj(x, y, z, MT_CYBRAKDEMON_ELECTRIC_BARRIER);
- P_SetTarget(&elecmobj->target, mobj);
- elecmobj->angle = FixedAngle(mthing->angle<<FRACBITS);;
- elecmobj->destscale = mobj->scale*2;
- P_SetScale(elecmobj, elecmobj->destscale);
- }
- else if (i == MT_STARPOST)
+ break;
+ case MT_CYBRAKDEMON:
+ if (mthing->options & MTF_AMBUSH)
+ {
+ mobj_t* elecmobj;
+ elecmobj = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_CYBRAKDEMON_ELECTRIC_BARRIER);
+ P_SetTarget(&elecmobj->target, mobj);
+ elecmobj->angle = FixedAngle(mthing->angle << FRACBITS);
+ elecmobj->destscale = mobj->scale*2;
+ P_SetScale(elecmobj, elecmobj->destscale);
+ }
+ break;
+ case MT_STARPOST:
{
- thinker_t *th;
- mobj_t *mo2;
+ thinker_t* th;
+ mobj_t* mo2;
boolean foundanother = false;
- mobj->health = (mthing->angle / 360) + 1;
+ mobj->health = (mthing->angle/360) + 1;
// See if other starposts exist in this level that have the same value.
for (th = thlist[THINK_MOBJ].next; th != &thlist[THINK_MOBJ]; th = th->next)
@@ -12856,7 +12915,7 @@ ML_EFFECT5 : Don't stop thinking when too far away
if (th->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
continue;
- mo2 = (mobj_t *)th;
+ mo2 = (mobj_t*)th;
if (mo2 == mobj)
continue;
@@ -12870,14 +12929,14 @@ ML_EFFECT5 : Don't stop thinking when too far away
if (!foundanother)
numstarposts++;
+ break;
}
- else if (i == MT_SPIKE)
- {
+ case MT_SPIKE:
// Pop up spikes!
if (mthing->options & MTF_OBJECTSPECIAL)
{
mobj->flags &= ~MF_SCENERY;
- mobj->fuse = (16 - mthing->extrainfo) * (mthing->angle + mobj->info->speed) / 16;
+ mobj->fuse = (16 - mthing->extrainfo)*(mthing->angle + mobj->info->speed)/16;
if (mthing->options & MTF_EXTRA)
P_SetMobjState(mobj, mobj->info->meleestate);
}
@@ -12889,14 +12948,13 @@ ML_EFFECT5 : Don't stop thinking when too far away
mobj->flags |= MF_SOLID;
P_SetThingPosition(mobj);
}
- }
- else if (i == MT_WALLSPIKE)
- {
+ break;
+ case MT_WALLSPIKE:
// Pop up spikes!
if (mthing->options & MTF_OBJECTSPECIAL)
{
mobj->flags &= ~MF_SCENERY;
- mobj->fuse = (16 - mthing->extrainfo) * ((mthing->angle/360) + mobj->info->speed) / 16;
+ mobj->fuse = (16 - mthing->extrainfo)*((mthing->angle/360) + mobj->info->speed)/16;
if (mthing->options & MTF_EXTRA)
P_SetMobjState(mobj, mobj->info->meleestate);
}
@@ -12904,64 +12962,51 @@ ML_EFFECT5 : Don't stop thinking when too far away
if (!(mthing->options & MTF_AMBUSH) && !metalrecording)
{
P_UnsetThingPosition(mobj);
- mobj->flags &= ~(MF_NOBLOCKMAP|MF_NOCLIPHEIGHT);
+ mobj->flags &= ~(MF_NOBLOCKMAP | MF_NOCLIPHEIGHT);
mobj->flags |= MF_SOLID;
P_SetThingPosition(mobj);
}
// spawn base
{
- const angle_t mobjangle = FixedAngle(mthing->angle<<FRACBITS); // the mobj's own angle hasn't been set quite yet so...
+ const angle_t mobjangle = FixedAngle(mthing->angle << FRACBITS); // the mobj's own angle hasn't been set quite yet so...
const fixed_t baseradius = mobj->radius - mobj->scale;
- mobj_t *base = P_SpawnMobj(
- mobj->x - P_ReturnThrustX(mobj, mobjangle, baseradius),
- mobj->y - P_ReturnThrustY(mobj, mobjangle, baseradius),
- mobj->z, MT_WALLSPIKEBASE);
+ mobj_t* base = P_SpawnMobj(
+ mobj->x - P_ReturnThrustX(mobj, mobjangle, baseradius),
+ mobj->y - P_ReturnThrustY(mobj, mobjangle, baseradius),
+ mobj->z, MT_WALLSPIKEBASE);
base->angle = mobjangle + ANGLE_90;
base->destscale = mobj->destscale;
P_SetScale(base, mobj->scale);
P_SetTarget(&base->target, mobj);
P_SetTarget(&mobj->tracer, base);
}
- }
-
- //count 10 ring boxes into the number of rings equation too.
- if (i == MT_RING_BOX && nummaprings >= 0)
- nummaprings += 10;
-
- if (i == MT_BIGTUMBLEWEED || i == MT_LITTLETUMBLEWEED)
- {
+ break;
+ case MT_RING_BOX:
+ //count 10 ring boxes into the number of rings equation too.
+ if (nummaprings >= 0)
+ nummaprings += 10;
+ break;
+ case MT_BIGTUMBLEWEED:
+ case MT_LITTLETUMBLEWEED:
if (mthing->options & MTF_AMBUSH)
{
- mobj->momz += FixedMul(16*FRACUNIT, mobj->scale);
-
- if (P_RandomChance(FRACUNIT/2))
- mobj->momx += FixedMul(16*FRACUNIT, mobj->scale);
- else
- mobj->momx -= FixedMul(16*FRACUNIT, mobj->scale);
-
- if (P_RandomChance(FRACUNIT/2))
- mobj->momy += FixedMul(16*FRACUNIT, mobj->scale);
- else
- mobj->momy -= FixedMul(16*FRACUNIT,mobj->scale);
+ fixed_t offset = FixedMul(16*FRACUNIT, mobj->scale);
+ mobj->momx += P_RandomChance(FRACUNIT/2) ? offset : -offset;
+ mobj->momy += P_RandomChance(FRACUNIT/2) ? offset : -offset;
+ mobj->momz += offset;
}
- }
-
- // CTF flag pointers
- if (i == MT_REDFLAG)
- {
+ break;
+ case MT_REDFLAG:
redflag = mobj;
rflagpoint = mobj->spawnpoint;
- }
- if (i == MT_BLUEFLAG)
- {
+ break;
+ case MT_BLUEFLAG:
blueflag = mobj;
bflagpoint = mobj->spawnpoint;
- }
-
- // special push/pull stuff
- if (i == MT_PUSH || i == MT_PULL)
- {
+ break;
+ case MT_PUSH:
+ case MT_PULL:
mobj->health = 0; // Default behaviour: pushing uses XY, fading uses XYZ
if (mthing->options & MTF_AMBUSH)
@@ -12970,92 +13015,110 @@ ML_EFFECT5 : Don't stop thinking when too far away
mobj->health |= 2; // If object special is set, fade using XY
if (G_IsSpecialStage(gamemap))
- {
- if (i == MT_PUSH)
- P_SetMobjState(mobj, S_GRAVWELLGREEN);
- if (i == MT_PULL)
- P_SetMobjState(mobj, S_GRAVWELLRED);
- }
+ P_SetMobjState(mobj, (mobj->type == MT_PUSH) ? S_GRAVWELLGREEN : S_GRAVWELLRED);
+ break;
+ case MT_NIGHTSSTAR:
+ if (maptol & TOL_XMAS)
+ P_SetMobjState(mobj, mobj->info->seestate);
+ break;
+ default:
+ break;
}
- if (doangle)
- mobj->angle = FixedAngle(mthing->angle<<FRACBITS);
+ if (mobj->flags & MF_BOSS)
+ {
+ if (mthing->options & MTF_OBJECTSPECIAL) // No egg trap for this boss
+ mobj->flags2 |= MF2_BOSSNOTRAP;
+ }
- // ignore MTF_ flags and return early
- if (i == MT_NIGHTSBUMPER)
+ return true;
+}
+
+static void P_SetAmbush(mobj_t *mobj)
+{
+ if (mobj->type == MT_YELLOWDIAG || mobj->type == MT_REDDIAG || mobj->type == MT_BLUEDIAG)
+ mobj->angle += ANGLE_22h;
+
+ if (mobj->flags & MF_NIGHTSITEM)
{
- mthing->mobj = mobj;
- return;
+ // Spawn already displayed
+ mobj->flags |= MF_SPECIAL;
+ mobj->flags &= ~MF_NIGHTSITEM;
}
- if ((mthing->options & MTF_AMBUSH)
- && (mthing->options & MTF_OBJECTSPECIAL)
- && (mobj->flags & MF_PUSHABLE))
- mobj->flags2 |= MF2_CLASSICPUSH;
- else
+ if (mobj->flags & MF_PUSHABLE)
+ mobj->flags &= ~MF_PUSHABLE;
+
+ if ((mobj->flags & MF_MONITOR) && mobj->info->speed != 0)
{
- if (mthing->options & MTF_AMBUSH)
- {
- if (i == MT_YELLOWDIAG || i == MT_REDDIAG || i == MT_BLUEDIAG)
- mobj->angle += ANGLE_22h;
+ // flag for strong/weak random boxes
+ // any monitor with nonzero speed is allowed to respawn like this
+ mobj->flags2 |= MF2_AMBUSH;
+ }
- if (i == MT_YELLOWHORIZ || i == MT_REDHORIZ || i == MT_BLUEHORIZ)
- {
- if (mthing->options & MTF_OBJECTFLIP)
- mobj->z -= 16*FRACUNIT;
- else
- mobj->z += 16*FRACUNIT;
- }
+ else if (mobj->type != MT_AXIS &&
+ mobj->type != MT_AXISTRANSFER &&
+ mobj->type != MT_AXISTRANSFERLINE &&
+ mobj->type != MT_NIGHTSBUMPER &&
+ mobj->type != MT_STARPOST)
+ mobj->flags2 |= MF2_AMBUSH;
+}
+static void P_SetObjectSpecial(mobj_t *mobj)
+{
+ if (mobj->type == MT_YELLOWDIAG || mobj->type == MT_REDDIAG || mobj->type == MT_BLUEDIAG)
+ mobj->flags |= MF_NOGRAVITY;
- if (mobj->flags & MF_NIGHTSITEM)
- {
- // Spawn already displayed
- mobj->flags |= MF_SPECIAL;
- mobj->flags &= ~MF_NIGHTSITEM;
- }
+ if ((mobj->flags & MF_MONITOR) && mobj->info->speed != 0)
+ {
+ // flag for strong/weak random boxes
+ // any monitor with nonzero speed is allowed to respawn like this
+ mobj->flags2 |= MF2_STRONGBOX;
+ }
- if (mobj->flags & MF_PUSHABLE)
- mobj->flags &= ~MF_PUSHABLE;
+ // Requires you to be in bonus time to activate
+ if (mobj->flags & MF_NIGHTSITEM)
+ mobj->flags2 |= MF2_STRONGBOX;
- if ((mobj->flags & MF_MONITOR) && mobj->info->speed != 0)
- {
- // flag for strong/weak random boxes
- // any monitor with nonzero speed is allowed to respawn like this
- mobj->flags2 |= MF2_AMBUSH;
- }
+ // Pushables bounce and slide coolly with object special flag set
+ if (mobj->flags & MF_PUSHABLE)
+ {
+ mobj->flags2 |= MF2_SLIDEPUSH;
+ mobj->flags |= MF_BOUNCE;
+ }
+}
- else if (mthing->type != mobjinfo[MT_AXIS].doomednum &&
- mthing->type != mobjinfo[MT_AXISTRANSFER].doomednum &&
- mthing->type != mobjinfo[MT_AXISTRANSFERLINE].doomednum &&
- mthing->type != mobjinfo[MT_NIGHTSBUMPER].doomednum &&
- mthing->type != mobjinfo[MT_STARPOST].doomednum)
- mobj->flags2 |= MF2_AMBUSH;
- }
+static mobj_t *P_SpawnMobjFromMapThing(mapthing_t *mthing, fixed_t x, fixed_t y, fixed_t z, mobjtype_t i)
+{
+ mobj_t *mobj = NULL;
+ boolean doangle = true;
- if (mthing->options & MTF_OBJECTSPECIAL)
- {
- if (i == MT_YELLOWDIAG || i == MT_REDDIAG || i == MT_BLUEDIAG)
- mobj->flags |= MF_NOGRAVITY;
+ mobj = P_SpawnMobj(x, y, z, i);
+ mobj->spawnpoint = mthing;
- if ((mobj->flags & MF_MONITOR) && mobj->info->speed != 0)
- {
- // flag for strong/weak random boxes
- // any monitor with nonzero speed is allowed to respawn like this
- mobj->flags2 |= MF2_STRONGBOX;
- }
+ if (!P_SetupSpawnedMapThing(mthing, mobj, &doangle))
+ return mobj;
+
+ if (doangle)
+ mobj->angle = FixedAngle(mthing->angle << FRACBITS);
+
+ mthing->mobj = mobj;
+
+ // ignore MTF_ flags and return early
+ if (i == MT_NIGHTSBUMPER)
+ return mobj;
- // Requires you to be in bonus time to activate
- if (mobj->flags & MF_NIGHTSITEM)
- mobj->flags2 |= MF2_STRONGBOX;
+ if ((mthing->options & MTF_AMBUSH)
+ && (mthing->options & MTF_OBJECTSPECIAL)
+ && (mobj->flags & MF_PUSHABLE))
+ mobj->flags2 |= MF2_CLASSICPUSH;
+ else
+ {
+ if (mthing->options & MTF_AMBUSH)
+ P_SetAmbush(mobj);
- // Pushables bounce and slide coolly with object special flag set
- if (mobj->flags & MF_PUSHABLE)
- {
- mobj->flags2 |= MF2_SLIDEPUSH;
- mobj->flags |= MF_BOUNCE;
- }
- }
+ if (mthing->options & MTF_OBJECTSPECIAL)
+ P_SetObjectSpecial(mobj);
}
// Generic reverse gravity for individual objects flag.
@@ -13079,579 +13142,334 @@ ML_EFFECT5 : Don't stop thinking when too far away
if (mobj->flags & MF_NIGHTSITEM)
mobj->flags2 |= MF2_DONTDRAW;
- mthing->mobj = mobj;
+ return mobj;
}
-void P_SpawnHoopsAndRings(mapthing_t *mthing, boolean bonustime)
+//
+// P_SpawnMapThing
+// The fields of the mapthing should
+// already be in host byte order.
+//
+mobj_t *P_SpawnMapThing(mapthing_t *mthing)
{
- mobjtype_t ringthing = MT_RING;
+ mobjtype_t i;
mobj_t *mobj = NULL;
- INT32 r, i;
- fixed_t x, y, z, finalx, finaly, finalz;
- sector_t *sec;
- TVector v, *res;
- angle_t closestangle, fa;
- boolean nightsreplace = ((maptol & TOL_NIGHTS) && !G_IsSpecialStage(gamemap));
-
- x = mthing->x << FRACBITS;
- y = mthing->y << FRACBITS;
-
- sec = R_PointInSubsector(x, y)->sector;
-
- // NiGHTS hoop!
- if (mthing->type == 1705)
- {
- mobj_t *nextmobj = NULL;
- mobj_t *hoopcenter;
- INT16 spewangle;
-
- z = mthing->options << FRACBITS;
-
- hoopcenter = P_SpawnMobj(x, y, z, MT_HOOPCENTER);
+ fixed_t x, y, z;
- hoopcenter->spawnpoint = mthing;
+ if (!mthing->type)
+ return mobj; // Ignore type-0 things as NOPs
- // Screw these damn hoops, I need this thinker.
- //hoopcenter->flags |= MF_NOTHINK;
+ if (mthing->type == 3328) // 3D Mode start Thing
+ return mobj;
- z +=
-#ifdef ESLOPE
- sec->f_slope ? P_GetZAt(sec->f_slope, x, y) :
-#endif
- sec->floorheight;
+ if (!objectplacing && P_SpawnNonMobjMapThing(mthing))
+ return mobj;
- hoopcenter->z = z - hoopcenter->height/2;
+ i = P_GetMobjtype(mthing->type);
+ if (i == MT_UNKNOWN)
+ CONS_Alert(CONS_WARNING, M_GetText("Unknown thing type %d placed at (%d, %d)\n"), mthing->type, mthing->x, mthing->y);
- P_UnsetThingPosition(hoopcenter);
- hoopcenter->x = x;
- hoopcenter->y = y;
- P_SetThingPosition(hoopcenter);
+ // Skip all returning/substitution code in objectplace.
+ if (!objectplacing)
+ {
+ if (!P_AllowMobjSpawn(mthing, i))
+ return mobj;
- // Scale 0-255 to 0-359 =(
- closestangle = FixedAngle(FixedMul((mthing->angle>>8)*FRACUNIT,
- 360*(FRACUNIT/256)));
+ i = P_GetMobjtypeSubstitute(mthing, i);
+ if (i == MT_NULL) // Don't spawn mobj
+ return mobj;
+ }
- hoopcenter->movedir = FixedInt(FixedMul((mthing->angle&255)*FRACUNIT,
- 360*(FRACUNIT/256)));
- hoopcenter->movecount = FixedInt(AngleFixed(closestangle));
+ x = mthing->x << FRACBITS;
+ y = mthing->y << FRACBITS;
+ z = P_GetMapThingSpawnHeight(i, mthing, x, y);
+ return P_SpawnMobjFromMapThing(mthing, x, y, z, i);
+}
- // For the hoop when it flies away
- hoopcenter->extravalue1 = 32;
- hoopcenter->extravalue2 = 8 * FRACUNIT;
+static void P_SpawnHoopInternal(mapthing_t *mthing, INT32 hoopsize, fixed_t sizefactor)
+{
+ mobj_t *mobj = NULL;
+ mobj_t *nextmobj = NULL;
+ mobj_t *hoopcenter;
+ TMatrix *pitchmatrix, *yawmatrix;
+ fixed_t radius = hoopsize*sizefactor;
+ INT32 i;
+ angle_t fa;
+ TVector v, *res;
+ fixed_t x = mthing->x << FRACBITS;
+ fixed_t y = mthing->y << FRACBITS;
+ fixed_t z = P_GetMobjSpawnHeight(MT_HOOP, x, y, mthing->z << FRACBITS, false);
- spewangle = (INT16)hoopcenter->movedir;
+ hoopcenter = P_SpawnMobj(x, y, z, MT_HOOPCENTER);
+ hoopcenter->spawnpoint = mthing;
+ hoopcenter->z -= hoopcenter->height/2;
- // Create the hoop!
- for (i = 0; i < 32; i++)
- {
- fa = i*(FINEANGLES/32);
- v[0] = FixedMul(FINECOSINE(fa),96*FRACUNIT);
- v[1] = 0;
- v[2] = FixedMul(FINESINE(fa),96*FRACUNIT);
- v[3] = FRACUNIT;
+ P_UnsetThingPosition(hoopcenter);
+ hoopcenter->x = x;
+ hoopcenter->y = y;
+ P_SetThingPosition(hoopcenter);
- res = VectorMatrixMultiply(v, *RotateXMatrix(FixedAngle(spewangle*FRACUNIT)));
- M_Memcpy(&v, res, sizeof (v));
- res = VectorMatrixMultiply(v, *RotateZMatrix(closestangle));
- M_Memcpy(&v, res, sizeof (v));
+ // Scale 0-255 to 0-359 =(
+ hoopcenter->movedir = ((mthing->angle & 255)*360)/256; // Pitch
+ pitchmatrix = RotateXMatrix(FixedAngle(hoopcenter->movedir << FRACBITS));
+ hoopcenter->movecount = (((UINT16)mthing->angle >> 8)*360)/256; // Yaw
+ yawmatrix = RotateZMatrix(FixedAngle(hoopcenter->movecount << FRACBITS));
- finalx = x + v[0];
- finaly = y + v[1];
- finalz = z + v[2];
+ // For the hoop when it flies away
+ hoopcenter->extravalue1 = hoopsize;
+ hoopcenter->extravalue2 = radius/12;
- mobj = P_SpawnMobj(finalx, finaly, finalz, MT_HOOP);
+ // Create the hoop!
+ for (i = 0; i < hoopsize; i++)
+ {
+ fa = i*(FINEANGLES/hoopsize);
+ v[0] = FixedMul(FINECOSINE(fa), radius);
+ v[1] = 0;
+ v[2] = FixedMul(FINESINE(fa), radius);
+ v[3] = FRACUNIT;
- if (maptol & TOL_XMAS)
- P_SetMobjState(mobj, mobj->info->seestate + (i & 1));
+ res = VectorMatrixMultiply(v, *pitchmatrix);
+ M_Memcpy(&v, res, sizeof(v));
+ res = VectorMatrixMultiply(v, *yawmatrix);
+ M_Memcpy(&v, res, sizeof(v));
- mobj->z -= mobj->height/2;
- P_SetTarget(&mobj->target, hoopcenter); // Link the sprite to the center.
- mobj->fuse = 0;
+ mobj = P_SpawnMobj(x + v[0], y + v[1], z + v[2], MT_HOOP);
+ mobj->z -= mobj->height/2;
- // Link all the sprites in the hoop together
- if (nextmobj)
- {
- P_SetTarget(&mobj->hprev, nextmobj);
- P_SetTarget(&mobj->hprev->hnext, mobj);
- }
- else
- P_SetTarget(&mobj->hprev, P_SetTarget(&mobj->hnext, NULL));
+ if (maptol & TOL_XMAS)
+ P_SetMobjState(mobj, mobj->info->seestate + (i & 1));
- nextmobj = mobj;
- }
+ P_SetTarget(&mobj->target, hoopcenter); // Link the sprite to the center.
+ mobj->fuse = 0;
- // Create the collision detectors!
- for (i = 0; i < 16; i++)
+ // Link all the sprites in the hoop together
+ if (nextmobj)
{
- fa = i*FINEANGLES/16;
- v[0] = FixedMul(FINECOSINE(fa),32*FRACUNIT);
- v[1] = 0;
- v[2] = FixedMul(FINESINE(fa),32*FRACUNIT);
- v[3] = FRACUNIT;
- res = VectorMatrixMultiply(v, *RotateXMatrix(FixedAngle(spewangle*FRACUNIT)));
- M_Memcpy(&v, res, sizeof (v));
- res = VectorMatrixMultiply(v, *RotateZMatrix(closestangle));
- M_Memcpy(&v, res, sizeof (v));
-
- finalx = x + v[0];
- finaly = y + v[1];
- finalz = z + v[2];
-
- mobj = P_SpawnMobj(finalx, finaly, finalz, MT_HOOPCOLLIDE);
- mobj->z -= mobj->height/2;
-
- // Link all the collision sprites together.
- P_SetTarget(&mobj->hnext, NULL);
P_SetTarget(&mobj->hprev, nextmobj);
P_SetTarget(&mobj->hprev->hnext, mobj);
-
- nextmobj = mobj;
}
- // Create the collision detectors!
- for (i = 0; i < 16; i++)
- {
- fa = i*FINEANGLES/16;
- v[0] = FixedMul(FINECOSINE(fa),64*FRACUNIT);
- v[1] = 0;
- v[2] = FixedMul(FINESINE(fa),64*FRACUNIT);
- v[3] = FRACUNIT;
- res = VectorMatrixMultiply(v, *RotateXMatrix(FixedAngle(spewangle*FRACUNIT)));
- M_Memcpy(&v, res, sizeof (v));
- res = VectorMatrixMultiply(v, *RotateZMatrix(closestangle));
- M_Memcpy(&v, res, sizeof (v));
-
- finalx = x + v[0];
- finaly = y + v[1];
- finalz = z + v[2];
-
- mobj = P_SpawnMobj(finalx, finaly, finalz, MT_HOOPCOLLIDE);
- mobj->z -= mobj->height/2;
-
- // Link all the collision sprites together.
- P_SetTarget(&mobj->hnext, NULL);
- P_SetTarget(&mobj->hprev, nextmobj);
- P_SetTarget(&mobj->hprev->hnext, mobj);
+ else
+ P_SetTarget(&mobj->hprev, P_SetTarget(&mobj->hnext, NULL));
- nextmobj = mobj;
- }
- return;
+ nextmobj = mobj;
}
- // CUSTOMIZABLE NiGHTS hoop!
- else if (mthing->type == 1713)
- {
- mobj_t *nextmobj = NULL;
- mobj_t *hoopcenter;
- INT16 spewangle;
- INT32 hoopsize;
- INT32 hoopplacement;
-
- // Save our flags!
- z = (mthing->options>>ZSHIFT) << FRACBITS;
-
- hoopcenter = P_SpawnMobj(x, y, z, MT_HOOPCENTER);
- hoopcenter->spawnpoint = mthing;
- z +=
-#ifdef ESLOPE
- sec->f_slope ? P_GetZAt(sec->f_slope, x, y) :
-#endif
- sec->floorheight;
- hoopcenter->z = z - hoopcenter->height/2;
-
- P_UnsetThingPosition(hoopcenter);
- hoopcenter->x = x;
- hoopcenter->y = y;
- P_SetThingPosition(hoopcenter);
-
- // Scale 0-255 to 0-359 =(
- closestangle = FixedAngle(FixedMul((mthing->angle>>8)*FRACUNIT,
- 360*(FRACUNIT/256)));
-
- hoopcenter->movedir = FixedInt(FixedMul((mthing->angle&255)*FRACUNIT,
- 360*(FRACUNIT/256)));
- hoopcenter->movecount = FixedInt(AngleFixed(closestangle));
-
- spewangle = (INT16)hoopcenter->movedir;
-
- // Super happy fun time
- // For each flag add 4 fracunits to the size
- // Default (0 flags) is 8 fracunits
- hoopsize = 8 + (4 * (mthing->options & 0xF));
- hoopplacement = hoopsize * (4*FRACUNIT);
+ // Create the collision detectors!
+ // Create them until the size is less than 8
+ // But always create at least ONE set of collision detectors
+ do
+ {
+ if (hoopsize >= 32)
+ hoopsize -= 16;
+ else
+ hoopsize /= 2;
- // For the hoop when it flies away
- hoopcenter->extravalue1 = hoopsize;
- hoopcenter->extravalue2 = FixedDiv(hoopplacement, 12*FRACUNIT);
+ radius = hoopsize*sizefactor;
- // Create the hoop!
for (i = 0; i < hoopsize; i++)
{
fa = i*(FINEANGLES/hoopsize);
- v[0] = FixedMul(FINECOSINE(fa), hoopplacement);
+ v[0] = FixedMul(FINECOSINE(fa), radius);
v[1] = 0;
- v[2] = FixedMul(FINESINE(fa), hoopplacement);
+ v[2] = FixedMul(FINESINE(fa), radius);
v[3] = FRACUNIT;
- res = VectorMatrixMultiply(v, *RotateXMatrix(FixedAngle(spewangle*FRACUNIT)));
- M_Memcpy(&v, res, sizeof (v));
- res = VectorMatrixMultiply(v, *RotateZMatrix(closestangle));
- M_Memcpy(&v, res, sizeof (v));
-
- finalx = x + v[0];
- finaly = y + v[1];
- finalz = z + v[2];
-
- mobj = P_SpawnMobj(finalx, finaly, finalz, MT_HOOP);
-
- if (maptol & TOL_XMAS)
- P_SetMobjState(mobj, mobj->info->seestate + (i & 1));
+ res = VectorMatrixMultiply(v, *pitchmatrix);
+ M_Memcpy(&v, res, sizeof(v));
+ res = VectorMatrixMultiply(v, *yawmatrix);
+ M_Memcpy(&v, res, sizeof(v));
+ mobj = P_SpawnMobj(x + v[0], y + v[1], z + v[2], MT_HOOPCOLLIDE);
mobj->z -= mobj->height/2;
- P_SetTarget(&mobj->target, hoopcenter); // Link the sprite to the center.
- mobj->fuse = 0;
- // Link all the sprites in the hoop together
- if (nextmobj)
- {
- P_SetTarget(&mobj->hprev, nextmobj);
- P_SetTarget(&mobj->hprev->hnext, mobj);
- }
- else
- P_SetTarget(&mobj->hprev, P_SetTarget(&mobj->hnext, NULL));
+ // Link all the collision sprites together.
+ P_SetTarget(&mobj->hnext, NULL);
+ P_SetTarget(&mobj->hprev, nextmobj);
+ P_SetTarget(&mobj->hprev->hnext, mobj);
nextmobj = mobj;
}
+ } while (hoopsize >= 8);
+}
- // Create the collision detectors!
- // Create them until the size is less than 8
- // But always create at least ONE set of collision detectors
- do
- {
- if (hoopsize >= 32)
- hoopsize -= 16;
- else
- hoopsize /= 2;
-
- hoopplacement = hoopsize * (4*FRACUNIT);
-
- for (i = 0; i < hoopsize; i++)
- {
- fa = i*FINEANGLES/hoopsize;
- v[0] = FixedMul(FINECOSINE(fa), hoopplacement);
- v[1] = 0;
- v[2] = FixedMul(FINESINE(fa), hoopplacement);
- v[3] = FRACUNIT;
- res = VectorMatrixMultiply(v, *RotateXMatrix(FixedAngle(spewangle*FRACUNIT)));
- M_Memcpy(&v, res, sizeof (v));
- res = VectorMatrixMultiply(v, *RotateZMatrix(closestangle));
- M_Memcpy(&v, res, sizeof (v));
-
- finalx = x + v[0];
- finaly = y + v[1];
- finalz = z + v[2];
-
- mobj = P_SpawnMobj(finalx, finaly, finalz, MT_HOOPCOLLIDE);
- mobj->z -= mobj->height/2;
-
- // Link all the collision sprites together.
- P_SetTarget(&mobj->hnext, NULL);
- P_SetTarget(&mobj->hprev, nextmobj);
- P_SetTarget(&mobj->hprev->hnext, mobj);
+void P_SpawnHoop(mapthing_t *mthing)
+{
+ if (metalrecording)
+ return;
- nextmobj = mobj;
- }
- } while (hoopsize >= 8);
+ if (mthing->type == 1705) // Generic hoop
+ P_SpawnHoopInternal(mthing, 24, 4*FRACUNIT);
+ else // Customizable hoop
+ // For each flag add 16 fracunits to the size
+ // Default (0 flags) is 32 fracunits
+ P_SpawnHoopInternal(mthing, 8 + (4*(mthing->options & 0xF)), 4*FRACUNIT);
+}
+void P_SetBonusTime(mobj_t *mobj)
+{
+ if (!mobj)
return;
- }
- // ***
- // Special placement patterns
- // ***
-
- // Vertical Rings - Stack of 5 (handles both red and yellow)
- else if (mthing->type == 600 || mthing->type == 601)
- {
- INT32 dist = 64*FRACUNIT;
- if (mthing->type == 601)
- dist = 128*FRACUNIT;
- if (ultimatemode)
- return; // No rings in Ultimate!
+ if (mobj->type != MT_BLUESPHERE && mobj->type != MT_NIGHTSCHIP)
+ return;
- if (nightsreplace)
- ringthing = MT_NIGHTSSTAR;
+ P_SetMobjState(mobj, mobj->info->raisestate);
+}
- if (mthing->options & MTF_OBJECTFLIP)
- {
- z = (
-#ifdef ESLOPE
- sec->c_slope ? P_GetZAt(sec->c_slope, x, y) :
-#endif
- sec->ceilingheight) - mobjinfo[ringthing].height;
- if (mthing->options >> ZSHIFT)
- z -= ((mthing->options >> ZSHIFT) << FRACBITS);
- }
- else
- {
- z = (
-#ifdef ESLOPE
- sec->f_slope ? P_GetZAt(sec->f_slope, x, y) :
-#endif
- sec->floorheight);
- if (mthing->options >> ZSHIFT)
- z += ((mthing->options >> ZSHIFT) << FRACBITS);
- }
+static void P_SpawnItemRow(mapthing_t *mthing, mobjtype_t* itemtypes, UINT8 numitemtypes, INT32 numitems, fixed_t horizontalspacing, fixed_t verticalspacing, INT16 fixedangle, boolean bonustime)
+{
+ mapthing_t dummything;
+ mobj_t *mobj = NULL;
+ fixed_t x = mthing->x << FRACBITS;
+ fixed_t y = mthing->y << FRACBITS;
+ fixed_t z = mthing->z << FRACBITS;
+ INT32 r;
+ angle_t angle = FixedAngle(fixedangle << FRACBITS);
+ angle_t fineangle = (angle >> ANGLETOFINESHIFT) & FINEMASK;
- for (r = 1; r <= 5; r++)
+ for (r = 0; r < numitemtypes; r++)
+ {
+ dummything = *mthing;
+ dummything.type = mobjinfo[itemtypes[r]].doomednum;
+ // Skip all returning/substitution code in objectplace.
+ if (!objectplacing)
{
- if (mthing->options & MTF_OBJECTFLIP)
- z -= dist;
- else
- z += dist;
-
- mobj = P_SpawnMobj(x, y, z, ringthing);
-
- if (mthing->options & MTF_OBJECTFLIP)
+ if (!P_AllowMobjSpawn(&dummything, itemtypes[r]))
{
- mobj->eflags |= MFE_VERTICALFLIP;
- mobj->flags2 |= MF2_OBJECTFLIP;
+ itemtypes[r] = MT_NULL;
+ continue;
}
- mobj->angle = FixedAngle(mthing->angle*FRACUNIT);
- if (mthing->options & MTF_AMBUSH)
- mobj->flags2 |= MF2_AMBUSH;
-
- if ((maptol & TOL_XMAS) && (ringthing == MT_NIGHTSSTAR))
- P_SetMobjState(mobj, mobj->info->seestate);
+ itemtypes[r] = P_GetMobjtypeSubstitute(&dummything, itemtypes[r]);
}
}
- // Diagonal rings (handles both types)
- else if (mthing->type == 602 || mthing->type == 603) // Diagonal rings (5)
- {
- INT32 iterations = 5;
- if (mthing->type == 603)
- iterations = 10;
-
- if (ultimatemode)
- return; // No rings in Ultimate!
-
- if (nightsreplace)
- ringthing = MT_NIGHTSSTAR;
-
- closestangle = FixedAngle(mthing->angle*FRACUNIT);
- fa = (closestangle >> ANGLETOFINESHIFT);
-
- if (mthing->options & MTF_OBJECTFLIP)
- {
- z = (
-#ifdef ESLOPE
- sec->c_slope ? P_GetZAt(sec->c_slope, x, y) :
-#endif
- sec->ceilingheight) - mobjinfo[ringthing].height;
- if (mthing->options >> ZSHIFT)
- z -= ((mthing->options >> ZSHIFT) << FRACBITS);
- }
- else
- {
- z = (
-#ifdef ESLOPE
- sec->f_slope ? P_GetZAt(sec->f_slope, x, y) :
-#endif
- sec->floorheight);
- if (mthing->options >> ZSHIFT)
- z += ((mthing->options >> ZSHIFT) << FRACBITS);
- }
-
- for (r = 1; r <= iterations; r++)
- {
- x += FixedMul(64*FRACUNIT, FINECOSINE(fa));
- y += FixedMul(64*FRACUNIT, FINESINE(fa));
+ z = P_GetMobjSpawnHeight(itemtypes[0], x, y, z, mthing->options & MTF_OBJECTFLIP);
- if (mthing->options & MTF_OBJECTFLIP)
- z -= 64*FRACUNIT;
- else
- z += 64*FRACUNIT;
+ for (r = 0; r < numitems; r++)
+ {
+ mobjtype_t itemtype = itemtypes[r % numitemtypes];
+ if (itemtype == MT_NULL)
+ continue;
+ dummything.type = mobjinfo[itemtype].doomednum;
- mobj = P_SpawnMobj(x, y, z, ringthing);
+ x += FixedMul(horizontalspacing, FINECOSINE(fineangle));
+ y += FixedMul(horizontalspacing, FINESINE(fineangle));
+ z += (mthing->options & MTF_OBJECTFLIP) ? -verticalspacing : verticalspacing;
- if (mthing->options & MTF_OBJECTFLIP)
- {
- mobj->eflags |= MFE_VERTICALFLIP;
- mobj->flags2 |= MF2_OBJECTFLIP;
- }
+ mobj = P_SpawnMobjFromMapThing(&dummything, x, y, z, itemtype);
- mobj->angle = closestangle;
- if (mthing->options & MTF_AMBUSH)
- mobj->flags2 |= MF2_AMBUSH;
+ if (!mobj)
+ continue;
- if ((maptol & TOL_XMAS) && (ringthing == MT_NIGHTSSTAR))
- P_SetMobjState(mobj, mobj->info->seestate);
- }
+ mobj->spawnpoint = NULL;
+ if (bonustime)
+ P_SetBonusTime(mobj);
}
- // Rings of items (all six of them)
- else if (mthing->type >= 604 && mthing->type <= 609)
- {
- INT32 numitems = 8;
- INT32 size = 96*FRACUNIT;
-
- if (mthing->type & 1)
- {
- numitems = 16;
- size = 192*FRACUNIT;
- }
-
- z =
-#ifdef ESLOPE
- sec->f_slope ? P_GetZAt(sec->f_slope, x, y) :
-#endif
- sec->floorheight;
- if (mthing->options >> ZSHIFT)
- z += ((mthing->options >> ZSHIFT) << FRACBITS);
+}
- closestangle = FixedAngle(mthing->angle*FRACUNIT);
+static void P_SpawnSingularItemRow(mapthing_t* mthing, mobjtype_t itemtype, INT32 numitems, fixed_t horizontalspacing, fixed_t verticalspacing, INT16 fixedangle, boolean bonustime)
+{
+ mobjtype_t itemtypes[1] = { itemtype };
+ return P_SpawnItemRow(mthing, itemtypes, 1, numitems, horizontalspacing, verticalspacing, fixedangle, bonustime);
+}
- switch (mthing->type)
- {
- case 604:
- case 605:
- if (ultimatemode)
- return; // No rings in Ultimate!
- if (nightsreplace)
- ringthing = MT_NIGHTSSTAR;
- break;
- case 608:
- case 609:
- /*ringthing = (i & 1) ? MT_RING : MT_BLUESPHERE; -- i == 0 is bluesphere
- break;*/
- case 606:
- case 607:
- ringthing = (nightsreplace) ? MT_NIGHTSCHIP : MT_BLUESPHERE;
- break;
- default:
- break;
- }
+static void P_SpawnItemCircle(mapthing_t *mthing, mobjtype_t *itemtypes, UINT8 numitemtypes, INT32 numitems, fixed_t size, boolean bonustime)
+{
+ mapthing_t dummything;
+ mobj_t* mobj = NULL;
+ fixed_t x = mthing->x << FRACBITS;
+ fixed_t y = mthing->y << FRACBITS;
+ fixed_t z = mthing->z << FRACBITS;
+ angle_t angle = FixedAngle(mthing->angle << FRACBITS);
+ angle_t fa;
+ INT32 i;
+ TVector v, *res;
- // Create the hoop!
- for (i = 0; i < numitems; i++)
+ for (i = 0; i < numitemtypes; i++)
+ {
+ dummything = *mthing;
+ dummything.type = mobjinfo[itemtypes[i]].doomednum;
+ // Skip all returning/substitution code in objectplace.
+ if (!objectplacing)
{
- if (mthing->type == 608 || mthing->type == 609)
- {
- if (i & 1)
- {
- if (ultimatemode)
- continue; // No rings in Ultimate!
- ringthing = (nightsreplace) ? MT_NIGHTSSTAR : MT_RING;
- }
- else
- ringthing = (nightsreplace) ? MT_NIGHTSCHIP : MT_BLUESPHERE;
- }
-
- fa = i*FINEANGLES/numitems;
- v[0] = FixedMul(FINECOSINE(fa),size);
- v[1] = 0;
- v[2] = FixedMul(FINESINE(fa),size);
- v[3] = FRACUNIT;
-
- res = VectorMatrixMultiply(v, *RotateZMatrix(closestangle));
- M_Memcpy(&v, res, sizeof (v));
-
- finalx = x + v[0];
- finaly = y + v[1];
- finalz = z + v[2];
-
- mobj = P_SpawnMobj(finalx, finaly, finalz, ringthing);
- mobj->z -= mobj->height/2;
-
- if (mthing->options & MTF_OBJECTFLIP)
+ if (!P_AllowMobjSpawn(&dummything, itemtypes[i]))
{
- mobj->eflags |= MFE_VERTICALFLIP;
- mobj->flags2 |= MF2_OBJECTFLIP;
+ itemtypes[i] = MT_NULL;
+ continue;
}
- mobj->angle = closestangle;
- if (mthing->options & MTF_AMBUSH)
- mobj->flags2 |= MF2_AMBUSH;
-
- if (bonustime && (ringthing == MT_BLUESPHERE || ringthing == MT_NIGHTSCHIP))
- P_SetMobjState(mobj, mobj->info->raisestate);
- else if ((maptol & TOL_XMAS) && (ringthing == MT_NIGHTSSTAR))
- P_SetMobjState(mobj, mobj->info->seestate);
+ itemtypes[i] = P_GetMobjtypeSubstitute(&dummything, itemtypes[i]);
}
}
- // All manners of rings and coins
- else
- {
-
- // Which ringthing to use
- if (mthing->type == mobjinfo[MT_BLUESPHERE].doomednum)
- ringthing = (nightsreplace) ? MT_NIGHTSCHIP : MT_BLUESPHERE;
- else if (mthing->type == mobjinfo[MT_BOMBSPHERE].doomednum)
- ringthing = MT_BOMBSPHERE;
- else
- {
- if (ultimatemode)
- return; // No rings in Ultimate!
+ z = P_GetMobjSpawnHeight(itemtypes[0], x, y, z, false);
- if (nightsreplace)
- ringthing = MT_NIGHTSSTAR;
- else if (mthing->type == mobjinfo[MT_COIN].doomednum)
- ringthing = MT_COIN;
- else if (mthing->type == mobjinfo[MT_REDTEAMRING].doomednum) // No team rings in non-CTF
- ringthing = (gametype == GT_CTF) ? MT_REDTEAMRING : MT_RING;
- else if (mthing->type == mobjinfo[MT_BLUETEAMRING].doomednum) // Ditto
- ringthing = (gametype == GT_CTF) ? MT_BLUETEAMRING : MT_RING;
- }
-
- // Set proper height
- if (mthing->options & MTF_OBJECTFLIP)
- {
- z = (
-#ifdef ESLOPE
- sec->c_slope ? P_GetZAt(sec->c_slope, x, y) :
-#endif
- sec->ceilingheight) - mobjinfo[ringthing].height;
- if (mthing->options >> ZSHIFT)
- z -= ((mthing->options >> ZSHIFT) << FRACBITS);
- }
- else
- {
- z =
-#ifdef ESLOPE
- sec->f_slope ? P_GetZAt(sec->f_slope, x, y) :
-#endif
- sec->floorheight;
- if (mthing->options >> ZSHIFT)
- z += ((mthing->options >> ZSHIFT) << FRACBITS);
- }
+ for (i = 0; i < numitems; i++)
+ {
+ mobjtype_t itemtype = itemtypes[i % numitemtypes];
+ if (itemtype == MT_NULL)
+ continue;
+ dummything.type = mobjinfo[itemtype].doomednum;
- if (mthing->options & MTF_AMBUSH) // Special flag for rings
- {
- if (mthing->options & MTF_OBJECTFLIP)
- z -= 24*FRACUNIT;
- else
- z += 24*FRACUNIT;
- }
+ fa = i*FINEANGLES/numitems;
+ v[0] = FixedMul(FINECOSINE(fa), size);
+ v[1] = 0;
+ v[2] = FixedMul(FINESINE(fa), size);
+ v[3] = FRACUNIT;
- mthing->z = (INT16)(z>>FRACBITS);
+ res = VectorMatrixMultiply(v, *RotateZMatrix(angle));
+ M_Memcpy(&v, res, sizeof(v));
- mobj = P_SpawnMobj(x, y, z, ringthing);
- mobj->spawnpoint = mthing;
+ mobj = P_SpawnMobjFromMapThing(&dummything, x + v[0], y + v[1], z + v[2], itemtype);
- if (mthing->options & MTF_OBJECTFLIP)
- {
- mobj->eflags |= MFE_VERTICALFLIP;
- mobj->flags2 |= MF2_OBJECTFLIP;
- }
+ if (!mobj)
+ continue;
- mobj->angle = FixedAngle(mthing->angle*FRACUNIT);
- mthing->mobj = mobj;
- if (mthing->options & MTF_AMBUSH)
- mobj->flags2 |= MF2_AMBUSH;
+ mobj->z -= mobj->height/2;
+ mobj->spawnpoint = NULL;
+ if (bonustime)
+ P_SetBonusTime(mobj);
+ }
+}
- if (bonustime && (ringthing == MT_BLUESPHERE || ringthing == MT_NIGHTSCHIP))
- P_SetMobjState(mobj, mobj->info->raisestate);
- else if ((maptol & TOL_XMAS) && (ringthing == MT_NIGHTSSTAR))
- P_SetMobjState(mobj, mobj->info->seestate);
+void P_SpawnItemPattern(mapthing_t *mthing, boolean bonustime)
+{
+ switch (mthing->type)
+ {
+ // Special placement patterns
+ case 600: // 5 vertical rings (yellow spring)
+ P_SpawnSingularItemRow(mthing, MT_RING, 5, 0, 64*FRACUNIT, 0, bonustime);
+ return;
+ case 601: // 5 vertical rings (red spring)
+ P_SpawnSingularItemRow(mthing, MT_RING, 5, 0, 128*FRACUNIT, 0, bonustime);
+ return;
+ case 602: // 5 diagonal rings (yellow spring)
+ P_SpawnSingularItemRow(mthing, MT_RING, 5, 64*FRACUNIT, 64*FRACUNIT, mthing->angle, bonustime);
+ return;
+ case 603: // 10 diagonal rings (red spring)
+ P_SpawnSingularItemRow(mthing, MT_RING, 10, 64*FRACUNIT, 64*FRACUNIT, mthing->angle, bonustime);
+ return;
+ case 604: // Circle of rings (8 items)
+ case 605: // Circle of rings (16 items)
+ case 606: // Circle of blue spheres (8 items)
+ case 607: // Circle of blue spheres (16 items)
+ {
+ INT32 numitems = (mthing->type & 1) ? 16 : 8;
+ fixed_t size = (mthing->type & 1) ? 192*FRACUNIT : 96*FRACUNIT;
+ mobjtype_t itemtypes[1] = { (mthing->type < 606) ? MT_RING : MT_BLUESPHERE };
+ P_SpawnItemCircle(mthing, itemtypes, 1, numitems, size, bonustime);
+ return;
+ }
+ case 608: // Circle of rings and blue spheres (8 items)
+ case 609: // Circle of rings and blue spheres (16 items)
+ {
+ INT32 numitems = (mthing->type & 1) ? 16 : 8;
+ fixed_t size = (mthing->type & 1) ? 192*FRACUNIT : 96*FRACUNIT;
+ mobjtype_t itemtypes[2] = { MT_RING, MT_BLUESPHERE };
+ P_SpawnItemCircle(mthing, itemtypes, 2, numitems, size, bonustime);
+ return;
+ }
+ default:
+ return;
}
}
diff --git a/src/p_mobj.h b/src/p_mobj.h
index 40d850f166ca890d812a5004d08f3bde0ec58676..92160d9e2d70f4634d90d47feed67cfa5940b1a9 100644
--- a/src/p_mobj.h
+++ b/src/p_mobj.h
@@ -279,9 +279,7 @@ typedef struct mobj_s
// More drawing info: to determine current sprite.
angle_t angle; // orientation
-#ifdef ROTSPRITE
angle_t rollangle;
-#endif
spritenum_t sprite; // used to find patch_t and flip value
UINT32 frame; // frame number, plus bits see p_pspr.h
UINT8 sprite2; // player sprites
@@ -402,9 +400,7 @@ typedef struct precipmobj_s
// More drawing info: to determine current sprite.
angle_t angle; // orientation
-#ifdef ROTSPRITE
angle_t rollangle;
-#endif
spritenum_t sprite; // used to find patch_t and flip value
UINT32 frame; // frame number, plus bits see p_pspr.h
UINT8 sprite2; // player sprites
@@ -456,8 +452,10 @@ void P_MovePlayerToSpawn(INT32 playernum, mapthing_t *mthing);
void P_MovePlayerToStarpost(INT32 playernum);
void P_AfterPlayerSpawn(INT32 playernum);
-void P_SpawnMapThing(mapthing_t *mthing);
-void P_SpawnHoopsAndRings(mapthing_t *mthing, boolean bonustime);
+mobj_t *P_SpawnMapThing(mapthing_t *mthing);
+void P_SpawnHoop(mapthing_t *mthing);
+void P_SetBonusTime(mobj_t *mobj);
+void P_SpawnItemPattern(mapthing_t *mthing, boolean bonustime);
void P_SpawnHoopOfSomething(fixed_t x, fixed_t y, fixed_t z, fixed_t radius, INT32 number, mobjtype_t type, angle_t rotangle);
void P_SpawnPrecipitation(void);
void P_SpawnParaloop(fixed_t x, fixed_t y, fixed_t z, fixed_t radius, INT32 number, mobjtype_t type, statenum_t nstate, angle_t rotangle, boolean spawncenter);
diff --git a/src/p_polyobj.c b/src/p_polyobj.c
index 6637d238c521e0a6a167189c74f41db78d0922e5..cd0a44bb4a78e913addbd4e91a64cc1791c30b2a 100644
--- a/src/p_polyobj.c
+++ b/src/p_polyobj.c
@@ -400,6 +400,8 @@ static void Polyobj_findSegs(polyobj_t *po, seg_t *seg)
// Find backfacings
for (s = 0; s < numsegs; s++)
{
+ if (segs[s].glseg)
+ continue;
if (segs[s].linedef == seg->linedef
&& segs[s].side == 1)
{
@@ -436,6 +438,8 @@ newseg:
// seg's ending vertex.
for (i = 0; i < numsegs; ++i)
{
+ if (segs[i].glseg)
+ continue;
if (segs[i].side != 0) // needs to be frontfacing
continue;
if (segs[i].v1->x == seg->v2->x && segs[i].v1->y == seg->v2->y)
@@ -460,6 +464,9 @@ newseg:
// Find backfacings
for (q = 0; q < numsegs; q++)
{
+ if (segs[q].glseg)
+ continue;
+
if (segs[q].linedef == segs[i].linedef
&& segs[q].side == 1)
{
@@ -606,6 +613,9 @@ static void Polyobj_spawnPolyObj(INT32 num, mobj_t *spawnSpot, INT32 id)
INT32 poflags = POF_SOLID|POF_TESTHEIGHT|POF_RENDERSIDES;
INT32 parentID = 0, potrans = 0;
+ if (seg->glseg)
+ continue;
+
if (seg->side != 0) // needs to be frontfacing
continue;
@@ -1815,6 +1825,7 @@ void T_PolyObjWaypoint(polywaypoint_t *th)
if (po->thinker == NULL)
po->thinker = &th->thinker;
+/*
// Find out target first.
// We redo this each tic to make savegame compatibility easier.
for (wp = thlist[THINK_MOBJ].next; wp != &thlist[THINK_MOBJ]; wp = wp->next)
@@ -1833,6 +1844,9 @@ void T_PolyObjWaypoint(polywaypoint_t *th)
break;
}
}
+*/
+
+ target = th->target;
if (!target)
{
@@ -2015,6 +2029,8 @@ void T_PolyObjWaypoint(polywaypoint_t *th)
target = waypoint;
th->pointnum = target->health;
+ // Set the mobj as your target! -- Monster Iestyn 27/12/19
+ P_SetTarget(&th->target, target);
// calculate MOMX/MOMY/MOMZ for next waypoint
// change slope
@@ -2641,6 +2657,9 @@ INT32 EV_DoPolyObjWaypoint(polywaypointdata_t *pwdata)
// Set pointnum
th->pointnum = target->health;
+ th->target = NULL; // set to NULL first so the below doesn't go wrong
+ // Set the mobj as your target! -- Monster Iestyn 27/12/19
+ P_SetTarget(&th->target, target);
// We don't deal with the mirror crap here, we'll
// handle that in the T_Thinker function.
diff --git a/src/p_polyobj.h b/src/p_polyobj.h
index ffacf628b3cd4bfcac5d36fc5e91cee45a2ada2d..339390c0af8eaa9a3f2f3bbda918d3bcf577bba7 100644
--- a/src/p_polyobj.h
+++ b/src/p_polyobj.h
@@ -161,6 +161,8 @@ typedef struct polywaypoint_s
fixed_t diffx;
fixed_t diffy;
fixed_t diffz;
+
+ mobj_t *target; // next waypoint mobj
} polywaypoint_t;
typedef struct polyslidedoor_s
diff --git a/src/p_saveg.c b/src/p_saveg.c
index 89447db80ae08d844d3259c0717f4916f7a380c5..2b6a474bf70999317e2567bf70cbfb0a39abce48 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -777,14 +777,13 @@ static void P_NetArchiveWorld(void)
size_t i;
INT32 statsec = 0, statline = 0;
const line_t *li = lines;
+ const line_t *spawnli = spawnlines;
const side_t *si;
+ const side_t *spawnsi;
UINT8 *put;
- // reload the map just to see difference
- mapsector_t *ms;
- mapsidedef_t *msd;
- maplinedef_t *mld;
const sector_t *ss = sectors;
+ const sector_t *spawnss = spawnsectors;
UINT8 diff, diff2, diff3;
// initialize colormap vars because paranoia
@@ -793,65 +792,45 @@ static void P_NetArchiveWorld(void)
WRITEUINT32(save_p, ARCHIVEBLOCK_WORLD);
put = save_p;
- if (W_IsLumpWad(lastloadedmaplumpnum)) // welp it's a map wad in a pk3
- { // HACK: Open wad file rather quickly so we can get the data from the relevant lumps
- UINT8 *wadData = W_CacheLumpNum(lastloadedmaplumpnum, PU_STATIC);
- filelump_t *fileinfo = (filelump_t *)(wadData + ((wadinfo_t *)wadData)->infotableofs);
-#define retrieve_mapdata(d, f)\
- d = Z_Malloc((f)->size, PU_CACHE, NULL); \
- M_Memcpy(d, wadData + (f)->filepos, (f)->size)
- retrieve_mapdata(ms, fileinfo + ML_SECTORS);
- retrieve_mapdata(mld, fileinfo + ML_LINEDEFS);
- retrieve_mapdata(msd, fileinfo + ML_SIDEDEFS);
-#undef retrieve_mapdata
- Z_Free(wadData); // we're done with this now
- }
- else // phew it's just a WAD
- {
- ms = W_CacheLumpNum(lastloadedmaplumpnum+ML_SECTORS, PU_CACHE);
- mld = W_CacheLumpNum(lastloadedmaplumpnum+ML_LINEDEFS, PU_CACHE);
- msd = W_CacheLumpNum(lastloadedmaplumpnum+ML_SIDEDEFS, PU_CACHE);
- }
-
- for (i = 0; i < numsectors; i++, ss++, ms++)
+ for (i = 0; i < numsectors; i++, ss++, spawnss++)
{
diff = diff2 = diff3 = 0;
- if (ss->floorheight != SHORT(ms->floorheight)<<FRACBITS)
+ if (ss->floorheight != spawnss->floorheight)
diff |= SD_FLOORHT;
- if (ss->ceilingheight != SHORT(ms->ceilingheight)<<FRACBITS)
+ if (ss->ceilingheight != spawnss->ceilingheight)
diff |= SD_CEILHT;
//
// flats
//
- if (ss->floorpic != P_CheckLevelFlat(ms->floorpic))
+ if (ss->floorpic != spawnss->floorpic)
diff |= SD_FLOORPIC;
- if (ss->ceilingpic != P_CheckLevelFlat(ms->ceilingpic))
+ if (ss->ceilingpic != spawnss->ceilingpic)
diff |= SD_CEILPIC;
- if (ss->lightlevel != SHORT(ms->lightlevel))
+ if (ss->lightlevel != spawnss->lightlevel)
diff |= SD_LIGHT;
- if (ss->special != SHORT(ms->special))
+ if (ss->special != spawnss->special)
diff |= SD_SPECIAL;
- if (ss->floor_xoffs != ss->spawn_flr_xoffs)
+ if (ss->floor_xoffs != spawnss->floor_xoffs)
diff2 |= SD_FXOFFS;
- if (ss->floor_yoffs != ss->spawn_flr_yoffs)
+ if (ss->floor_yoffs != spawnss->floor_yoffs)
diff2 |= SD_FYOFFS;
- if (ss->ceiling_xoffs != ss->spawn_ceil_xoffs)
+ if (ss->ceiling_xoffs != spawnss->ceiling_xoffs)
diff2 |= SD_CXOFFS;
- if (ss->ceiling_yoffs != ss->spawn_ceil_yoffs)
+ if (ss->ceiling_yoffs != spawnss->ceiling_yoffs)
diff2 |= SD_CYOFFS;
- if (ss->floorpic_angle != ss->spawn_flrpic_angle)
+ if (ss->floorpic_angle != spawnss->floorpic_angle)
diff2 |= SD_FLOORANG;
- if (ss->ceilingpic_angle != ss->spawn_flrpic_angle)
+ if (ss->ceilingpic_angle != spawnss->ceilingpic_angle)
diff2 |= SD_CEILANG;
- if (ss->tag != SHORT(ms->tag))
+ if (ss->tag != spawnss->tag)
diff2 |= SD_TAG;
- if (ss->nexttag != ss->spawn_nexttag || ss->firsttag != ss->spawn_firsttag)
+ if (ss->nexttag != spawnss->nexttag || ss->firsttag != spawnss->firsttag)
diff3 |= SD_TAGLIST;
- if (ss->extra_colormap != ss->spawn_extra_colormap)
+ if (ss->extra_colormap != spawnss->extra_colormap)
diff3 |= SD_COLORMAP;
// Check if any of the sector's FOFs differ from how they spawned
@@ -955,45 +934,41 @@ static void P_NetArchiveWorld(void)
WRITEUINT16(put, 0xffff);
// do lines
- for (i = 0; i < numlines; i++, mld++, li++)
+ for (i = 0; i < numlines; i++, spawnli++, li++)
{
diff = diff2 = diff3 = 0;
- if (li->special != SHORT(mld->special))
+ if (li->special != spawnli->special)
diff |= LD_SPECIAL;
- if (SHORT(mld->special) == 321 || SHORT(mld->special) == 322) // only reason li->callcount would be non-zero is if either of these are involved
+ if (spawnli->special == 321 || spawnli->special == 322) // only reason li->callcount would be non-zero is if either of these are involved
diff |= LD_CLLCOUNT;
if (li->sidenum[0] != 0xffff)
{
si = &sides[li->sidenum[0]];
- if (si->textureoffset != SHORT(msd[li->sidenum[0]].textureoffset)<<FRACBITS)
+ spawnsi = &spawnsides[li->sidenum[0]];
+ if (si->textureoffset != spawnsi->textureoffset)
diff |= LD_S1TEXOFF;
//SoM: 4/1/2000: Some textures are colormaps. Don't worry about invalid textures.
- if (R_CheckTextureNumForName(msd[li->sidenum[0]].toptexture) != -1
- && si->toptexture != R_TextureNumForName(msd[li->sidenum[0]].toptexture))
+ if (si->toptexture != spawnsi->toptexture)
diff |= LD_S1TOPTEX;
- if (R_CheckTextureNumForName(msd[li->sidenum[0]].bottomtexture) != -1
- && si->bottomtexture != R_TextureNumForName(msd[li->sidenum[0]].bottomtexture))
+ if (si->bottomtexture != spawnsi->bottomtexture)
diff |= LD_S1BOTTEX;
- if (R_CheckTextureNumForName(msd[li->sidenum[0]].midtexture) != -1
- && si->midtexture != R_TextureNumForName(msd[li->sidenum[0]].midtexture))
+ if (si->midtexture != spawnsi->midtexture)
diff |= LD_S1MIDTEX;
}
if (li->sidenum[1] != 0xffff)
{
si = &sides[li->sidenum[1]];
- if (si->textureoffset != SHORT(msd[li->sidenum[1]].textureoffset)<<FRACBITS)
+ spawnsi = &spawnsides[li->sidenum[1]];
+ if (si->textureoffset != spawnsi->textureoffset)
diff2 |= LD_S2TEXOFF;
- if (R_CheckTextureNumForName(msd[li->sidenum[1]].toptexture) != -1
- && si->toptexture != R_TextureNumForName(msd[li->sidenum[1]].toptexture))
+ if (si->toptexture != spawnsi->toptexture)
diff2 |= LD_S2TOPTEX;
- if (R_CheckTextureNumForName(msd[li->sidenum[1]].bottomtexture) != -1
- && si->bottomtexture != R_TextureNumForName(msd[li->sidenum[1]].bottomtexture))
+ if (si->bottomtexture != spawnsi->bottomtexture)
diff2 |= LD_S2BOTTEX;
- if (R_CheckTextureNumForName(msd[li->sidenum[1]].midtexture) != -1
- && si->midtexture != R_TextureNumForName(msd[li->sidenum[1]].midtexture))
+ if (si->midtexture != spawnsi->midtexture)
diff2 |= LD_S2MIDTEX;
if (diff2)
diff |= LD_DIFF2;
@@ -1277,9 +1252,7 @@ typedef enum
MD2_SLOPE = 1<<11,
#endif
MD2_COLORIZED = 1<<12,
-#ifdef ROTSPRITE
MD2_ROLLANGLE = 1<<13,
-#endif
} mobj_diff2_t;
typedef enum
@@ -1499,10 +1472,8 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
#endif
if (mobj->colorized)
diff2 |= MD2_COLORIZED;
-#ifdef ROTSPRITE
if (mobj->rollangle)
diff2 |= MD2_ROLLANGLE;
-#endif
if (diff2 != 0)
diff |= MD_MORE;
@@ -1667,10 +1638,8 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
#endif
if (diff2 & MD2_COLORIZED)
WRITEUINT8(save_p, mobj->colorized);
-#ifdef ROTSPRITE
if (diff2 & MD2_ROLLANGLE)
WRITEANGLE(save_p, mobj->rollangle);
-#endif
WRITEUINT32(save_p, mobj->mobjnum);
}
@@ -2086,6 +2055,7 @@ static void SavePolywaypointThinker(const thinker_t *th, UINT8 type)
WRITEFIXED(save_p, ht->diffx);
WRITEFIXED(save_p, ht->diffy);
WRITEFIXED(save_p, ht->diffz);
+ WRITEUINT32(save_p, SaveMobjnum(ht->target));
}
//
@@ -2563,7 +2533,7 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
if (mapthings[spawnpointnum].type == 1705 || mapthings[spawnpointnum].type == 1713) // NiGHTS Hoop special case
{
- P_SpawnHoopsAndRings(&mapthings[spawnpointnum], false);
+ P_SpawnHoop(&mapthings[spawnpointnum]);
return NULL;
}
@@ -2747,12 +2717,8 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
#endif
if (diff2 & MD2_COLORIZED)
mobj->colorized = READUINT8(save_p);
-#ifdef ROTSPRITE
if (diff2 & MD2_ROLLANGLE)
mobj->rollangle = READANGLE(save_p);
- else
- mobj->rollangle = 0;
-#endif
if (diff & MD_REDFLAG)
{
@@ -3279,6 +3245,7 @@ static inline thinker_t* LoadPolywaypointThinker(actionf_p1 thinker)
ht->diffx = READFIXED(save_p);
ht->diffy = READFIXED(save_p);
ht->diffz = READFIXED(save_p);
+ ht->target = LoadMobj(READUINT32(save_p));
return &ht->thinker;
}
@@ -3573,6 +3540,7 @@ static void P_NetUnArchiveThinkers(void)
case tc_polywaypoint:
th = LoadPolywaypointThinker((actionf_p1)T_PolyObjWaypoint);
+ restoreNum = true;
break;
case tc_polyslidedoor:
@@ -3634,9 +3602,9 @@ static void P_NetUnArchiveThinkers(void)
if (restoreNum)
{
executor_t *delay = NULL;
+ polywaypoint_t *polywp = NULL;
UINT32 mobjnum;
- for (currentthinker = thlist[THINK_MAIN].next; currentthinker != &thlist[THINK_MAIN];
- currentthinker = currentthinker->next)
+ for (currentthinker = thlist[THINK_MAIN].next; currentthinker != &thlist[THINK_MAIN]; currentthinker = currentthinker->next)
{
if (currentthinker->function.acp1 != (actionf_p1)T_ExecutorDelay)
continue;
@@ -3645,6 +3613,15 @@ static void P_NetUnArchiveThinkers(void)
continue;
delay->caller = P_FindNewPosition(mobjnum);
}
+ for (currentthinker = thlist[THINK_POLYOBJ].next; currentthinker != &thlist[THINK_POLYOBJ]; currentthinker = currentthinker->next)
+ {
+ if (currentthinker->function.acp1 != (actionf_p1)T_PolyObjWaypoint)
+ continue;
+ polywp = (void *)currentthinker;
+ if (!(mobjnum = (UINT32)(size_t)polywp->target))
+ continue;
+ polywp->target = P_FindNewPosition(mobjnum);
+ }
}
}
@@ -4099,7 +4076,7 @@ static inline boolean P_NetUnArchiveMisc(void)
tokenlist = READUINT32(save_p);
- if (!P_SetupLevel(true))
+ if (!P_LoadLevel(true))
return false;
// get the time
diff --git a/src/p_setup.c b/src/p_setup.c
index babe0265e2ad7d06556de742bfa25a07b77ade26..a6dd25a8d4a6985fe92891527ffd1e7a7b798ccd 100644
--- a/src/p_setup.c
+++ b/src/p_setup.c
@@ -103,6 +103,9 @@ node_t *nodes;
line_t *lines;
side_t *sides;
mapthing_t *mapthings;
+sector_t *spawnsectors;
+line_t *spawnlines;
+side_t *spawnsides;
INT32 numstarposts;
UINT16 bossdisabled;
boolean stoppedclock;
@@ -210,6 +213,9 @@ static void P_ClearSingleMapHeaderInfo(INT16 i)
mapheaderinfo[num]->lvlttl[0] = '\0';
mapheaderinfo[num]->selectheading[0] = '\0';
mapheaderinfo[num]->subttl[0] = '\0';
+ mapheaderinfo[num]->ltzzpatch[0] = '\0';
+ mapheaderinfo[num]->ltzztext[0] = '\0';
+ mapheaderinfo[num]->ltactdiamond[0] = '\0';
mapheaderinfo[num]->actnum = 0;
mapheaderinfo[num]->typeoflevel = 0;
mapheaderinfo[num]->nextlevel = (INT16)(i + 1);
@@ -367,171 +373,6 @@ UINT32 P_GetScoreForGrade(INT16 map, UINT8 mare, UINT8 grade)
return mapheaderinfo[map-1]->grades[mare].grade[grade-1];
}
-/** Loads the vertexes for a level.
- *
- * \param lump VERTEXES lump number.
- * \sa ML_VERTEXES
- */
-
-static inline void P_LoadRawVertexes(UINT8 *data, size_t i)
-{
- mapvertex_t *ml;
- vertex_t *li;
-
- numvertexes = i / sizeof (mapvertex_t);
-
- if (numvertexes <= 0)
- I_Error("Level has no vertices"); // instead of crashing
-
- // Allocate zone memory for buffer.
- vertexes = Z_Calloc(numvertexes * sizeof (*vertexes), PU_LEVEL, NULL);
-
- ml = (mapvertex_t *)data;
- li = vertexes;
-
- // Copy and convert vertex coordinates, internal representation as fixed.
- for (i = 0; i < numvertexes; i++, li++, ml++)
- {
- li->x = SHORT(ml->x)<<FRACBITS;
- li->y = SHORT(ml->y)<<FRACBITS;
- }
-}
-
-static inline void P_LoadVertexes(lumpnum_t lumpnum)
-{
- UINT8 *data = W_CacheLumpNum(lumpnum, PU_STATIC);
- P_LoadRawVertexes(data, W_LumpLength(lumpnum));
- Z_Free(data);
-}
-
-/** Computes the length of a seg in fracunits.
- *
- * \param seg Seg to compute length for.
- * \return Length in fracunits.
- */
-fixed_t P_SegLength(seg_t *seg)
-{
- INT64 dx = (seg->v2->x - seg->v1->x)>>1;
- INT64 dy = (seg->v2->y - seg->v1->y)>>1;
- return FixedHypot(dx, dy)<<1;
-}
-
-#ifdef HWRENDER
-/** Computes the length of a seg as a float.
- * This is needed for OpenGL.
- *
- * \param seg Seg to compute length for.
- * \return Length as a float.
- */
-static inline float P_SegLengthFloat(seg_t *seg)
-{
- float dx, dy;
-
- // make a vector (start at origin)
- dx = FIXED_TO_FLOAT(seg->v2->x - seg->v1->x);
- dy = FIXED_TO_FLOAT(seg->v2->y - seg->v1->y);
-
- return (float)hypot(dx, dy);
-}
-#endif
-
-/** Loads the SEGS resource from a level.
- *
- * \param lump Lump number of the SEGS resource.
- * \sa ::ML_SEGS
- */
-static void P_LoadRawSegs(UINT8 *data, size_t i)
-{
- INT32 linedef, side;
- mapseg_t *ml;
- seg_t *li;
- line_t *ldef;
-
- numsegs = i / sizeof (mapseg_t);
- if (numsegs <= 0)
- I_Error("Level has no segs"); // instead of crashing
- segs = Z_Calloc(numsegs * sizeof (*segs), PU_LEVEL, NULL);
-
- ml = (mapseg_t *)data;
- li = segs;
- for (i = 0; i < numsegs; i++, li++, ml++)
- {
- li->v1 = &vertexes[SHORT(ml->v1)];
- li->v2 = &vertexes[SHORT(ml->v2)];
-
- li->length = P_SegLength(li);
-#ifdef HWRENDER
- if (rendermode == render_opengl)
- {
- li->flength = P_SegLengthFloat(li);
- //Hurdler: 04/12/2000: for now, only used in hardware mode
- li->lightmaps = NULL; // list of static lightmap for this seg
- }
- li->pv1 = li->pv2 = NULL;
-#endif
-
- li->angle = (SHORT(ml->angle))<<FRACBITS;
- li->offset = (SHORT(ml->offset))<<FRACBITS;
- linedef = SHORT(ml->linedef);
- ldef = &lines[linedef];
- li->linedef = ldef;
- li->side = side = SHORT(ml->side);
- li->sidedef = &sides[ldef->sidenum[side]];
- li->frontsector = sides[ldef->sidenum[side]].sector;
- if (ldef-> flags & ML_TWOSIDED)
- li->backsector = sides[ldef->sidenum[side^1]].sector;
- else
- li->backsector = 0;
-
- li->numlights = 0;
- li->rlights = NULL;
- }
-}
-
-static void P_LoadSegs(lumpnum_t lumpnum)
-{
- UINT8 *data = W_CacheLumpNum(lumpnum, PU_STATIC);
- P_LoadRawSegs(data, W_LumpLength(lumpnum));
- Z_Free(data);
-}
-
-
-/** Loads the SSECTORS resource from a level.
- *
- * \param lump Lump number of the SSECTORS resource.
- * \sa ::ML_SSECTORS
- */
-static inline void P_LoadRawSubsectors(void *data, size_t i)
-{
- mapsubsector_t *ms;
- subsector_t *ss;
-
- numsubsectors = i / sizeof (mapsubsector_t);
- if (numsubsectors <= 0)
- I_Error("Level has no subsectors (did you forget to run it through a nodesbuilder?)");
- ss = subsectors = Z_Calloc(numsubsectors * sizeof (*subsectors), PU_LEVEL, NULL);
-
- ms = (mapsubsector_t *)data;
-
- for (i = 0; i < numsubsectors; i++, ss++, ms++)
- {
- ss->sector = NULL;
- ss->numlines = SHORT(ms->numsegs);
- ss->firstline = SHORT(ms->firstseg);
-#ifdef FLOORSPLATS
- ss->splats = NULL;
-#endif
- ss->validcount = 0;
- }
-}
-
-static void P_LoadSubsectors(lumpnum_t lumpnum)
-{
- UINT8 *data = W_CacheLumpNum(lumpnum, PU_STATIC);
- P_LoadRawSubsectors(data, W_LumpLength(lumpnum));
- Z_Free(data);
-}
-
//
// levelflats
//
@@ -539,6 +380,7 @@ static void P_LoadSubsectors(lumpnum_t lumpnum)
size_t numlevelflats;
levelflat_t *levelflats;
+levelflat_t *foundflats;
//SoM: Other files want this info.
size_t P_PrecacheLevelFlats(void)
@@ -697,163 +539,9 @@ INT32 P_CheckLevelFlat(const char *flatname)
return (INT32)i;
}
-// Sets up the ingame sectors structures.
-// Lumpnum is the lumpnum of a SECTORS lump.
-static void P_LoadRawSectors(UINT8 *data, size_t i)
-{
- mapsector_t *ms;
- sector_t *ss;
- levelflat_t *foundflats;
-
- // We count how many sectors we got.
- numsectors = i / sizeof (mapsector_t);
- if (numsectors <= 0)
- I_Error("Level has no sectors");
-
- // Allocate as much memory as we need into the global sectors table.
- sectors = Z_Calloc(numsectors*sizeof (*sectors), PU_LEVEL, NULL);
-
- // Allocate a big chunk of memory as big as our MAXLEVELFLATS limit.
- //Fab : FIXME: allocate for whatever number of flats - 512 different flats per level should be plenty
- foundflats = calloc(MAXLEVELFLATS, sizeof (*foundflats));
- if (foundflats == NULL)
- I_Error("Ran out of memory while loading sectors\n");
-
- numlevelflats = 0;
-
- // For each counted sector, copy the sector raw data from our cache pointer ms, to the global table pointer ss.
- ms = (mapsector_t *)data;
- ss = sectors;
- for (i = 0; i < numsectors; i++, ss++, ms++)
- {
- ss->floorheight = SHORT(ms->floorheight)<<FRACBITS;
- ss->ceilingheight = SHORT(ms->ceilingheight)<<FRACBITS;
-
- ss->floorpic = P_AddLevelFlat(ms->floorpic, foundflats);
- ss->ceilingpic = P_AddLevelFlat(ms->ceilingpic, foundflats);
-
- ss->lightlevel = SHORT(ms->lightlevel);
- ss->spawn_lightlevel = SHORT(ms->lightlevel);
- ss->special = SHORT(ms->special);
- ss->tag = SHORT(ms->tag);
- ss->nexttag = ss->firsttag = -1;
- ss->spawn_nexttag = ss->spawn_firsttag = -1;
-
- memset(&ss->soundorg, 0, sizeof(ss->soundorg));
- ss->validcount = 0;
-
- ss->thinglist = NULL;
- ss->touching_thinglist = NULL;
- ss->preciplist = NULL;
- ss->touching_preciplist = NULL;
-
- ss->floordata = NULL;
- ss->ceilingdata = NULL;
- ss->lightingdata = NULL;
-
- ss->linecount = 0;
- ss->lines = NULL;
-
- ss->heightsec = -1;
- ss->camsec = -1;
- ss->floorlightsec = -1;
- ss->ceilinglightsec = -1;
- ss->crumblestate = 0;
- ss->ffloors = NULL;
- ss->lightlist = NULL;
- ss->numlights = 0;
- ss->attached = NULL;
- ss->attachedsolid = NULL;
- ss->numattached = 0;
- ss->maxattached = 1;
- ss->moved = true;
-
- ss->extra_colormap = NULL;
- ss->spawn_extra_colormap = NULL;
-
- ss->floor_xoffs = ss->ceiling_xoffs = ss->floor_yoffs = ss->ceiling_yoffs = 0;
- ss->spawn_flr_xoffs = ss->spawn_ceil_xoffs = ss->spawn_flr_yoffs = ss->spawn_ceil_yoffs = 0;
- ss->floorpic_angle = ss->ceilingpic_angle = 0;
- ss->spawn_flrpic_angle = ss->spawn_ceilpic_angle = 0;
- ss->gravity = NULL;
- ss->cullheight = NULL;
- ss->verticalflip = false;
- ss->flags = 0;
- ss->flags |= SF_FLIPSPECIAL_FLOOR;
-
- ss->floorspeed = 0;
- ss->ceilspeed = 0;
-
-#ifdef HWRENDER // ----- for special tricks with HW renderer -----
- ss->pseudoSector = false;
- ss->virtualFloor = false;
- ss->virtualCeiling = false;
- ss->sectorLines = NULL;
- ss->stackList = NULL;
- ss->lineoutLength = -1.0l;
-#endif // ----- end special tricks -----
- }
-
- // set the sky flat num
- skyflatnum = P_AddLevelFlat(SKYFLATNAME, foundflats);
-
- // copy table for global usage
- levelflats = M_Memcpy(Z_Calloc(numlevelflats * sizeof (*levelflats), PU_LEVEL, NULL), foundflats, numlevelflats * sizeof (levelflat_t));
- free(foundflats);
-
- // search for animated flats and set up
- P_SetupLevelFlatAnims();
-}
-
-static void P_LoadSectors(lumpnum_t lumpnum)
-{
- UINT8 *data = W_CacheLumpNum(lumpnum, PU_STATIC);
- P_LoadRawSectors(data, W_LumpLength(lumpnum));
- Z_Free(data);
-}
-
-//
-// P_LoadNodes
-//
-static void P_LoadRawNodes(UINT8 *data, size_t i)
-{
- UINT8 j, k;
- mapnode_t *mn;
- node_t *no;
-
- numnodes = i / sizeof (mapnode_t);
- if (numnodes <= 0)
- I_Error("Level has no nodes");
- nodes = Z_Calloc(numnodes * sizeof (*nodes), PU_LEVEL, NULL);
-
- mn = (mapnode_t *)data;
- no = nodes;
-
- for (i = 0; i < numnodes; i++, no++, mn++)
- {
- no->x = SHORT(mn->x)<<FRACBITS;
- no->y = SHORT(mn->y)<<FRACBITS;
- no->dx = SHORT(mn->dx)<<FRACBITS;
- no->dy = SHORT(mn->dy)<<FRACBITS;
- for (j = 0; j < 2; j++)
- {
- no->children[j] = SHORT(mn->children[j]);
- for (k = 0; k < 4; k++)
- no->bbox[j][k] = SHORT(mn->bbox[j][k])<<FRACBITS;
- }
- }
-}
-
-static void P_LoadNodes(lumpnum_t lumpnum)
-{
- UINT8 *data = W_CacheLumpNum(lumpnum, PU_STATIC);
- P_LoadRawNodes(data, W_LumpLength(lumpnum));
- Z_Free(data);
-}
-
//
// P_ReloadRings
-// Used by NiGHTS, clears all ring/wing/etc items and respawns them
+// Used by NiGHTS, clears all ring/sphere/hoop/etc items and respawns them
//
void P_ReloadRings(void)
{
@@ -900,22 +588,21 @@ void P_ReloadRings(void)
{
// Notice an omission? We handle hoops differently.
if (mt->type == mobjinfo[MT_RING].doomednum || mt->type == mobjinfo[MT_COIN].doomednum
- || mt->type == mobjinfo[MT_REDTEAMRING].doomednum || mt->type == mobjinfo[MT_BLUETEAMRING].doomednum
- || mt->type == mobjinfo[MT_BLUESPHERE].doomednum || mt->type == mobjinfo[MT_BOMBSPHERE].doomednum
- || (mt->type >= 600 && mt->type <= 609)) // circles and diagonals
+ || mt->type == mobjinfo[MT_REDTEAMRING].doomednum || mt->type == mobjinfo[MT_BLUETEAMRING].doomednum
+ || mt->type == mobjinfo[MT_BLUESPHERE].doomednum || mt->type == mobjinfo[MT_BOMBSPHERE].doomednum)
{
mt->mobj = NULL;
-
- // Z for objects Tails 05-26-2002
- mt->z = (INT16)(R_PointInSubsector(mt->x << FRACBITS, mt->y << FRACBITS)
- ->sector->floorheight>>FRACBITS);
-
- P_SpawnHoopsAndRings(mt, true);
+ P_SetBonusTime(P_SpawnMapThing(mt));
+ }
+ else if (mt->type >= 600 && mt->type <= 609) // Item patterns
+ {
+ mt->mobj = NULL;
+ P_SpawnItemPattern(mt, true);
}
}
for (i = 0; i < numHoops; i++)
{
- P_SpawnHoopsAndRings(hoopsToRespawn[i], false);
+ P_SpawnHoop(hoopsToRespawn[i]);
}
}
@@ -1006,27 +693,59 @@ void P_ScanThings(INT16 mapnum, INT16 wadnum, INT16 lumpnum)
}
#endif
-static void P_PrepareRawThings(UINT8 *data, size_t i)
+static void P_SpawnEmeraldHunt(void)
{
- mapthing_t *mt;
+ INT32 emer1, emer2, emer3;
+ INT32 timeout = 0; // keeps from getting stuck
- nummapthings = i / (5 * sizeof (INT16));
- mapthings = Z_Calloc(nummapthings * sizeof (*mapthings), PU_LEVEL, NULL);
+ emer1 = emer2 = emer3 = 0;
- // Spawn axis points first so they are
- // at the front of the list for fast searching.
- mt = mapthings;
- for (i = 0; i < nummapthings; i++, mt++)
+ //increment spawn numbers because zero is valid.
+ emer1 = (P_RandomKey(numhuntemeralds)) + 1;
+ while (timeout++ < 100)
{
- mt->x = READINT16(data);
- mt->y = READINT16(data);
- mt->angle = READINT16(data);
- mt->type = READUINT16(data);
- mt->options = READUINT16(data);
- mt->extrainfo = (UINT8)(mt->type >> 12);
+ emer2 = (P_RandomKey(numhuntemeralds)) + 1;
- mt->type &= 4095;
+ if (emer2 != emer1)
+ break;
+ }
+
+ timeout = 0;
+ while (timeout++ < 100)
+ {
+ emer3 = (P_RandomKey(numhuntemeralds)) + 1;
+
+ if (emer3 != emer2 && emer3 != emer1)
+ break;
+ }
+
+ //decrement spawn values to the actual number because zero is valid.
+ if (emer1--)
+ P_SpawnMobj(huntemeralds[emer1]->x<<FRACBITS,
+ huntemeralds[emer1]->y<<FRACBITS,
+ huntemeralds[emer1]->z<<FRACBITS, MT_EMERHUNT);
+
+ if (emer2--)
+ P_SetMobjStateNF(P_SpawnMobj(huntemeralds[emer2]->x<<FRACBITS,
+ huntemeralds[emer2]->y<<FRACBITS,
+ huntemeralds[emer2]->z<<FRACBITS, MT_EMERHUNT),
+ mobjinfo[MT_EMERHUNT].spawnstate+1);
+
+ if (emer3--)
+ P_SetMobjStateNF(P_SpawnMobj(huntemeralds[emer3]->x<<FRACBITS,
+ huntemeralds[emer3]->y<<FRACBITS,
+ huntemeralds[emer3]->z<<FRACBITS, MT_EMERHUNT),
+ mobjinfo[MT_EMERHUNT].spawnstate+2);
+}
+
+static void P_SpawnMapThings(boolean spawnemblems)
+{
+ size_t i;
+ mapthing_t *mt;
+ // Spawn axis points first so they are at the front of the list for fast searching.
+ for (i = 0, mt = mapthings; i < nummapthings; i++, mt++)
+ {
switch (mt->type)
{
case 1700: // MT_AXIS
@@ -1039,115 +758,32 @@ static void P_PrepareRawThings(UINT8 *data, size_t i)
break;
}
}
-}
-
-static void P_PrepareThings(lumpnum_t lumpnum)
-{
- UINT8 *data = W_CacheLumpNum(lumpnum, PU_STATIC);
- P_PrepareRawThings(data, W_LumpLength(lumpnum));
- Z_Free(data);
-}
-
-static void P_LoadThings(boolean loademblems)
-{
- size_t i;
- mapthing_t *mt;
-
- // Loading the things lump itself into memory is now handled in P_PrepareThings, above
- mt = mapthings;
numhuntemeralds = 0;
- for (i = 0; i < nummapthings; i++, mt++)
- {
- sector_t *mtsector = R_PointInSubsector(mt->x << FRACBITS, mt->y << FRACBITS)->sector;
-
- // Z for objects
- mt->z = (INT16)(
-#ifdef ESLOPE
- mtsector->f_slope ? P_GetZAt(mtsector->f_slope, mt->x << FRACBITS, mt->y << FRACBITS) :
-#endif
- mtsector->floorheight)>>FRACBITS;
+ for (i = 0, mt = mapthings; i < nummapthings; i++, mt++)
+ {
if (mt->type == 1700 // MT_AXIS
|| mt->type == 1701 // MT_AXISTRANSFER
|| mt->type == 1702) // MT_AXISTRANSFERLINE
continue; // These were already spawned
- if (!loademblems && mt->type == mobjinfo[MT_EMBLEM].doomednum)
+ if (!spawnemblems && mt->type == mobjinfo[MT_EMBLEM].doomednum)
continue;
mt->mobj = NULL;
- P_SpawnMapThing(mt);
+
+ if (mt->type >= 600 && mt->type <= 609) // item patterns
+ P_SpawnItemPattern(mt, false);
+ else if (mt->type == 1705 || mt->type == 1713) // hoops
+ P_SpawnHoop(mt);
+ else // Everything else
+ P_SpawnMapThing(mt);
}
// random emeralds for hunt
if (numhuntemeralds)
- {
- INT32 emer1, emer2, emer3;
- INT32 timeout = 0; // keeps from getting stuck
-
- emer1 = emer2 = emer3 = 0;
-
- //increment spawn numbers because zero is valid.
- emer1 = (P_RandomKey(numhuntemeralds)) + 1;
- while (timeout++ < 100)
- {
- emer2 = (P_RandomKey(numhuntemeralds)) + 1;
-
- if (emer2 != emer1)
- break;
- }
-
- timeout = 0;
- while (timeout++ < 100)
- {
- emer3 = (P_RandomKey(numhuntemeralds)) + 1;
-
- if (emer3 != emer2 && emer3 != emer1)
- break;
- }
-
- //decrement spawn values to the actual number because zero is valid.
- if (emer1--)
- P_SpawnMobj(huntemeralds[emer1]->x<<FRACBITS,
- huntemeralds[emer1]->y<<FRACBITS,
- huntemeralds[emer1]->z<<FRACBITS, MT_EMERHUNT);
-
- if (emer2--)
- P_SetMobjStateNF(P_SpawnMobj(huntemeralds[emer2]->x<<FRACBITS,
- huntemeralds[emer2]->y<<FRACBITS,
- huntemeralds[emer2]->z<<FRACBITS, MT_EMERHUNT),
- mobjinfo[MT_EMERHUNT].spawnstate+1);
-
- if (emer3--)
- P_SetMobjStateNF(P_SpawnMobj(huntemeralds[emer3]->x<<FRACBITS,
- huntemeralds[emer3]->y<<FRACBITS,
- huntemeralds[emer3]->z<<FRACBITS, MT_EMERHUNT),
- mobjinfo[MT_EMERHUNT].spawnstate+2);
- }
-
- if (metalrecording) // Metal Sonic gets no rings to distract him.
- return;
-
- // Run through the list of mapthings again to spawn hoops and rings
- mt = mapthings;
- for (i = 0; i < nummapthings; i++, mt++)
- {
- if (mt->type == mobjinfo[MT_RING].doomednum || mt->type == mobjinfo[MT_COIN].doomednum
- || mt->type == mobjinfo[MT_REDTEAMRING].doomednum || mt->type == mobjinfo[MT_BLUETEAMRING].doomednum
- || mt->type == mobjinfo[MT_BLUESPHERE].doomednum || mt->type == mobjinfo[MT_BOMBSPHERE].doomednum
- || (mt->type >= 600 && mt->type <= 609) // circles and diagonals
- || mt->type == 1705 || mt->type == 1713) // hoops
- {
- mt->mobj = NULL;
-
- // Z for objects Tails 05-26-2002
- mt->z = (INT16)(R_PointInSubsector(mt->x << FRACBITS, mt->y << FRACBITS)
- ->sector->floorheight>>FRACBITS);
-
- P_SpawnHoopsAndRings(mt, false);
- }
- }
+ P_SpawnEmeraldHunt();
}
// Experimental groovy write function!
@@ -1193,270 +829,249 @@ void P_WriteThings(lumpnum_t lumpnum)
CONS_Printf(M_GetText("newthings%d.lmp saved.\n"), gamemap);
}
-static void P_LoadRawLineDefs(UINT8 *data, size_t i)
-{
- maplinedef_t *mld;
- line_t *ld;
- vertex_t *v1, *v2;
+//
+// MAP LOADING FUNCTIONS
+//
- numlines = i / sizeof (maplinedef_t);
- if (numlines <= 0)
- I_Error("Level has no linedefs");
- lines = Z_Calloc(numlines * sizeof (*lines), PU_LEVEL, NULL);
+static void P_LoadVertices(UINT8 *data)
+{
+ mapvertex_t *mv = (mapvertex_t *)data;
+ vertex_t *v = vertexes;
+ size_t i;
- mld = (maplinedef_t *)data;
- ld = lines;
- for (i = 0; i < numlines; i++, mld++, ld++)
+ // Copy and convert vertex coordinates, internal representation as fixed.
+ for (i = 0; i < numvertexes; i++, v++, mv++)
{
- ld->flags = SHORT(mld->flags);
- ld->special = SHORT(mld->special);
- ld->tag = SHORT(mld->tag);
- v1 = ld->v1 = &vertexes[SHORT(mld->v1)];
- v2 = ld->v2 = &vertexes[SHORT(mld->v2)];
- ld->dx = v2->x - v1->x;
- ld->dy = v2->y - v1->y;
-
-#ifdef WALLSPLATS
- ld->splats = NULL;
-#endif
+ v->x = SHORT(mv->x)<<FRACBITS;
+ v->y = SHORT(mv->y)<<FRACBITS;
+ v->z = 0;
+ }
+}
- if (!ld->dx)
- ld->slopetype = ST_VERTICAL;
- else if (!ld->dy)
- ld->slopetype = ST_HORIZONTAL;
- else if ((ld->dy > 0) == (ld->dx > 0))
- ld->slopetype = ST_POSITIVE;
- else
- ld->slopetype = ST_NEGATIVE;
+static void P_InitializeSector(sector_t *ss)
+{
+ ss->nexttag = ss->firsttag = -1;
- if (v1->x < v2->x)
- {
- ld->bbox[BOXLEFT] = v1->x;
- ld->bbox[BOXRIGHT] = v2->x;
- }
- else
- {
- ld->bbox[BOXLEFT] = v2->x;
- ld->bbox[BOXRIGHT] = v1->x;
- }
+ memset(&ss->soundorg, 0, sizeof(ss->soundorg));
- if (v1->y < v2->y)
- {
- ld->bbox[BOXBOTTOM] = v1->y;
- ld->bbox[BOXTOP] = v2->y;
- }
- else
- {
- ld->bbox[BOXBOTTOM] = v2->y;
- ld->bbox[BOXTOP] = v1->y;
- }
+ ss->validcount = 0;
- ld->sidenum[0] = SHORT(mld->sidenum[0]);
- ld->sidenum[1] = SHORT(mld->sidenum[1]);
+ ss->thinglist = NULL;
- {
- // cph 2006/09/30 - fix sidedef errors right away.
- // cph 2002/07/20 - these errors are fatal if not fixed, so apply them
- UINT8 j;
+ ss->floordata = NULL;
+ ss->ceilingdata = NULL;
+ ss->lightingdata = NULL;
+ ss->fadecolormapdata = NULL;
- for (j=0; j < 2; j++)
- {
- if (ld->sidenum[j] != 0xffff && ld->sidenum[j] >= (UINT16)numsides)
- {
- ld->sidenum[j] = 0xffff;
- CONS_Debug(DBG_SETUP, "P_LoadRawLineDefs: linedef %s has out-of-range sidedef number\n", sizeu1(numlines-i-1));
- }
- }
- }
+ ss->floor_xoffs = ss->floor_yoffs = 0;
+ ss->ceiling_xoffs = ss->ceiling_yoffs = 0;
- ld->frontsector = ld->backsector = NULL;
- ld->validcount = 0;
- ld->firsttag = ld->nexttag = -1;
- ld->callcount = 0;
- // killough 11/98: fix common wad errors (missing sidedefs):
+ ss->floorpic_angle = ss->ceilingpic_angle = 0;
- if (ld->sidenum[0] == 0xffff)
- {
- ld->sidenum[0] = 0; // Substitute dummy sidedef for missing right side
- // cph - print a warning about the bug
- CONS_Debug(DBG_SETUP, "P_LoadRawLineDefs: linedef %s missing first sidedef\n", sizeu1(numlines-i-1));
- }
+ ss->heightsec = -1;
+ ss->camsec = -1;
- if ((ld->sidenum[1] == 0xffff) && (ld->flags & ML_TWOSIDED))
- {
- ld->flags &= ~ML_TWOSIDED; // Clear 2s flag for missing left side
- // cph - print a warning about the bug
- CONS_Debug(DBG_SETUP, "P_LoadRawLineDefs: linedef %s has two-sided flag set, but no second sidedef\n", sizeu1(numlines-i-1));
- }
+ ss->floorlightsec = ss->ceilinglightsec = -1;
+ ss->crumblestate = 0;
- if (ld->sidenum[0] != 0xffff && ld->special)
- sides[ld->sidenum[0]].special = ld->special;
- if (ld->sidenum[1] != 0xffff && ld->special)
- sides[ld->sidenum[1]].special = ld->special;
+ ss->touching_thinglist = NULL;
-#ifdef POLYOBJECTS
- ld->polyobj = NULL;
+ ss->linecount = 0;
+ ss->lines = NULL;
+ ss->tagline = NULL;
+
+ ss->ffloors = NULL;
+ ss->attached = NULL;
+ ss->attachedsolid = NULL;
+ ss->numattached = 0;
+ ss->maxattached = 1;
+ ss->lightlist = NULL;
+ ss->numlights = 0;
+ ss->moved = true;
+
+ ss->extra_colormap = NULL;
+
+#ifdef HWRENDER // ----- for special tricks with HW renderer -----
+ ss->pseudoSector = false;
+ ss->virtualFloor = false;
+ ss->virtualFloorheight = 0;
+ ss->virtualCeiling = false;
+ ss->virtualCeilingheight = 0;
+ ss->sectorLines = NULL;
+ ss->stackList = NULL;
+ ss->lineoutLength = -1.0l;
+#endif // ----- end special tricks -----
+
+ ss->gravity = NULL;
+ ss->verticalflip = false;
+ ss->flags = SF_FLIPSPECIAL_FLOOR;
+
+ ss->cullheight = NULL;
+
+ ss->floorspeed = ss->ceilspeed = 0;
+
+ ss->preciplist = NULL;
+ ss->touching_preciplist = NULL;
+
+#ifdef ESLOPE
+ ss->f_slope = NULL;
+ ss->c_slope = NULL;
+ ss->hasslope = false;
#endif
- }
-}
-static void P_LoadLineDefs(lumpnum_t lumpnum)
-{
- UINT8 *data = W_CacheLumpNum(lumpnum, PU_STATIC);
- P_LoadRawLineDefs(data, W_LumpLength(lumpnum));
- Z_Free(data);
+ ss->spawn_lightlevel = ss->lightlevel;
+
+ ss->spawn_extra_colormap = NULL;
}
-static void P_LoadLineDefs2(void)
+static void P_LoadSectors(UINT8 *data)
{
- size_t i = numlines;
- register line_t *ld = lines;
- for (;i--;ld++)
+ mapsector_t *ms = (mapsector_t *)data;
+ sector_t *ss = sectors;
+ size_t i;
+
+ // For each counted sector, copy the sector raw data from our cache pointer ms, to the global table pointer ss.
+ for (i = 0; i < numsectors; i++, ss++, ms++)
{
- ld->frontsector = sides[ld->sidenum[0]].sector; //e6y: Can't be -1 here
- ld->backsector = ld->sidenum[1] != 0xffff ? sides[ld->sidenum[1]].sector : 0;
+ ss->floorheight = SHORT(ms->floorheight)<<FRACBITS;
+ ss->ceilingheight = SHORT(ms->ceilingheight)<<FRACBITS;
- // Repeat count for midtexture
- if ((ld->flags & ML_EFFECT5) && (ld->sidenum[1] != 0xffff)
- && !(ld->special >= 300 && ld->special < 500)) // exempt linedef exec specials
- {
- sides[ld->sidenum[0]].repeatcnt = (INT16)(((unsigned)sides[ld->sidenum[0]].textureoffset >> FRACBITS) >> 12);
- sides[ld->sidenum[0]].textureoffset = (((unsigned)sides[ld->sidenum[0]].textureoffset >> FRACBITS) & 2047) << FRACBITS;
- sides[ld->sidenum[1]].repeatcnt = (INT16)(((unsigned)sides[ld->sidenum[1]].textureoffset >> FRACBITS) >> 12);
- sides[ld->sidenum[1]].textureoffset = (((unsigned)sides[ld->sidenum[1]].textureoffset >> FRACBITS) & 2047) << FRACBITS;
- }
+ ss->floorpic = P_AddLevelFlat(ms->floorpic, foundflats);
+ ss->ceilingpic = P_AddLevelFlat(ms->ceilingpic, foundflats);
- // Compile linedef 'text' from both sidedefs 'text' for appropriate specials.
- switch(ld->special)
- {
- case 331: // Trigger linedef executor: Skin - Continuous
- case 332: // Trigger linedef executor: Skin - Each time
- case 333: // Trigger linedef executor: Skin - Once
- case 443: // Calls a named Lua function
- if (sides[ld->sidenum[0]].text)
- {
- size_t len = strlen(sides[ld->sidenum[0]].text)+1;
- if (ld->sidenum[1] != 0xffff && sides[ld->sidenum[1]].text)
- len += strlen(sides[ld->sidenum[1]].text);
- ld->text = Z_Malloc(len, PU_LEVEL, NULL);
- M_Memcpy(ld->text, sides[ld->sidenum[0]].text, strlen(sides[ld->sidenum[0]].text)+1);
- if (ld->sidenum[1] != 0xffff && sides[ld->sidenum[1]].text)
- M_Memcpy(ld->text+strlen(ld->text)+1, sides[ld->sidenum[1]].text, strlen(sides[ld->sidenum[1]].text)+1);
- }
- break;
- }
- }
+ ss->lightlevel = SHORT(ms->lightlevel);
+ ss->special = SHORT(ms->special);
+ ss->tag = SHORT(ms->tag);
- // Optimize sidedefs
- if (M_CheckParm("-compress"))
- {
- side_t *newsides;
- size_t numnewsides = 0;
- size_t z;
+ P_InitializeSector(ss);
+ }
+}
- for (i = 0; i < numsides; i++)
- {
- size_t j, k;
- if (sides[i].sector == NULL)
- continue;
+static void P_InitializeLinedef(line_t *ld)
+{
+ vertex_t *v1 = ld->v1;
+ vertex_t *v2 = ld->v2;
+ UINT8 j;
- for (k = numlines, ld = lines; k--; ld++)
- {
- if (ld->sidenum[0] == i)
- ld->sidenum[0] = (UINT16)numnewsides;
+ ld->dx = v2->x - v1->x;
+ ld->dy = v2->y - v1->y;
- if (ld->sidenum[1] == i)
- ld->sidenum[1] = (UINT16)numnewsides;
- }
+ ld->bbox[BOXLEFT] = min(v1->x, v2->x);
+ ld->bbox[BOXRIGHT] = max(v1->x, v2->x);
+ ld->bbox[BOXBOTTOM] = min(v1->y, v2->y);
+ ld->bbox[BOXTOP] = max(v1->y, v2->y);
- for (j = i+1; j < numsides; j++)
- {
- if (sides[j].sector == NULL)
- continue;
+ if (!ld->dx)
+ ld->slopetype = ST_VERTICAL;
+ else if (!ld->dy)
+ ld->slopetype = ST_HORIZONTAL;
+ else if ((ld->dy > 0) == (ld->dx > 0))
+ ld->slopetype = ST_POSITIVE;
+ else
+ ld->slopetype = ST_NEGATIVE;
- if (!memcmp(&sides[i], &sides[j], sizeof(side_t)))
- {
- // Find the linedefs that belong to this one
- for (k = numlines, ld = lines; k--; ld++)
- {
- if (ld->sidenum[0] == j)
- ld->sidenum[0] = (UINT16)numnewsides;
+ ld->frontsector = ld->backsector = NULL;
- if (ld->sidenum[1] == j)
- ld->sidenum[1] = (UINT16)numnewsides;
- }
- sides[j].sector = NULL; // Flag for deletion
- }
- }
- numnewsides++;
- }
+ ld->validcount = 0;
+#ifdef WALLSPLATS
+ ld->splats = NULL;
+#endif
+ ld->firsttag = ld->nexttag = -1;
+#ifdef POLYOBJECTS
+ ld->polyobj = NULL;
+#endif
- // We're loading crap into this block anyhow, so no point in zeroing it out.
- newsides = Z_Malloc(numnewsides * sizeof(*newsides), PU_LEVEL, NULL);
+ ld->text = NULL;
+ ld->callcount = 0;
- // Copy the sides to their new block of memory.
- for (i = 0, z = 0; i < numsides; i++)
+ // cph 2006/09/30 - fix sidedef errors right away.
+ // cph 2002/07/20 - these errors are fatal if not fixed, so apply them
+ for (j = 0; j < 2; j++)
+ if (ld->sidenum[j] != 0xffff && ld->sidenum[j] >= (UINT16)numsides)
{
- if (sides[i].sector != NULL)
- M_Memcpy(&newsides[z++], &sides[i], sizeof(side_t));
+ ld->sidenum[j] = 0xffff;
+ CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s has out-of-range sidedef number\n", sizeu1((size_t)(ld - lines)));
}
- CONS_Debug(DBG_SETUP, "Old sides is %s, new sides is %s\n", sizeu1(numsides), sizeu1(numnewsides));
+ // killough 11/98: fix common wad errors (missing sidedefs):
+ if (ld->sidenum[0] == 0xffff)
+ {
+ ld->sidenum[0] = 0; // Substitute dummy sidedef for missing right side
+ // cph - print a warning about the bug
+ CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s missing first sidedef\n", sizeu1((size_t)(ld - lines)));
+ }
- Z_Free(sides);
- sides = newsides;
- numsides = numnewsides;
+ if ((ld->sidenum[1] == 0xffff) && (ld->flags & ML_TWOSIDED))
+ {
+ ld->flags &= ~ML_TWOSIDED; // Clear 2s flag for missing left side
+ // cph - print a warning about the bug
+ CONS_Debug(DBG_SETUP, "P_InitializeLinedef: Linedef %s has two-sided flag set, but no second sidedef\n", sizeu1((size_t)(ld - lines)));
}
-}
+ if (ld->sidenum[0] != 0xffff)
+ {
+ sides[ld->sidenum[0]].special = ld->special;
+ sides[ld->sidenum[0]].line = ld;
+ }
+ if (ld->sidenum[1] != 0xffff)
+ {
+ sides[ld->sidenum[1]].special = ld->special;
+ sides[ld->sidenum[1]].line = ld;
-static inline void P_LoadRawSideDefs(size_t i)
-{
- numsides = i / sizeof (mapsidedef_t);
- if (numsides <= 0)
- I_Error("Level has no sidedefs");
- sides = Z_Calloc(numsides * sizeof (*sides), PU_LEVEL, NULL);
+ }
}
-static inline void P_LoadSideDefs(lumpnum_t lumpnum)
+static void P_LoadLinedefs(UINT8 *data)
{
- P_LoadRawSideDefs(W_LumpLength(lumpnum));
-}
+ maplinedef_t *mld = (maplinedef_t *)data;
+ line_t *ld = lines;
+ size_t i;
+
+ for (i = 0; i < numlines; i++, mld++, ld++)
+ {
+ ld->flags = SHORT(mld->flags);
+ ld->special = SHORT(mld->special);
+ ld->tag = SHORT(mld->tag);
+ ld->v1 = &vertexes[SHORT(mld->v1)];
+ ld->v2 = &vertexes[SHORT(mld->v2)];
+
+ ld->sidenum[0] = SHORT(mld->sidenum[0]);
+ ld->sidenum[1] = SHORT(mld->sidenum[1]);
+ P_InitializeLinedef(ld);
+ }
+}
-static void P_LoadRawSideDefs2(void *data)
+static void P_LoadSidedefs(UINT8 *data)
{
- UINT16 i;
+ mapsidedef_t *msd = (mapsidedef_t*)data;
+ side_t *sd = sides;
+ size_t i;
- for (i = 0; i < numsides; i++)
+ for (i = 0; i < numsides; i++, sd++, msd++)
{
- register mapsidedef_t *msd = (mapsidedef_t *)data + i;
- register side_t *sd = sides + i;
- register sector_t *sec;
+ UINT16 sector_num;
+ boolean isfrontside = !sd->line || sd->line->sidenum[0] == i;
sd->textureoffset = SHORT(msd->textureoffset)<<FRACBITS;
sd->rowoffset = SHORT(msd->rowoffset)<<FRACBITS;
- { /* cph 2006/09/30 - catch out-of-range sector numbers; use sector 0 instead */
- UINT16 sector_num = SHORT(msd->sector);
-
- if (sector_num >= numsectors)
- {
- CONS_Debug(DBG_SETUP, "P_LoadRawSideDefs2: sidedef %u has out-of-range sector num %u\n", i, sector_num);
- sector_num = 0;
- }
- sd->sector = sec = §ors[sector_num];
+ // cph 2006/09/30 - catch out-of-range sector numbers; use sector 0 instead
+ sector_num = SHORT(msd->sector);
+ if (sector_num >= numsectors)
+ {
+ CONS_Debug(DBG_SETUP, "P_LoadSidedefs: sidedef %s has out-of-range sector num %u\n", sizeu1(i), sector_num);
+ sector_num = 0;
}
-
- sd->sector = sec = §ors[SHORT(msd->sector)];
+ sd->sector = §ors[sector_num];
sd->colormap_data = NULL;
- // Colormaps!
+ // Special info stored in texture fields!
switch (sd->special)
{
- case 63: // variable colormap via 242 linedef
+ case 63: // Fake floor/ceiling planes
case 606: //SoM: 4/4/2000: Just colormap transfer
case 447: // Change colormap of tagged sectors! -- Monster Iestyn 14/06/18
case 455: // Fade colormaps! mazmazz 9/12/2018 (:flag_us:)
@@ -1486,9 +1101,8 @@ static void P_LoadRawSideDefs2(void *data)
sd->midtexture = get_number(process);
}
- // always process if back sidedef, because we need that - symbol
sd->text = Z_Malloc(7, PU_LEVEL, NULL);
- if (i == 1 || msd->toptexture[0] != '-' || msd->toptexture[1] != '\0')
+ if (isfrontside && !(msd->toptexture[0] == '-' && msd->toptexture[1] == '\0'))
{
M_Memcpy(process,msd->toptexture,8);
process[8] = '\0';
@@ -1565,6 +1179,20 @@ static void P_LoadRawSideDefs2(void *data)
break;
}
+ case 259: // Custom FOF
+ if (!isfrontside)
+ {
+ if ((msd->toptexture[0] >= '0' && msd->toptexture[0] <= '9')
+ || (msd->toptexture[0] >= 'A' && msd->toptexture[0] <= 'F'))
+ sd->toptexture = axtoi(msd->toptexture);
+ else
+ I_Error("Custom FOF (tag %d) needs a value in the linedef's back side upper texture field.", sd->line->tag);
+
+ sd->midtexture = R_TextureNumForName(msd->midtexture);
+ sd->bottomtexture = R_TextureNumForName(msd->bottomtexture);
+ break;
+ }
+ // FALLTHRU
default: // normal cases
if (msd->toptexture[0] == '#')
{
@@ -1582,17 +1210,591 @@ static void P_LoadRawSideDefs2(void *data)
break;
}
}
- R_ClearTextureNumCache(true);
}
-// Delay loading texture names until after loaded linedefs.
-static void P_LoadSideDefs2(lumpnum_t lumpnum)
+static void P_LoadThings(UINT8 *data)
+{
+ mapthing_t *mt;
+ size_t i;
+
+ for (i = 0, mt = mapthings; i < nummapthings; i++, mt++)
+ {
+ mt->x = READINT16(data);
+ mt->y = READINT16(data);
+
+ mt->angle = READINT16(data);
+ mt->type = READUINT16(data);
+ mt->options = READUINT16(data);
+ mt->extrainfo = (UINT8)(mt->type >> 12);
+
+ mt->type &= 4095;
+
+ if (mt->type == 1705 || (mt->type == 750 && mt->extrainfo))
+ mt->z = mt->options; // NiGHTS Hoops use the full flags bits to set the height.
+ else
+ mt->z = mt->options >> ZSHIFT;
+ }
+}
+
+static void P_LoadMapData(const virtres_t *virt)
+{
+ virtlump_t* virtvertexes = NULL, * virtsectors = NULL, * virtsidedefs = NULL, * virtlinedefs = NULL, * virtthings = NULL;
+#ifdef UDMF
+ virtlump_t* textmap = vres_Find(virt, "TEXTMAP");
+
+ // Count map data.
+ if (textmap)
+ {
+ nummapthings = 0;
+ numlines = 0;
+ numsides = 0;
+ numvertexes = 0;
+ numsectors = 0;
+
+ // Count how many entries for each type we got in textmap.
+ //TextmapCount(vtextmap->data, vtextmap->size);
+ }
+ else
+#endif
+ {
+ virtthings = vres_Find(virt, "THINGS");
+ virtvertexes = vres_Find(virt, "VERTEXES");
+ virtsectors = vres_Find(virt, "SECTORS");
+ virtsidedefs = vres_Find(virt, "SIDEDEFS");
+ virtlinedefs = vres_Find(virt, "LINEDEFS");
+
+ if (!virtthings)
+ I_Error("THINGS lump not found");
+ if (!virtvertexes)
+ I_Error("VERTEXES lump not found");
+ if (!virtsectors)
+ I_Error("SECTORS lump not found");
+ if (!virtsidedefs)
+ I_Error("SIDEDEFS lump not found");
+ if (!virtlinedefs)
+ I_Error("LINEDEFS lump not found");
+
+ // Traditional doom map format just assumes the number of elements from the lump sizes.
+ numvertexes = virtvertexes->size / sizeof (mapvertex_t);
+ numsectors = virtsectors->size / sizeof (mapsector_t);
+ numsides = virtsidedefs->size / sizeof (mapsidedef_t);
+ numlines = virtlinedefs->size / sizeof (maplinedef_t);
+ nummapthings = virtthings->size / (5 * sizeof (INT16));
+ }
+
+ if (numvertexes <= 0)
+ I_Error("Level has no vertices");
+ if (numsectors <= 0)
+ I_Error("Level has no sectors");
+ if (numsides <= 0)
+ I_Error("Level has no sidedefs");
+ if (numlines <= 0)
+ I_Error("Level has no linedefs");
+
+ vertexes = Z_Calloc(numvertexes * sizeof (*vertexes), PU_LEVEL, NULL);
+ sectors = Z_Calloc(numsectors * sizeof (*sectors), PU_LEVEL, NULL);
+ sides = Z_Calloc(numsides * sizeof (*sides), PU_LEVEL, NULL);
+ lines = Z_Calloc(numlines * sizeof (*lines), PU_LEVEL, NULL);
+ mapthings = Z_Calloc(nummapthings * sizeof (*mapthings), PU_LEVEL, NULL);
+
+ // Allocate a big chunk of memory as big as our MAXLEVELFLATS limit.
+ //Fab : FIXME: allocate for whatever number of flats - 512 different flats per level should be plenty
+ foundflats = calloc(MAXLEVELFLATS, sizeof (*foundflats));
+ if (foundflats == NULL)
+ I_Error("Ran out of memory while loading sectors\n");
+
+ numlevelflats = 0;
+
+#ifdef UDMF
+ if (textmap)
+ {
+
+ }
+ else
+#endif
+ {
+ // Strict map data
+ P_LoadVertices(virtvertexes->data);
+ P_LoadSectors(virtsectors->data);
+ P_LoadLinedefs(virtlinedefs->data);
+ P_LoadSidedefs(virtsidedefs->data);
+ P_LoadThings(virtthings->data);
+ }
+
+ R_ClearTextureNumCache(true);
+
+ // set the sky flat num
+ skyflatnum = P_AddLevelFlat(SKYFLATNAME, foundflats);
+
+ // copy table for global usage
+ levelflats = M_Memcpy(Z_Calloc(numlevelflats * sizeof (*levelflats), PU_LEVEL, NULL), foundflats, numlevelflats * sizeof (levelflat_t));
+ free(foundflats);
+
+ // search for animated flats and set up
+ P_SetupLevelFlatAnims();
+
+ // Copy relevant map data for NetArchive purposes.
+ spawnsectors = Z_Calloc(numsectors * sizeof (*sectors), PU_LEVEL, NULL);
+ spawnlines = Z_Calloc(numlines * sizeof (*lines), PU_LEVEL, NULL);
+ spawnsides = Z_Calloc(numsides * sizeof (*sides), PU_LEVEL, NULL);
+
+ memcpy(spawnsectors, sectors, numsectors * sizeof (*sectors));
+ memcpy(spawnlines, lines, numlines * sizeof (*lines));
+ memcpy(spawnsides, sides, numsides * sizeof (*sides));
+}
+
+static void P_InitializeSubsector(subsector_t *ss)
+{
+ ss->sector = NULL;
+#ifdef FLOORSPLATS
+ ss->splats = NULL;
+#endif
+ ss->validcount = 0;
+}
+
+static inline void P_LoadSubsectors(UINT8 *data)
+{
+ mapsubsector_t *ms = (mapsubsector_t*)data;
+ subsector_t *ss = subsectors;
+ size_t i;
+
+ for (i = 0; i < numsubsectors; i++, ss++, ms++)
+ {
+ ss->numlines = SHORT(ms->numsegs);
+ ss->firstline = SHORT(ms->firstseg);
+ P_InitializeSubsector(ss);
+ }
+}
+
+static void P_LoadNodes(UINT8 *data)
+{
+ UINT8 j, k;
+ mapnode_t *mn = (mapnode_t*)data;
+ node_t *no = nodes;
+ size_t i;
+
+ for (i = 0; i < numnodes; i++, no++, mn++)
+ {
+ no->x = SHORT(mn->x)<<FRACBITS;
+ no->y = SHORT(mn->y)<<FRACBITS;
+ no->dx = SHORT(mn->dx)<<FRACBITS;
+ no->dy = SHORT(mn->dy)<<FRACBITS;
+ for (j = 0; j < 2; j++)
+ {
+ no->children[j] = SHORT(mn->children[j]);
+ for (k = 0; k < 4; k++)
+ no->bbox[j][k] = SHORT(mn->bbox[j][k])<<FRACBITS;
+ }
+ }
+}
+
+/** Computes the length of a seg in fracunits.
+ *
+ * \param seg Seg to compute length for.
+ * \return Length in fracunits.
+ */
+fixed_t P_SegLength(seg_t *seg)
+{
+ INT64 dx = (seg->v2->x - seg->v1->x)>>1;
+ INT64 dy = (seg->v2->y - seg->v1->y)>>1;
+ return FixedHypot(dx, dy)<<1;
+}
+
+#ifdef HWRENDER
+/** Computes the length of a seg as a float.
+ * This is needed for OpenGL.
+ *
+ * \param seg Seg to compute length for.
+ * \return Length as a float.
+ */
+static inline float P_SegLengthFloat(seg_t *seg)
+{
+ float dx, dy;
+
+ // make a vector (start at origin)
+ dx = FIXED_TO_FLOAT(seg->v2->x - seg->v1->x);
+ dy = FIXED_TO_FLOAT(seg->v2->y - seg->v1->y);
+
+ return (float)hypot(dx, dy);
+}
+#endif
+
+static void P_InitializeSeg(seg_t *seg)
+{
+ seg->sidedef = &sides[seg->linedef->sidenum[seg->side]];
+
+ seg->frontsector = seg->sidedef->sector;
+ seg->backsector = (seg->linedef->flags & ML_TWOSIDED) ? sides[seg->linedef->sidenum[seg->side ^ 1]].sector : NULL;
+
+#ifdef HWRENDER
+ seg->pv1 = seg->pv2 = NULL;
+
+ //Hurdler: 04/12/2000: for now, only used in hardware mode
+ seg->lightmaps = NULL; // list of static lightmap for this seg
+#endif
+
+ seg->numlights = 0;
+ seg->rlights = NULL;
+#ifdef POLYOBJECTS
+ seg->polyseg = NULL;
+ seg->dontrenderme = false;
+#endif
+}
+
+static void P_LoadSegs(UINT8 *data)
+{
+ mapseg_t *ms = (mapseg_t*)data;
+ seg_t *seg = segs;
+ size_t i;
+
+ for (i = 0; i < numsegs; i++, seg++, ms++)
+ {
+ seg->v1 = &vertexes[SHORT(ms->v1)];
+ seg->v2 = &vertexes[SHORT(ms->v2)];
+
+ seg->side = SHORT(ms->side);
+
+ seg->offset = (SHORT(ms->offset)) << FRACBITS;
+
+ seg->angle = (SHORT(ms->angle)) << FRACBITS;
+
+ seg->linedef = &lines[SHORT(ms->linedef)];
+
+ seg->length = P_SegLength(seg);
+#ifdef HWRENDER
+ seg->flength = (rendermode == render_opengl) ? P_SegLengthFloat(seg) : 0;
+#endif
+
+ seg->glseg = false;
+ P_InitializeSeg(seg);
+ }
+}
+
+typedef enum {
+ NT_DOOM,
+ NT_XNOD,
+ NT_ZNOD,
+ NT_XGLN,
+ NT_ZGLN,
+ NT_XGL2,
+ NT_ZGL2,
+ NT_XGL3,
+ NT_ZGL3,
+ NT_UNSUPPORTED,
+ NUMNODETYPES
+} nodetype_t;
+
+// Find out the BSP format.
+static nodetype_t P_GetNodetype(const virtres_t *virt, UINT8 **nodedata)
+{
+ boolean supported[NUMNODETYPES] = {0};
+ nodetype_t nodetype = NT_UNSUPPORTED;
+ char signature[4 + 1];
+
+ if (vres_Find(virt, "TEXTMAP"))
+ {
+ *nodedata = vres_Find(virt, "ZNODES")->data;
+ supported[NT_XGLN] = supported[NT_XGL3] = true;
+ }
+ else
+ {
+ virtlump_t *virtsegs = vres_Find(virt, "SEGS");
+ virtlump_t *virtssectors;
+
+ if (virtsegs && virtsegs->size)
+ {
+ *nodedata = vres_Find(virt, "NODES")->data;
+ return NT_DOOM; // Traditional map format BSP tree.
+ }
+
+ virtssectors = vres_Find(virt, "SSECTORS");
+
+ if (virtssectors && virtssectors->size)
+ { // Possibly GL nodes: NODES ignored, SSECTORS takes precedence as nodes lump, (It is confusing yeah) and has a signature.
+ *nodedata = virtssectors->data;
+ supported[NT_XGLN] = supported[NT_ZGLN] = supported[NT_XGL3] = true;
+ }
+ else
+ { // Possibly ZDoom extended nodes: SSECTORS is empty, NODES has a signature.
+ *nodedata = vres_Find(virt, "NODES")->data;
+ supported[NT_XNOD] = supported[NT_ZNOD] = true;
+ }
+ }
+
+ M_Memcpy(signature, *nodedata, 4);
+ signature[4] = '\0';
+ (*nodedata) += 4;
+
+ if (!strcmp(signature, "XNOD"))
+ nodetype = NT_XNOD;
+ else if (!strcmp(signature, "ZNOD"))
+ nodetype = NT_ZNOD;
+ else if (!strcmp(signature, "XGLN"))
+ nodetype = NT_XGLN;
+ else if (!strcmp(signature, "ZGLN"))
+ nodetype = NT_ZGLN;
+ else if (!strcmp(signature, "XGL3"))
+ nodetype = NT_XGL3;
+
+ return supported[nodetype] ? nodetype : NT_UNSUPPORTED;
+}
+
+// Extended node formats feature additional vertices; useful for OpenGL, but totally useless in gamelogic.
+static boolean P_LoadExtraVertices(UINT8 **data)
+{
+ UINT32 origvrtx = READUINT32((*data));
+ UINT32 xtrvrtx = READUINT32((*data));
+ line_t* ld = lines;
+ vertex_t *oldpos = vertexes;
+ ssize_t offset;
+ size_t i;
+
+ if (numvertexes != origvrtx) // If native vertex count doesn't match node original vertex count, bail out (broken data?).
+ {
+ CONS_Alert(CONS_WARNING, "Vertex count in map data and nodes differ!\n");
+ return false;
+ }
+
+ if (!xtrvrtx)
+ return true;
+
+ // If extra vertexes were generated, reallocate the vertex array and fix the pointers.
+ numvertexes += xtrvrtx;
+ vertexes = Z_Realloc(vertexes, numvertexes*sizeof(*vertexes), PU_LEVEL, NULL);
+ offset = (size_t)(vertexes - oldpos);
+
+ for (i = 0, ld = lines; i < numlines; i++, ld++)
+ {
+ ld->v1 += offset;
+ ld->v2 += offset;
+ }
+
+ // Read extra vertex data.
+ for (i = origvrtx; i < numvertexes; i++)
+ {
+ vertexes[i].x = READFIXED((*data));
+ vertexes[i].y = READFIXED((*data));
+ }
+
+ return true;
+}
+
+static boolean P_LoadExtendedSubsectorsAndSegs(UINT8 **data, nodetype_t nodetype)
+{
+ size_t i, k;
+ INT16 m;
+ seg_t *seg;
+
+ // Subsectors
+ numsubsectors = READUINT32((*data));
+ subsectors = Z_Calloc(numsubsectors*sizeof(*subsectors), PU_LEVEL, NULL);
+
+ for (i = 0; i < numsubsectors; i++)
+ subsectors[i].numlines = READUINT32((*data));
+
+ // Segs
+ numsegs = READUINT32((*data));
+ segs = Z_Calloc(numsegs*sizeof(*segs), PU_LEVEL, NULL);
+
+ for (i = 0, k = 0; i < numsubsectors; i++)
+ {
+ subsectors[i].firstline = k;
+ P_InitializeSubsector(&subsectors[i]);
+
+ switch (nodetype)
+ {
+ case NT_XGLN:
+ case NT_XGL3:
+ for (m = 0; m < subsectors[i].numlines; m++, k++)
+ {
+ UINT16 linenum;
+ UINT32 vert = READUINT32((*data));
+
+ segs[k].v1 = &vertexes[vert];
+ if (m == 0)
+ segs[k + subsectors[i].numlines - 1].v2 = &vertexes[vert];
+ else
+ segs[k - 1].v2 = segs[k].v1;
+
+ (*data) += 4; // partner, can be ignored by software renderer
+ if (nodetype == NT_XGL3)
+ (*data) += 2; // Line number is 32-bit in XGL3, but we're limited to 16 bits.
+
+ linenum = READUINT16((*data));
+ segs[k].glseg = (linenum == 0xFFFF);
+ segs[k].linedef = (linenum == 0xFFFF) ? NULL : &lines[linenum];
+ segs[k].side = READUINT8((*data));
+ }
+ break;
+
+ case NT_XNOD:
+ for (m = 0; m < subsectors[i].numlines; m++, k++)
+ {
+ segs[k].v1 = &vertexes[READUINT32((*data))];
+ segs[k].v2 = &vertexes[READUINT32((*data))];
+ segs[k].linedef = &lines[READUINT16((*data))];
+ segs[k].side = READUINT8((*data));
+ segs[k].glseg = false;
+ }
+ break;
+
+ default:
+ return false;
+ }
+ }
+
+ for (i = 0, seg = segs; i < numsegs; i++, seg++)
+ {
+ vertex_t *v1 = seg->v1;
+ vertex_t *v2 = seg->v2;
+ P_InitializeSeg(seg);
+ seg->angle = R_PointToAngle2(v1->x, v1->y, v2->x, v2->y);
+ seg->offset = FixedHypot(v1->x - seg->linedef->v1->x, v1->y - seg->linedef->v1->y);
+ }
+
+ return true;
+}
+
+// Auxiliary function: Shrink node ID from 32-bit to 16-bit.
+static UINT16 ShrinkNodeID(UINT32 x) {
+ UINT16 mask = (x >> 16) & 0xC000;
+ UINT16 result = x;
+ return result | mask;
+}
+
+static void P_LoadExtendedNodes(UINT8 **data, nodetype_t nodetype)
+{
+ node_t *mn;
+ size_t i, j, k;
+ boolean xgl3 = (nodetype == NT_XGL3);
+
+ numnodes = READINT32((*data));
+ nodes = Z_Calloc(numnodes*sizeof(*nodes), PU_LEVEL, NULL);
+
+ for (i = 0, mn = nodes; i < numnodes; i++, mn++)
+ {
+ // Splitter
+ mn->x = xgl3 ? READINT32((*data)) : (READINT16((*data)) << FRACBITS);
+ mn->y = xgl3 ? READINT32((*data)) : (READINT16((*data)) << FRACBITS);
+ mn->dx = xgl3 ? READINT32((*data)) : (READINT16((*data)) << FRACBITS);
+ mn->dy = xgl3 ? READINT32((*data)) : (READINT16((*data)) << FRACBITS);
+
+ // Bounding boxes
+ for (j = 0; j < 2; j++)
+ for (k = 0; k < 4; k++)
+ mn->bbox[j][k] = READINT16((*data)) << FRACBITS;
+
+ //Children
+ mn->children[0] = ShrinkNodeID(READUINT32((*data))); /// \todo Use UINT32 for node children in a future, instead?
+ mn->children[1] = ShrinkNodeID(READUINT32((*data)));
+ }
+}
+
+static void P_LoadMapBSP(const virtres_t *virt)
+{
+ UINT8 *nodedata = NULL;
+ nodetype_t nodetype = P_GetNodetype(virt, &nodedata);
+
+ switch (nodetype)
+ {
+ case NT_DOOM:
+ {
+ virtlump_t *virtssectors = vres_Find(virt, "SSECTORS");
+ virtlump_t* virtnodes = vres_Find(virt, "NODES");
+ virtlump_t *virtsegs = vres_Find(virt, "SEGS");
+
+ numsubsectors = virtssectors->size / sizeof(mapsubsector_t);
+ numnodes = virtnodes->size / sizeof(mapnode_t);
+ numsegs = virtsegs->size / sizeof(mapseg_t);
+
+ if (numsubsectors <= 0)
+ I_Error("Level has no subsectors (did you forget to run it through a nodesbuilder?)");
+ if (numnodes <= 0)
+ I_Error("Level has no nodes");
+ if (numsegs <= 0)
+ I_Error("Level has no segs");
+
+ subsectors = Z_Calloc(numsubsectors * sizeof(*subsectors), PU_LEVEL, NULL);
+ nodes = Z_Calloc(numnodes * sizeof(*nodes), PU_LEVEL, NULL);
+ segs = Z_Calloc(numsegs * sizeof(*segs), PU_LEVEL, NULL);
+
+ P_LoadSubsectors(virtssectors->data);
+ P_LoadNodes(virtnodes->data);
+ P_LoadSegs(virtsegs->data);
+ break;
+ }
+ case NT_XNOD:
+ case NT_XGLN:
+ case NT_XGL3:
+ if (!P_LoadExtraVertices(&nodedata))
+ return;
+ if (!P_LoadExtendedSubsectorsAndSegs(&nodedata, nodetype))
+ return;
+ P_LoadExtendedNodes(&nodedata, nodetype);
+ break;
+ default:
+ CONS_Alert(CONS_WARNING, "Unsupported BSP format detected.\n");
+ return;
+ }
+ return;
+}
+
+// Split from P_LoadBlockMap for convenience
+// -- Monster Iestyn 08/01/18
+static void P_ReadBlockMapLump(INT16 *wadblockmaplump, size_t count)
+{
+ size_t i;
+ blockmaplump = Z_Calloc(sizeof (*blockmaplump) * count, PU_LEVEL, NULL);
+
+ // killough 3/1/98: Expand wad blockmap into larger internal one,
+ // by treating all offsets except -1 as unsigned and zero-extending
+ // them. This potentially doubles the size of blockmaps allowed,
+ // because Doom originally considered the offsets as always signed.
+
+ blockmaplump[0] = SHORT(wadblockmaplump[0]);
+ blockmaplump[1] = SHORT(wadblockmaplump[1]);
+ blockmaplump[2] = (INT32)(SHORT(wadblockmaplump[2])) & 0xffff;
+ blockmaplump[3] = (INT32)(SHORT(wadblockmaplump[3])) & 0xffff;
+
+ for (i = 4; i < count; i++)
+ {
+ INT16 t = SHORT(wadblockmaplump[i]); // killough 3/1/98
+ blockmaplump[i] = t == -1 ? (INT32)-1 : (INT32) t & 0xffff;
+ }
+}
+
+// This needs to be a separate function
+// because making both the WAD and PK3 loading code use
+// the same functions is trickier than it looks for blockmap
+// -- Monster Iestyn 09/01/18
+static boolean P_LoadBlockMap(UINT8 *data, size_t count)
{
- UINT8 *data = W_CacheLumpNum(lumpnum, PU_STATIC);
- P_LoadRawSideDefs2(data);
- Z_Free(data);
-}
+ if (!count || count >= 0x20000)
+ return false;
+
+ //CONS_Printf("Reading blockmap lump for pk3...\n");
+
+ // no need to malloc anything, assume the data is uncompressed for now
+ count /= 2;
+ P_ReadBlockMapLump((INT16 *)data, count);
+
+ bmaporgx = blockmaplump[0]<<FRACBITS;
+ bmaporgy = blockmaplump[1]<<FRACBITS;
+ bmapwidth = blockmaplump[2];
+ bmapheight = blockmaplump[3];
+ // clear out mobj chains
+ count = sizeof (*blocklinks)* bmapwidth*bmapheight;
+ blocklinks = Z_Calloc(count, PU_LEVEL, NULL);
+ blockmap = blockmaplump+4;
+
+#ifdef POLYOBJECTS
+ // haleyjd 2/22/06: setup polyobject blockmap
+ count = sizeof(*polyblocklinks) * bmapwidth * bmapheight;
+ polyblocklinks = Z_Calloc(count, PU_LEVEL, NULL);
+#endif
+ return true;
+}
static boolean LineInBlock(fixed_t cx1, fixed_t cy1, fixed_t cx2, fixed_t cy2, fixed_t bx1, fixed_t by1)
{
@@ -1849,156 +2051,147 @@ static void P_CreateBlockMap(void)
}
}
-// Split from P_LoadBlockMap for convenience
-// -- Monster Iestyn 08/01/18
-static void P_ReadBlockMapLump(INT16 *wadblockmaplump, size_t count)
+// PK3 version
+// -- Monster Iestyn 09/01/18
+static void P_LoadReject(UINT8 *data, size_t count)
{
- size_t i;
- blockmaplump = Z_Calloc(sizeof (*blockmaplump) * count, PU_LEVEL, NULL);
-
- // killough 3/1/98: Expand wad blockmap into larger internal one,
- // by treating all offsets except -1 as unsigned and zero-extending
- // them. This potentially doubles the size of blockmaps allowed,
- // because Doom originally considered the offsets as always signed.
-
- blockmaplump[0] = SHORT(wadblockmaplump[0]);
- blockmaplump[1] = SHORT(wadblockmaplump[1]);
- blockmaplump[2] = (INT32)(SHORT(wadblockmaplump[2])) & 0xffff;
- blockmaplump[3] = (INT32)(SHORT(wadblockmaplump[3])) & 0xffff;
-
- for (i = 4; i < count; i++)
+ if (!count) // zero length, someone probably used ZDBSP
{
- INT16 t = SHORT(wadblockmaplump[i]); // killough 3/1/98
- blockmaplump[i] = t == -1 ? (INT32)-1 : (INT32) t & 0xffff;
+ rejectmatrix = NULL;
+ CONS_Debug(DBG_SETUP, "P_LoadReject: REJECT lump has size 0, will not be loaded\n");
+ }
+ else
+ {
+ rejectmatrix = Z_Malloc(count, PU_LEVEL, NULL); // allocate memory for the reject matrix
+ M_Memcpy(rejectmatrix, data, count); // copy the data into it
}
}
-//
-// P_LoadBlockMap
-//
-// Levels might not have a blockmap, so if one does not exist
-// this should return false.
-static boolean P_LoadBlockMap(lumpnum_t lumpnum)
+static void P_LoadMapLUT(const virtres_t *virt)
{
-#if 0
- (void)lumpnum;
- return false;
-#else
- size_t count;
- const char *lumpname = W_CheckNameForNum(lumpnum);
+ virtlump_t* virtblockmap = vres_Find(virt, "BLOCKMAP");
+ virtlump_t* virtreject = vres_Find(virt, "REJECT");
+
+ // Lookup tables
+ if (virtreject)
+ P_LoadReject(virtreject->data, virtreject->size);
+ else
+ rejectmatrix = NULL;
- // Check if the lump exists, and if it's named "BLOCKMAP"
- if (!lumpname || memcmp(lumpname, "BLOCKMAP", 8) != 0)
+ if (!(virtblockmap && P_LoadBlockMap(virtblockmap->data, virtblockmap->size)))
+ P_CreateBlockMap();
+}
+
+static void P_ProcessLinedefsWithSidedefs(void)
+{
+ size_t i = numlines;
+ register line_t *ld = lines;
+ for (;i--;ld++)
{
- return false;
- }
+ ld->frontsector = sides[ld->sidenum[0]].sector; //e6y: Can't be -1 here
+ ld->backsector = ld->sidenum[1] != 0xffff ? sides[ld->sidenum[1]].sector : 0;
+
+ // Repeat count for midtexture
+ if ((ld->flags & ML_EFFECT5) && (ld->sidenum[1] != 0xffff)
+ && !(ld->special >= 300 && ld->special < 500)) // exempt linedef exec specials
+ {
+ sides[ld->sidenum[0]].repeatcnt = (INT16)(((unsigned)sides[ld->sidenum[0]].textureoffset >> FRACBITS) >> 12);
+ sides[ld->sidenum[0]].textureoffset = (((unsigned)sides[ld->sidenum[0]].textureoffset >> FRACBITS) & 2047) << FRACBITS;
+ sides[ld->sidenum[1]].repeatcnt = (INT16)(((unsigned)sides[ld->sidenum[1]].textureoffset >> FRACBITS) >> 12);
+ sides[ld->sidenum[1]].textureoffset = (((unsigned)sides[ld->sidenum[1]].textureoffset >> FRACBITS) & 2047) << FRACBITS;
+ }
- count = W_LumpLength(lumpnum);
+ // Compile linedef 'text' from both sidedefs 'text' for appropriate specials.
+ switch(ld->special)
+ {
+ case 331: // Trigger linedef executor: Skin - Continuous
+ case 332: // Trigger linedef executor: Skin - Each time
+ case 333: // Trigger linedef executor: Skin - Once
+ case 443: // Calls a named Lua function
+ if (sides[ld->sidenum[0]].text)
+ {
+ size_t len = strlen(sides[ld->sidenum[0]].text)+1;
+ if (ld->sidenum[1] != 0xffff && sides[ld->sidenum[1]].text)
+ len += strlen(sides[ld->sidenum[1]].text);
+ ld->text = Z_Malloc(len, PU_LEVEL, NULL);
+ M_Memcpy(ld->text, sides[ld->sidenum[0]].text, strlen(sides[ld->sidenum[0]].text)+1);
+ if (ld->sidenum[1] != 0xffff && sides[ld->sidenum[1]].text)
+ M_Memcpy(ld->text+strlen(ld->text)+1, sides[ld->sidenum[1]].text, strlen(sides[ld->sidenum[1]].text)+1);
+ }
+ break;
+ }
+ }
+}
- if (!count || count >= 0x20000)
- return false;
+static void P_CompressSidedefs(void)
+{
+ side_t *newsides;
+ size_t numnewsides = 0;
+ size_t z;
+ size_t i;
+ for (i = 0; i < numsides; i++)
{
- INT16 *wadblockmaplump = malloc(count); //INT16 *wadblockmaplump = W_CacheLumpNum (lump, PU_LEVEL);
- if (!wadblockmaplump)
- return false;
- W_ReadLump(lumpnum, wadblockmaplump);
- count /= 2;
- P_ReadBlockMapLump(wadblockmaplump, count);
- free(wadblockmaplump);
- }
+ size_t j, k;
+ line_t *ld;
- bmaporgx = blockmaplump[0]<<FRACBITS;
- bmaporgy = blockmaplump[1]<<FRACBITS;
- bmapwidth = blockmaplump[2];
- bmapheight = blockmaplump[3];
+ if (!sides[i].sector)
+ continue;
- // clear out mobj chains
- count = sizeof (*blocklinks)* bmapwidth*bmapheight;
- blocklinks = Z_Calloc(count, PU_LEVEL, NULL);
- blockmap = blockmaplump+4;
+ for (k = numlines, ld = lines; k--; ld++)
+ {
+ if (ld->sidenum[0] == i)
+ ld->sidenum[0] = (UINT16)numnewsides;
-#ifdef POLYOBJECTS
- // haleyjd 2/22/06: setup polyobject blockmap
- count = sizeof(*polyblocklinks) * bmapwidth * bmapheight;
- polyblocklinks = Z_Calloc(count, PU_LEVEL, NULL);
-#endif
- return true;
-/* Original
- blockmaplump = W_CacheLumpNum(lump, PU_LEVEL);
- blockmap = blockmaplump+4;
- count = W_LumpLength (lump)/2;
+ if (ld->sidenum[1] == i)
+ ld->sidenum[1] = (UINT16)numnewsides;
+ }
+
+ for (j = i + 1; j < numsides; j++)
+ {
+ if (!sides[j].sector)
+ continue;
- for (i = 0; i < count; i++)
- blockmaplump[i] = SHORT(blockmaplump[i]);
+ if (!memcmp(&sides[i], &sides[j], sizeof(side_t)))
+ {
+ // Find the linedefs that belong to this one
+ for (k = numlines, ld = lines; k--; ld++)
+ {
+ if (ld->sidenum[0] == j)
+ ld->sidenum[0] = (UINT16)numnewsides;
- bmaporgx = blockmaplump[0]<<FRACBITS;
- bmaporgy = blockmaplump[1]<<FRACBITS;
- bmapwidth = blockmaplump[2];
- bmapheight = blockmaplump[3];
+ if (ld->sidenum[1] == j)
+ ld->sidenum[1] = (UINT16)numnewsides;
+ }
+ sides[j].sector = NULL; // Flag for deletion
+ }
+ }
+ numnewsides++;
}
- // clear out mobj chains
- count = sizeof (*blocklinks)*bmapwidth*bmapheight;
- blocklinks = Z_Calloc(count, PU_LEVEL, NULL);
- return true;
- */
-#endif
-}
+ // We're loading crap into this block anyhow, so no point in zeroing it out.
+ newsides = Z_Malloc(numnewsides*sizeof(*newsides), PU_LEVEL, NULL);
-// This needs to be a separate function
-// because making both the WAD and PK3 loading code use
-// the same functions is trickier than it looks for blockmap
-// -- Monster Iestyn 09/01/18
-static boolean P_LoadRawBlockMap(UINT8 *data, size_t count, const char *lumpname)
-{
-#if 0
- (void)data;
- (void)count;
- (void)lumpname;
- return false;
-#else
- // Check if the lump is named "BLOCKMAP"
- if (!lumpname || memcmp(lumpname, "BLOCKMAP", 8) != 0)
+ // Copy the sides to their new block of memory.
+ for (i = 0, z = 0; i < numsides; i++)
{
- CONS_Printf("No blockmap lump found for pk3!\n");
- return false;
+ if (sides[i].sector)
+ M_Memcpy(&newsides[z++], &sides[i], sizeof(side_t));
}
- if (!count || count >= 0x20000)
- return false;
-
- //CONS_Printf("Reading blockmap lump for pk3...\n");
-
- // no need to malloc anything, assume the data is uncompressed for now
- count /= 2;
- P_ReadBlockMapLump((INT16 *)data, count);
-
- bmaporgx = blockmaplump[0]<<FRACBITS;
- bmaporgy = blockmaplump[1]<<FRACBITS;
- bmapwidth = blockmaplump[2];
- bmapheight = blockmaplump[3];
-
- // clear out mobj chains
- count = sizeof (*blocklinks)* bmapwidth*bmapheight;
- blocklinks = Z_Calloc(count, PU_LEVEL, NULL);
- blockmap = blockmaplump+4;
+ CONS_Debug(DBG_SETUP, "P_CompressSidedefs: Old sides is %s, new sides is %s\n", sizeu1(numsides), sizeu1(numnewsides));
-#ifdef POLYOBJECTS
- // haleyjd 2/22/06: setup polyobject blockmap
- count = sizeof(*polyblocklinks) * bmapwidth * bmapheight;
- polyblocklinks = Z_Calloc(count, PU_LEVEL, NULL);
-#endif
- return true;
-#endif
+ Z_Free(sides);
+ sides = newsides;
+ numsides = numnewsides;
}
//
-// P_GroupLines
+// P_LinkMapData
// Builds sector line lists and subsector sector numbers.
// Finds block bounding boxes for sectors.
//
-static void P_GroupLines(void)
+static void P_LinkMapData(void)
{
size_t i, j;
line_t *li;
@@ -2012,20 +2205,20 @@ static void P_GroupLines(void)
for (i = 0; i < numsubsectors; i++, ss++)
{
if (ss->firstline >= numsegs)
- CorruptMapError(va("P_GroupLines: ss->firstline invalid "
+ CorruptMapError(va("P_LinkMapData: ss->firstline invalid "
"(subsector %s, firstline refers to %d of %s)", sizeu1(i), ss->firstline,
sizeu2(numsegs)));
seg = &segs[ss->firstline];
sidei = (size_t)(seg->sidedef - sides);
if (!seg->sidedef)
- CorruptMapError(va("P_GroupLines: seg->sidedef is NULL "
+ CorruptMapError(va("P_LinkMapData: seg->sidedef is NULL "
"(subsector %s, firstline is %d)", sizeu1(i), ss->firstline));
if (seg->sidedef - sides < 0 || seg->sidedef - sides > (UINT16)numsides)
- CorruptMapError(va("P_GroupLines: seg->sidedef refers to sidedef %s of %s "
+ CorruptMapError(va("P_LinkMapData: seg->sidedef refers to sidedef %s of %s "
"(subsector %s, firstline is %d)", sizeu1(sidei), sizeu2(numsides),
sizeu3(i), ss->firstline));
if (!seg->sidedef->sector)
- CorruptMapError(va("P_GroupLines: seg->sidedef->sector is NULL "
+ CorruptMapError(va("P_LinkMapData: seg->sidedef->sector is NULL "
"(subsector %s, firstline is %d, sidedef is %s)", sizeu1(i), ss->firstline,
sizeu1(sidei)));
ss->sector = seg->sidedef->sector;
@@ -2046,7 +2239,7 @@ static void P_GroupLines(void)
if (sector->linecount == 0) // no lines found?
{
sector->lines = NULL;
- CONS_Debug(DBG_SETUP, "P_GroupLines: sector %s has no lines\n", sizeu1(i));
+ CONS_Debug(DBG_SETUP, "P_LinkMapData: sector %s has no lines\n", sizeu1(i));
}
else
{
@@ -2089,95 +2282,80 @@ static void P_GroupLines(void)
}
}
-//
-// P_LoadReject
-//
-// Detect if the REJECT lump is valid,
-// if not, rejectmatrix will be NULL
-static void P_LoadReject(lumpnum_t lumpnum)
+/** Compute MD5 message digest for bytes read from memory source
+ *
+ * The resulting message digest number will be written into the 16 bytes
+ * beginning at RESBLOCK.
+ *
+ * \param filename path of file
+ * \param resblock resulting MD5 checksum
+ * \return 0 if MD5 checksum was made, and is at resblock, 1 if error was found
+ */
+static INT32 P_MakeBufferMD5(const char *buffer, size_t len, void *resblock)
{
- size_t count;
- const char *lumpname = W_CheckNameForNum(lumpnum);
-
- // Check if the lump exists, and if it's named "REJECT"
- if (!lumpname || memcmp(lumpname, "REJECT\0\0", 8) != 0)
- {
- rejectmatrix = NULL;
- CONS_Debug(DBG_SETUP, "P_LoadReject: No valid REJECT lump found\n");
- return;
- }
-
- count = W_LumpLength(lumpnum);
-
- if (!count) // zero length, someone probably used ZDBSP
- {
- rejectmatrix = NULL;
- CONS_Debug(DBG_SETUP, "P_LoadReject: REJECT lump has size 0, will not be loaded\n");
- }
- else
- rejectmatrix = W_CacheLumpNum(lumpnum, PU_LEVEL);
+#ifdef NOMD5
+ (void)buffer;
+ (void)len;
+ memset(resblock, 0x00, 16);
+ return 1;
+#else
+ tic_t t = I_GetTime();
+ CONS_Debug(DBG_SETUP, "Making MD5\n");
+ if (md5_buffer(buffer, len, resblock) == NULL)
+ return 1;
+ CONS_Debug(DBG_SETUP, "MD5 calc took %f seconds\n", (float)(I_GetTime() - t)/NEWTICRATE);
+ return 0;
+#endif
}
-// PK3 version
-// -- Monster Iestyn 09/01/18
-static void P_LoadRawReject(UINT8 *data, size_t count, const char *lumpname)
+static void P_MakeMapMD5(virtres_t *virt, void *dest)
{
- // Check if the lump is named "REJECT"
- if (!lumpname || memcmp(lumpname, "REJECT\0\0", 8) != 0)
- {
- rejectmatrix = NULL;
- CONS_Debug(DBG_SETUP, "P_LoadRawReject: No valid REJECT lump found\n");
- return;
- }
+ unsigned char linemd5[16];
+ unsigned char sectormd5[16];
+ unsigned char thingmd5[16];
+ unsigned char sidedefmd5[16];
+ unsigned char resmd5[16];
+ UINT8 i;
- if (!count) // zero length, someone probably used ZDBSP
- {
- rejectmatrix = NULL;
- CONS_Debug(DBG_SETUP, "P_LoadRawReject: REJECT lump has size 0, will not be loaded\n");
- }
- else
- {
- rejectmatrix = Z_Malloc(count, PU_LEVEL, NULL); // allocate memory for the reject matrix
- M_Memcpy(rejectmatrix, data, count); // copy the data into it
- }
+ // Create a hash for the current map
+ // get the actual lumps!
+ virtlump_t *virtlines = vres_Find(virt, "LINEDEFS");
+ virtlump_t *virtsectors = vres_Find(virt, "SECTORS");
+ virtlump_t *virtmthings = vres_Find(virt, "THINGS");
+ virtlump_t *virtsides = vres_Find(virt, "SIDEDEFS");
+
+ P_MakeBufferMD5((char*)virtlines->data, virtlines->size, linemd5);
+ P_MakeBufferMD5((char*)virtsectors->data, virtsectors->size, sectormd5);
+ P_MakeBufferMD5((char*)virtmthings->data, virtmthings->size, thingmd5);
+ P_MakeBufferMD5((char*)virtsides->data, virtsides->size, sidedefmd5);
+
+ for (i = 0; i < 16; i++)
+ resmd5[i] = (linemd5[i] + sectormd5[i] + thingmd5[i] + sidedefmd5[i]) & 0xFF;
+
+ M_Memcpy(dest, &resmd5, 16);
}
-#if 0
-static char *levellumps[] =
+static void P_LoadMapFromFile(void)
{
- "label", // ML_LABEL, A separator, name, MAPxx
- "THINGS", // ML_THINGS, Enemies, items..
- "LINEDEFS", // ML_LINEDEFS, Linedefs, from editing
- "SIDEDEFS", // ML_SIDEDEFS, Sidedefs, from editing
- "VERTEXES", // ML_VERTEXES, Vertices, edited and BSP splits generated
- "SEGS", // ML_SEGS, Linesegs, from linedefs split by BSP
- "SSECTORS", // ML_SSECTORS, Subsectors, list of linesegs
- "NODES", // ML_NODES, BSP nodes
- "SECTORS", // ML_SECTORS, Sectors, from editing
- "REJECT", // ML_REJECT, LUT, sector-sector visibility
-};
+ virtres_t *virt = vres_GetMap(lastloadedmaplumpnum);
-/** Checks a lump and returns whether it is a valid start-of-level marker.
- *
- * \param lumpnum Lump number to check.
- * \return True if the lump is a valid level marker, false if not.
- */
-static inline boolean P_CheckLevel(lumpnum_t lumpnum)
-{
- UINT16 file, lump;
- size_t i;
+ P_LoadMapData(virt);
+ P_LoadMapBSP(virt);
+ P_LoadMapLUT(virt);
- for (i = ML_THINGS; i <= ML_REJECT; i++)
- {
- file = WADFILENUM(lumpnum);
- lump = LUMPNUM(lumpnum+1);
- if (file > numwadfiles || lump < LUMPNUM(lumpnum) || lump > wadfiles[file]->numlumps ||
- memcmp(wadfiles[file]->lumpinfo[lump].name, levellumps[i], 8) != 0)
- return false;
- }
- return true; // all right
+ P_ProcessLinedefsWithSidedefs();
+ if (M_CheckParm("-compress"))
+ P_CompressSidedefs();
+ P_LinkMapData();
+
+ P_MakeMapMD5(virt, &mapmd5);
+
+ vres_Free(virt);
}
-#endif
+
+//
+// LEVEL INITIALIZATION FUNCTIONS
+//
/** Sets up a sky texture to use for the level.
* The sky texture is used instead of F_SKY1.
@@ -2210,7 +2388,7 @@ lumpnum_t lastloadedmaplumpnum; // for comparative savegame
//
// Some player initialization for map start.
//
-static void P_LevelInitStuff(void)
+static void P_InitLevelSettings(void)
{
INT32 i;
boolean canresetlives = true;
@@ -2307,12 +2485,8 @@ static void P_LevelInitStuff(void)
CV_SetValue(&cv_analog[1], true);
}
-//
-// P_LoadThingsOnly
-//
-// "Reloads" a level, but only reloads all of the mobjs.
-//
-void P_LoadThingsOnly(void)
+// Respawns all the mapthings and mobjs in the map from the already loaded map data.
+void P_RespawnThings(void)
{
// Search through all the thinkers.
thinker_t *think;
@@ -2328,7 +2502,6 @@ void P_LoadThingsOnly(void)
centerid = i; // save id just in case
}
-
for (think = thlist[THINK_MOBJ].next; think != &thlist[THINK_MOBJ]; think = think->next)
{
if (think->function.acp1 == (actionf_p1)P_RemoveThinkerDelayed)
@@ -2336,83 +2509,15 @@ void P_LoadThingsOnly(void)
P_RemoveMobj((mobj_t *)think);
}
- P_LevelInitStuff();
+ P_InitLevelSettings();
- if (W_IsLumpWad(lastloadedmaplumpnum)) // welp it's a map wad in a pk3
- { // HACK: Open wad file rather quickly so we can use the things lump
- UINT8 *wadData = W_CacheLumpNum(lastloadedmaplumpnum, PU_STATIC);
- filelump_t *fileinfo = (filelump_t *)(wadData + ((wadinfo_t *)wadData)->infotableofs);
- fileinfo += ML_THINGS; // we only need the THINGS lump
- P_PrepareRawThings(wadData + fileinfo->filepos, fileinfo->size);
- Z_Free(wadData); // we're done with this now
- }
- else // phew it's just a WAD
- P_PrepareThings(lastloadedmaplumpnum + ML_THINGS);
- P_LoadThings(true);
+ P_SpawnMapThings(true);
// restore skybox viewpoint/centerpoint if necessary, set them to defaults if we can't do that
skyboxmo[0] = skyboxviewpnts[(viewid >= 0) ? viewid : 0];
skyboxmo[1] = skyboxcenterpnts[(centerid >= 0) ? centerid : 0];
}
-/** Compute MD5 message digest for bytes read from memory source
- *
- * The resulting message digest number will be written into the 16 bytes
- * beginning at RESBLOCK.
- *
- * \param filename path of file
- * \param resblock resulting MD5 checksum
- * \return 0 if MD5 checksum was made, and is at resblock, 1 if error was found
- */
-static INT32 P_MakeBufferMD5(const char *buffer, size_t len, void *resblock)
-{
-#ifdef NOMD5
- (void)buffer;
- (void)len;
- memset(resblock, 0x00, 16);
- return 1;
-#else
- tic_t t = I_GetTime();
- CONS_Debug(DBG_SETUP, "Making MD5\n");
- if (md5_buffer(buffer, len, resblock) == NULL)
- return 1;
- CONS_Debug(DBG_SETUP, "MD5 calc took %f seconds\n", (float)(I_GetTime() - t)/NEWTICRATE);
- return 0;
-#endif
-}
-
-static void P_MakeMapMD5(lumpnum_t maplumpnum, void *dest)
-{
- unsigned char linemd5[16];
- unsigned char sectormd5[16];
- unsigned char thingmd5[16];
- unsigned char sidedefmd5[16];
- unsigned char resmd5[16];
- UINT8 i;
-
- // Create a hash for the current map
- // get the actual lumps!
- UINT8 *datalines = W_CacheLumpNum(maplumpnum + ML_LINEDEFS, PU_CACHE);
- UINT8 *datasectors = W_CacheLumpNum(maplumpnum + ML_SECTORS, PU_CACHE);
- UINT8 *datathings = W_CacheLumpNum(maplumpnum + ML_THINGS, PU_CACHE);
- UINT8 *datasides = W_CacheLumpNum(maplumpnum + ML_SIDEDEFS, PU_CACHE);
-
- P_MakeBufferMD5((char*)datalines, W_LumpLength(maplumpnum + ML_LINEDEFS), linemd5);
- P_MakeBufferMD5((char*)datasectors, W_LumpLength(maplumpnum + ML_SECTORS), sectormd5);
- P_MakeBufferMD5((char*)datathings, W_LumpLength(maplumpnum + ML_THINGS), thingmd5);
- P_MakeBufferMD5((char*)datasides, W_LumpLength(maplumpnum + ML_SIDEDEFS), sidedefmd5);
-
- Z_Free(datalines);
- Z_Free(datasectors);
- Z_Free(datathings);
- Z_Free(datasides);
-
- for (i = 0; i < 16; i++)
- resmd5[i] = (linemd5[i] + sectormd5[i] + thingmd5[i] + sidedefmd5[i]) & 0xFF;
-
- M_Memcpy(dest, &resmd5, 16);
-}
-
static void P_RunLevelScript(const char *scriptname)
{
if (!(mapheaderinfo[gamemap-1]->levelflags & LF_SCRIPTISFILE))
@@ -2477,6 +2582,26 @@ static void P_ForceCharacter(const char *forcecharskin)
}
}
+static void P_ResetSpawnpoints(void)
+{
+ UINT8 i;
+
+ numdmstarts = numredctfstarts = numbluectfstarts = 0;
+
+ // reset the player starts
+ for (i = 0; i < MAXPLAYERS; i++)
+ playerstarts[i] = bluectfstarts[i] = redctfstarts[i] = NULL;
+
+ for (i = 0; i < MAX_DM_STARTS; i++)
+ deathmatchstarts[i] = NULL;
+
+ for (i = 0; i < 2; i++)
+ skyboxmo[i] = NULL;
+
+ for (i = 0; i < 16; i++)
+ skyboxviewpnts[i] = skyboxcenterpnts[i] = NULL;
+}
+
static void P_LoadRecordGhosts(void)
{
const size_t glen = strlen(srb2home)+1+strlen("replay")+1+strlen(timeattackfolder)+1+strlen("MAPXX")+1;
@@ -2540,110 +2665,360 @@ static void P_LoadRecordGhosts(void)
}
}
- // Guest ghost
- if (cv_ghost_guest.value && FIL_FileExists(va("%s-guest.lmp", gpath)))
- G_AddGhost(va("%s-guest.lmp", gpath));
+ // Guest ghost
+ if (cv_ghost_guest.value && FIL_FileExists(va("%s-guest.lmp", gpath)))
+ G_AddGhost(va("%s-guest.lmp", gpath));
+
+ free(gpath);
+}
+
+static void P_LoadNightsGhosts(void)
+{
+ const size_t glen = strlen(srb2home)+1+strlen("replay")+1+strlen(timeattackfolder)+1+strlen("MAPXX")+1;
+ char *gpath = malloc(glen);
+
+ if (!gpath)
+ return;
+
+ sprintf(gpath,"%s"PATHSEP"replay"PATHSEP"%s"PATHSEP"%s", srb2home, timeattackfolder, G_BuildMapName(gamemap));
+
+ // Best Score ghost
+ if (cv_ghost_bestscore.value && FIL_FileExists(va("%s-score-best.lmp", gpath)))
+ G_AddGhost(va("%s-score-best.lmp", gpath));
+
+ // Best Time ghost
+ if (cv_ghost_besttime.value && FIL_FileExists(va("%s-time-best.lmp", gpath)))
+ G_AddGhost(va("%s-time-best.lmp", gpath));
+
+ // Last ghost
+ if (cv_ghost_last.value && FIL_FileExists(va("%s-last.lmp", gpath)))
+ G_AddGhost(va("%s-last.lmp", gpath));
+
+ // Guest ghost
+ if (cv_ghost_guest.value && FIL_FileExists(va("%s-guest.lmp", gpath)))
+ G_AddGhost(va("%s-guest.lmp", gpath));
+
+ free(gpath);
+}
+
+static void P_InitTagGametype(void)
+{
+ UINT8 i;
+ INT32 realnumplayers = 0;
+ INT32 playersactive[MAXPLAYERS];
+
+ //I just realized how problematic this code can be.
+ //D_NumPlayers() will not always cover the scope of the netgame.
+ //What if one player is node 0 and the other node 31?
+ //The solution? Make a temp array of all players that are currently playing and pick from them.
+ //Future todo? When a player leaves, shift all nodes down so D_NumPlayers() can be used as intended?
+ //Also, you'd never have to loop through all 32 players slots to find anything ever again.
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ if (playeringame[i] && !players[i].spectator)
+ {
+ playersactive[realnumplayers] = i; //stores the player's node in the array.
+ realnumplayers++;
+ }
+ }
+
+ if (!realnumplayers) //this should also fix the dedicated crash bug. You only pick a player if one exists to be picked.
+ {
+ CONS_Printf(M_GetText("No player currently available to become IT. Awaiting available players.\n"));
+ return;
+ }
+
+ i = P_RandomKey(realnumplayers);
+ players[playersactive[i]].pflags |= PF_TAGIT; //choose our initial tagger before map starts.
+
+ // Taken and modified from G_DoReborn()
+ // Remove the player so he can respawn elsewhere.
+ // first disassociate the corpse
+ if (players[playersactive[i]].mo)
+ P_RemoveMobj(players[playersactive[i]].mo);
+
+ G_SpawnPlayer(playersactive[i], false); //respawn the lucky player in his dedicated spawn location.
+}
+
+static void P_SetupCamera(void)
+{
+ if (players[displayplayer].mo && (server || addedtogame))
+ {
+ camera.x = players[displayplayer].mo->x;
+ camera.y = players[displayplayer].mo->y;
+ camera.z = players[displayplayer].mo->z;
+ camera.angle = players[displayplayer].mo->angle;
+ camera.subsector = R_PointInSubsector(camera.x, camera.y); // make sure camera has a subsector set -- Monster Iestyn (12/11/18)
+ }
+ else
+ {
+ mapthing_t *thing;
+
+ switch (gametype)
+ {
+ case GT_MATCH:
+ case GT_TAG:
+ thing = deathmatchstarts[0];
+ break;
+
+ default:
+ thing = playerstarts[0];
+ break;
+ }
+
+ if (thing)
+ {
+ camera.x = thing->x;
+ camera.y = thing->y;
+ camera.z = thing->z;
+ camera.angle = FixedAngle((fixed_t)thing->angle << FRACBITS);
+ camera.subsector = R_PointInSubsector(camera.x, camera.y); // make sure camera has a subsector set -- Monster Iestyn (12/11/18)
+ }
+ }
+}
+
+static void P_InitCamera(void)
+{
+ if (!dedicated)
+ {
+ P_SetupCamera();
+
+ // Salt: CV_ClearChangedFlags() messes with your settings :(
+ /*if (!cv_cam_height.changed)
+ CV_Set(&cv_cam_height, cv_cam_height.defaultvalue);
+ if (!cv_cam2_height.changed)
+ CV_Set(&cv_cam2_height, cv_cam2_height.defaultvalue);
+
+ if (!cv_cam_dist.changed)
+ CV_Set(&cv_cam_dist, cv_cam_dist.defaultvalue);
+ if (!cv_cam2_dist.changed)
+ CV_Set(&cv_cam2_dist, cv_cam2_dist.defaultvalue);*/
+
+ // Though, I don't think anyone would care about cam_rotate being reset back to the only value that makes sense :P
+ if (!cv_cam_rotate.changed)
+ CV_Set(&cv_cam_rotate, cv_cam_rotate.defaultvalue);
+ if (!cv_cam2_rotate.changed)
+ CV_Set(&cv_cam2_rotate, cv_cam2_rotate.defaultvalue);
+
+ if (!cv_analog[0].changed)
+ CV_SetValue(&cv_analog[0], 0);
+ if (!cv_analog[1].changed)
+ CV_SetValue(&cv_analog[1], 0);
+
+ displayplayer = consoleplayer; // Start with your OWN view, please!
+ }
+
+ if (twodlevel)
+ {
+ CV_SetValue(&cv_analog[0], false);
+ CV_SetValue(&cv_analog[1], false);
+ }
+ else
+ {
+ if (cv_useranalog[0].value)
+ CV_SetValue(&cv_analog[0], true);
+
+ if ((splitscreen && cv_useranalog[1].value) || botingame)
+ CV_SetValue(&cv_analog[1], true);
+ }
+}
+
+static boolean CanSaveLevel(INT32 mapnum)
+{
+ if (ultimatemode) // never save in ultimate (probably redundant with cursaveslot also being checked)
+ return false;
+
+ if (G_IsSpecialStage(mapnum) // don't save in special stages
+ || mapnum == lastmaploaded) // don't save if the last map loaded was this one
+ return false;
+
+ // Any levels that have the savegame flag can save normally.
+ // If the game is complete for this save slot, then any level can save!
+ // On the other side of the spectrum, if lastmaploaded is 0, then the save file has only just been created and needs to save ASAP!
+ return (mapheaderinfo[mapnum-1]->levelflags & LF_SAVEGAME || gamecomplete || !lastmaploaded);
+}
+
+static void P_RunSpecialStageWipe(void)
+{
+ tic_t starttime = I_GetTime();
+ tic_t endtime = starttime + (3*TICRATE)/2;
+ tic_t nowtime;
+
+ S_StartSound(NULL, sfx_s3kaf);
+
+ // Fade music! Time it to S3KAF: 0.25 seconds is snappy.
+ if (RESETMUSIC ||
+ strnicmp(S_MusicName(),
+ (mapmusflags & MUSIC_RELOADRESET) ? mapheaderinfo[gamemap - 1]->musname : mapmusname, 7))
+ S_FadeOutStopMusic(MUSICRATE/4); //FixedMul(FixedDiv(F_GetWipeLength(wipedefs[wipe_speclevel_towhite])*NEWTICRATERATIO, NEWTICRATE), MUSICRATE)
+
+ F_WipeStartScreen();
+ wipestyleflags |= (WSF_FADEOUT|WSF_TOWHITE);
+
+#ifdef HWRENDER
+ // uh..........
+ if (rendermode == render_opengl)
+ F_WipeColorFill(0);
+#endif
+
+ F_WipeEndScreen();
+ F_RunWipe(wipedefs[wipe_speclevel_towhite], false);
+
+ I_OsPolling();
+ I_FinishUpdate(); // page flip or blit buffer
+ if (moviemode)
+ M_SaveFrame();
+
+ nowtime = lastwipetic;
+
+ // Hold on white for extra effect.
+ while (nowtime < endtime)
+ {
+ // wait loop
+ while (!((nowtime = I_GetTime()) - lastwipetic))
+ I_Sleep();
+ lastwipetic = nowtime;
+ if (moviemode) // make sure we save frames for the white hold too
+ M_SaveFrame();
+ }
+}
+
+static void P_RunLevelWipe(void)
+{
+ F_WipeStartScreen();
+ wipestyleflags |= WSF_FADEOUT;
+
+#ifdef HWRENDER
+ // uh..........
+ if (rendermode == render_opengl)
+ F_WipeColorFill(31);
+#endif
+
+ F_WipeEndScreen();
+ // for titlemap: run a specific wipe if specified
+ // needed for exiting time attack
+ if (wipetypepre != INT16_MAX)
+ F_RunWipe(
+ (wipetypepre >= 0 && F_WipeExists(wipetypepre)) ? wipetypepre : wipedefs[wipe_level_toblack],
+ false);
+ wipetypepre = -1;
+}
+
+static void P_InitPlayers(void)
+{
+ UINT8 i;
+
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ if (!playeringame[i])
+ continue;
+
+ // Start players with pity shields if possible
+ players[i].pity = -1;
+
+ players[i].mo = NULL;
- free(gpath);
+ if (!G_PlatformGametype())
+ G_DoReborn(i);
+ else // gametype is GT_COOP or GT_RACE
+ {
+ G_SpawnPlayer(i, players[i].starposttime);
+ if (players[i].starposttime)
+ P_ClearStarPost(players[i].starpostnum);
+ }
+ }
}
-static void P_LoadNightsGhosts(void)
+static void P_WriteLetter(void)
{
- const size_t glen = strlen(srb2home)+1+strlen("replay")+1+strlen(timeattackfolder)+1+strlen("MAPXX")+1;
- char *gpath = malloc(glen);
+ char *buf, *b;
- if (!gpath)
+ if (!unlockables[27].unlocked) // pandora's box
return;
- sprintf(gpath,"%s"PATHSEP"replay"PATHSEP"%s"PATHSEP"%s", srb2home, timeattackfolder, G_BuildMapName(gamemap));
+ if (modeattacking)
+ return;
- // Best Score ghost
- if (cv_ghost_bestscore.value && FIL_FileExists(va("%s-score-best.lmp", gpath)))
- G_AddGhost(va("%s-score-best.lmp", gpath));
+#ifndef DEVELOP
+ if (modifiedgame)
+ return;
+#endif
- // Best Time ghost
- if (cv_ghost_besttime.value && FIL_FileExists(va("%s-time-best.lmp", gpath)))
- G_AddGhost(va("%s-time-best.lmp", gpath));
+ if (netgame || multiplayer)
+ return;
- // Last ghost
- if (cv_ghost_last.value && FIL_FileExists(va("%s-last.lmp", gpath)))
- G_AddGhost(va("%s-last.lmp", gpath));
+ if (gamemap != 0x1d35 - 016464)
+ return;
- // Guest ghost
- if (cv_ghost_guest.value && FIL_FileExists(va("%s-guest.lmp", gpath)))
- G_AddGhost(va("%s-guest.lmp", gpath));
+ P_SpawnMobj(0640370000, 0x11000000, 0x3180000, MT_LETTER)->angle = ANGLE_90;
- free(gpath);
-}
+ if (textprompts[199]->page[1].backcolor == 259)
+ return;
-static void P_SetupCamera(void)
-{
- if (players[displayplayer].mo && (server || addedtogame))
+ buf = W_CacheLumpName("WATERMAP", PU_STATIC);
+ b = buf;
+
+ while ((*b != 65) && (b - buf < 256))
{
- camera.x = players[displayplayer].mo->x;
- camera.y = players[displayplayer].mo->y;
- camera.z = players[displayplayer].mo->z;
- camera.angle = players[displayplayer].mo->angle;
- camera.subsector = R_PointInSubsector(camera.x, camera.y); // make sure camera has a subsector set -- Monster Iestyn (12/11/18)
+ *b = (*b - 65) & 255;
+ b++;
}
- else
- {
- mapthing_t *thing;
+ *b = '\0';
- switch (gametype)
- {
- case GT_MATCH:
- case GT_TAG:
- thing = deathmatchstarts[0];
- break;
+ Z_Free(textprompts[199]->page[1].text);
+ textprompts[199]->page[1].text = Z_StrDup(buf);
+ textprompts[199]->page[1].lines = 4;
+ textprompts[199]->page[1].backcolor = 259;
+ Z_Free(buf);
+}
- default:
- thing = playerstarts[0];
- break;
- }
+static void P_InitGametype(void)
+{
+ UINT8 i;
- if (thing)
+ P_InitPlayers();
+
+ // restore time in netgame (see also g_game.c)
+ if ((netgame || multiplayer) && gametype == GT_COOP && cv_coopstarposts.value == 2)
+ {
+ // is this a hack? maybe
+ tic_t maxstarposttime = 0;
+ for (i = 0; i < MAXPLAYERS; i++)
{
- camera.x = thing->x;
- camera.y = thing->y;
- camera.z = thing->z;
- camera.angle = FixedAngle((fixed_t)thing->angle << FRACBITS);
- camera.subsector = R_PointInSubsector(camera.x, camera.y); // make sure camera has a subsector set -- Monster Iestyn (12/11/18)
+ if (playeringame[i] && players[i].starposttime > maxstarposttime)
+ maxstarposttime = players[i].starposttime;
}
+ leveltime = maxstarposttime;
}
-}
-static boolean CanSaveLevel(INT32 mapnum)
-{
- if (ultimatemode) // never save in ultimate (probably redundant with cursaveslot also being checked)
- return false;
+ P_WriteLetter();
- if (G_IsSpecialStage(mapnum) // don't save in special stages
- || mapnum == lastmaploaded) // don't save if the last map loaded was this one
- return false;
+ if (modeattacking == ATTACKING_RECORD && !demoplayback)
+ P_LoadRecordGhosts();
+ else if (modeattacking == ATTACKING_NIGHTS && !demoplayback)
+ P_LoadNightsGhosts();
- // Any levels that have the savegame flag can save normally.
- // If the game is complete for this save slot, then any level can save!
- // On the other side of the spectrum, if lastmaploaded is 0, then the save file has only just been created and needs to save ASAP!
- return (mapheaderinfo[mapnum-1]->levelflags & LF_SAVEGAME || gamecomplete || !lastmaploaded);
+ if (G_TagGametype())
+ P_InitTagGametype();
+ else if (gametype == GT_RACE && server)
+ CV_StealthSetValue(&cv_numlaps,
+ (cv_basenumlaps.value)
+ ? cv_basenumlaps.value
+ : mapheaderinfo[gamemap - 1]->numlaps);
}
/** Loads a level from a lump or external wad.
*
- * \param skipprecip If true, don't spawn precipitation.
+ * \param fromnetsave If true, skip some stuff because we're loading a netgame snapshot.
* \todo Clean up, refactor, split up; get rid of the bloat.
*/
-boolean P_SetupLevel(boolean skipprecip)
+boolean P_LoadLevel(boolean fromnetsave)
{
// use gamemap to get map number.
// 99% of the things already did, so.
// Map header should always be in place at this point
- INT32 i, loadprecip = 1, ranspecialwipe = 0;
- INT32 loademblems = 1;
- INT32 fromnetsave = 0;
- boolean loadedbm = false;
+ INT32 i, ranspecialwipe = 0;
sector_t *ss;
- boolean chase;
levelloading = true;
// This is needed. Don't touch.
@@ -2674,20 +3049,18 @@ boolean P_SetupLevel(boolean skipprecip)
if (cv_runscripts.value && mapheaderinfo[gamemap-1]->scriptname[0] != '#')
P_RunLevelScript(mapheaderinfo[gamemap-1]->scriptname);
- P_LevelInitStuff();
+ P_InitLevelSettings();
postimgtype = postimgtype2 = postimg_none;
if (mapheaderinfo[gamemap-1]->forcecharacter[0] != '\0')
P_ForceCharacter(mapheaderinfo[gamemap-1]->forcecharacter);
- // chasecam on in chaos, race, coop
- // chasecam off in match, tag, capture the flag
- chase = (gametype == GT_RACE || gametype == GT_COMPETITION || gametype == GT_COOP)
- || (maptol & TOL_2D);
-
if (!dedicated)
{
+ // chasecam on in first-person gametypes and 2D
+ boolean chase = (!(gametyperules & GTR_FIRSTPERSON)) || (maptol & TOL_2D);
+
// Salt: CV_ClearChangedFlags() messes with your settings :(
/*if (!cv_cam_speed.changed)
CV_Set(&cv_cam_speed, cv_cam_speed.defaultvalue);*/
@@ -2717,48 +3090,7 @@ boolean P_SetupLevel(boolean skipprecip)
ranspecialwipe = 2;
else if (rendermode != render_none && G_IsSpecialStage(gamemap))
{
- tic_t starttime = I_GetTime();
- tic_t endtime = starttime + (3*TICRATE)/2;
- tic_t nowtime;
-
- S_StartSound(NULL, sfx_s3kaf);
-
- // Fade music! Time it to S3KAF: 0.25 seconds is snappy.
- if (RESETMUSIC ||
- strnicmp(S_MusicName(),
- (mapmusflags & MUSIC_RELOADRESET) ? mapheaderinfo[gamemap-1]->musname : mapmusname, 7))
- S_FadeOutStopMusic(MUSICRATE/4); //FixedMul(FixedDiv(F_GetWipeLength(wipedefs[wipe_speclevel_towhite])*NEWTICRATERATIO, NEWTICRATE), MUSICRATE)
-
- F_WipeStartScreen();
- wipestyleflags |= (WSF_FADEOUT|WSF_TOWHITE);
-
-#ifdef HWRENDER
- // uh..........
- if (rendermode == render_opengl)
- F_WipeColorFill(0);
-#endif
-
- F_WipeEndScreen();
- F_RunWipe(wipedefs[wipe_speclevel_towhite], false);
-
- I_OsPolling();
- I_FinishUpdate(); // page flip or blit buffer
- if (moviemode)
- M_SaveFrame();
-
- nowtime = lastwipetic;
-
- // Hold on white for extra effect.
- while (nowtime < endtime)
- {
- // wait loop
- while (!((nowtime = I_GetTime()) - lastwipetic))
- I_Sleep();
- lastwipetic = nowtime;
- if (moviemode) // make sure we save frames for the white hold too
- M_SaveFrame();
- }
-
+ P_RunSpecialStageWipe();
ranspecialwipe = 1;
}
@@ -2784,25 +3116,7 @@ boolean P_SetupLevel(boolean skipprecip)
// Let's fade to black here
// But only if we didn't do the special stage wipe
if (rendermode != render_none && !ranspecialwipe)
- {
- F_WipeStartScreen();
- wipestyleflags |= WSF_FADEOUT;
-
-#ifdef HWRENDER
- // uh..........
- if (rendermode == render_opengl)
- F_WipeColorFill(31);
-#endif
-
- F_WipeEndScreen();
- // for titlemap: run a specific wipe if specified
- // needed for exiting time attack
- if (wipetypepre != INT16_MAX)
- F_RunWipe(
- (wipetypepre >= 0 && F_WipeExists(wipetypepre)) ? wipetypepre : wipedefs[wipe_level_toblack],
- false);
- wipetypepre = -1;
- }
+ P_RunLevelWipe();
if (!titlemapinaction)
{
@@ -2860,14 +3174,7 @@ boolean P_SetupLevel(boolean skipprecip)
P_InitThinkers();
P_InitCachedActions();
- /// \note for not spawning precipitation, etc. when loading netgame snapshots
- if (skipprecip)
- {
- fromnetsave = 1;
- loadprecip = 0;
- loademblems = 0;
- }
- else if (savedata.lives > 0)
+ if (!fromnetsave && savedata.lives > 0)
{
numgameovers = savedata.numgameovers;
players[consoleplayer].continues = savedata.continues;
@@ -2881,9 +3188,7 @@ boolean P_SetupLevel(boolean skipprecip)
// internal game map
maplumpname = G_BuildMapName(gamemap);
- //lastloadedmaplumpnum = LUMPERROR;
lastloadedmaplumpnum = W_CheckNumForName(maplumpname);
-
if (lastloadedmaplumpnum == INT16_MAX)
I_Error("Map %s not found.\n", maplumpname);
@@ -2893,111 +3198,12 @@ boolean P_SetupLevel(boolean skipprecip)
// SRB2 determines the sky texture to be used depending on the map header.
P_SetupLevelSky(mapheaderinfo[gamemap-1]->skynum, true);
- P_MakeMapMD5(lastloadedmaplumpnum, &mapmd5);
-
- // HACK ALERT: Cache the WAD, get the map data into the tables, free memory.
- // As it is implemented right now, we're assuming an uncompressed WAD.
- // (As in, a normal PWAD, not ZWAD or anything. The lump itself can be compressed.)
- // We're not accounting for extra lumps and scrambled lump positions. Any additional data will cause an error.
- if (W_IsLumpWad(lastloadedmaplumpnum))
- {
- // Remember that we're assuming that the WAD will have a specific set of lumps in a specific order.
- UINT8 *wadData = W_CacheLumpNum(lastloadedmaplumpnum, PU_STATIC);
- //filelump_t *fileinfo = wadData + ((wadinfo_t *)wadData)->infotableofs;
- filelump_t *fileinfo = (filelump_t *)(wadData + ((wadinfo_t *)wadData)->infotableofs);
- UINT32 numlumps = ((wadinfo_t *)wadData)->numlumps;
-
- if (numlumps < ML_REJECT) // at least 9 lumps should be in the wad for a map to be loaded
- {
- I_Error("Bad WAD file for map %s!\n", maplumpname);
- }
-
- if (numlumps > ML_BLOCKMAP) // enough room for a BLOCKMAP lump at least
- {
- loadedbm = P_LoadRawBlockMap(
- wadData + (fileinfo + ML_BLOCKMAP)->filepos,
- (fileinfo + ML_BLOCKMAP)->size,
- (fileinfo + ML_BLOCKMAP)->name);
- }
- P_LoadRawVertexes(wadData + (fileinfo + ML_VERTEXES)->filepos, (fileinfo + ML_VERTEXES)->size);
- P_LoadRawSectors(wadData + (fileinfo + ML_SECTORS)->filepos, (fileinfo + ML_SECTORS)->size);
- P_LoadRawSideDefs((fileinfo + ML_SIDEDEFS)->size);
- P_LoadRawLineDefs(wadData + (fileinfo + ML_LINEDEFS)->filepos, (fileinfo + ML_LINEDEFS)->size);
- P_LoadRawSideDefs2(wadData + (fileinfo + ML_SIDEDEFS)->filepos);
- P_LoadRawSubsectors(wadData + (fileinfo + ML_SSECTORS)->filepos, (fileinfo + ML_SSECTORS)->size);
- P_LoadRawNodes(wadData + (fileinfo + ML_NODES)->filepos, (fileinfo + ML_NODES)->size);
- P_LoadRawSegs(wadData + (fileinfo + ML_SEGS)->filepos, (fileinfo + ML_SEGS)->size);
- if (numlumps > ML_REJECT) // enough room for a REJECT lump at least
- {
- P_LoadRawReject(
- wadData + (fileinfo + ML_REJECT)->filepos,
- (fileinfo + ML_REJECT)->size,
- (fileinfo + ML_REJECT)->name);
- }
-
- // Important: take care of the ordering of the next functions.
- if (!loadedbm)
- P_CreateBlockMap(); // Graue 02-29-2004
- P_LoadLineDefs2();
- P_GroupLines();
- numdmstarts = numredctfstarts = numbluectfstarts = 0;
-
- // reset the player starts
- for (i = 0; i < MAXPLAYERS; i++)
- playerstarts[i] = bluectfstarts[i] = redctfstarts[i] = NULL;
-
- for (i = 0; i < MAX_DM_STARTS; i++)
- deathmatchstarts[i] = NULL;
-
- for (i = 0; i < 2; i++)
- skyboxmo[i] = NULL;
-
- for (i = 0; i < 16; i++)
- skyboxviewpnts[i] = skyboxcenterpnts[i] = NULL;
-
- P_MapStart();
-
- P_PrepareRawThings(wadData + (fileinfo + ML_THINGS)->filepos, (fileinfo + ML_THINGS)->size);
- Z_Free(wadData);
- }
- else
- {
- // Important: take care of the ordering of the next functions.
- loadedbm = P_LoadBlockMap(lastloadedmaplumpnum + ML_BLOCKMAP);
- P_LoadVertexes(lastloadedmaplumpnum + ML_VERTEXES);
- P_LoadSectors(lastloadedmaplumpnum + ML_SECTORS);
- P_LoadSideDefs(lastloadedmaplumpnum + ML_SIDEDEFS);
- P_LoadLineDefs(lastloadedmaplumpnum + ML_LINEDEFS);
- P_LoadSideDefs2(lastloadedmaplumpnum + ML_SIDEDEFS);
- P_LoadSubsectors(lastloadedmaplumpnum + ML_SSECTORS);
- P_LoadNodes(lastloadedmaplumpnum + ML_NODES);
- P_LoadSegs(lastloadedmaplumpnum + ML_SEGS);
- P_LoadReject(lastloadedmaplumpnum + ML_REJECT);
-
- // Important: take care of the ordering of the next functions.
- if (!loadedbm)
- P_CreateBlockMap(); // Graue 02-29-2004
- P_LoadLineDefs2();
- P_GroupLines();
- numdmstarts = numredctfstarts = numbluectfstarts = 0;
-
- // reset the player starts
- for (i = 0; i < MAXPLAYERS; i++)
- playerstarts[i] = bluectfstarts[i] = redctfstarts[i] = NULL;
-
- for (i = 0; i < MAX_DM_STARTS; i++)
- deathmatchstarts[i] = NULL;
-
- for (i = 0; i < 2; i++)
- skyboxmo[i] = NULL;
-
- for (i = 0; i < 16; i++)
- skyboxviewpnts[i] = skyboxcenterpnts[i] = NULL;
+ P_ResetSpawnpoints();
- P_MapStart();
+ P_MapStart();
- P_PrepareThings(lastloadedmaplumpnum + ML_THINGS);
- }
+ if (lastloadedmaplumpnum)
+ P_LoadMapFromFile();
// init gravity, tag lists,
// anything that P_ResetDynamicSlopes/P_LoadThings needs to know
@@ -3007,7 +3213,7 @@ boolean P_SetupLevel(boolean skipprecip)
P_ResetDynamicSlopes(fromnetsave);
#endif
- P_LoadThings(loademblems);
+ P_SpawnMapThings(!fromnetsave);
skyboxmo[0] = skyboxviewpnts[0];
skyboxmo[1] = skyboxcenterpnts[0];
@@ -3018,27 +3224,18 @@ boolean P_SetupLevel(boolean skipprecip)
// set up world state
P_SpawnSpecials(fromnetsave);
- if (loadprecip) // ugly hack for P_NetUnArchiveMisc (and P_LoadNetGame)
+ if (!fromnetsave) // ugly hack for P_NetUnArchiveMisc (and P_LoadNetGame)
P_SpawnPrecipitation();
#ifdef HWRENDER // not win32 only 19990829 by Kin
+ // Lactozilla: Free extrasubsectors regardless of renderer.
+ // Maybe we're not in OpenGL anymore.
+ if (extrasubsectors)
+ free(extrasubsectors);
+ extrasubsectors = NULL;
+ // stuff like HWR_CreatePlanePolygons is called there
if (rendermode == render_opengl)
- {
- // Lactozilla (December 8, 2019)
- // Level setup used to free EVERY mipmap from memory.
- // Even mipmaps that aren't related to level textures.
- // Presumably, the hardware render code used to store textures as level data.
- // Meaning, they had memory allocated and marked with the PU_LEVEL tag.
- // Level textures are only reloaded after R_LoadTextures, which is
- // when the texture list is loaded.
-#ifdef ALAM_LIGHTING
- // BP: reset light between levels (we draw preview frame lights on current frame)
- HWR_ResetLights();
-#endif
- // Correct missing sidedefs & deep water trick
- HWR_CorrectSWTricks();
- HWR_CreatePlanePolygons((INT32)numnodes - 1);
- }
+ HWR_SetupLevel();
#endif
// oh god I hope this helps
@@ -3046,161 +3243,10 @@ boolean P_SetupLevel(boolean skipprecip)
// none of this needs to be done because it's not the beginning of the map when
// a netgame save is being loaded, and could actively be harmful by messing with
// the client's view of the data.)
- if (fromnetsave)
- goto netgameskip;
- // ==========
-
- for (i = 0; i < MAXPLAYERS; i++)
- if (playeringame[i])
- {
- // Start players with pity shields if possible
- players[i].pity = -1;
-
- if (!G_PlatformGametype())
- {
- players[i].mo = NULL;
- G_DoReborn(i);
- }
- else // gametype is GT_COOP or GT_RACE
- {
- players[i].mo = NULL;
-
- if (players[i].starposttime)
- {
- G_SpawnPlayer(i, true);
- P_ClearStarPost(players[i].starpostnum);
- }
- else
- G_SpawnPlayer(i, false);
- }
- }
-
- // restore time in netgame (see also g_game.c)
- if ((netgame || multiplayer) && gametype == GT_COOP && cv_coopstarposts.value == 2)
- {
- // is this a hack? maybe
- tic_t maxstarposttime = 0;
- for (i = 0; i < MAXPLAYERS; i++)
- {
- if (playeringame[i] && players[i].starposttime > maxstarposttime)
- maxstarposttime = players[i].starposttime;
- }
- leveltime = maxstarposttime;
- }
-
- if (unlockables[27].unlocked && !modeattacking // pandora's box
-#ifndef DEVELOP
- && !modifiedgame
-#endif
- && !(netgame || multiplayer) && gamemap == 0x1d35-016464)
- {
- P_SpawnMobj(0640370000, 0x11000000, 0x3180000, MT_LETTER)->angle = ANGLE_90;
- if (textprompts[199]->page[1].backcolor != 259)
- {
- char *buf = W_CacheLumpName("WATERMAP", PU_STATIC), *b = buf;
- while ((*b != 65) && (b-buf < 256)) { *b = (*b - 65)&255; b++; } *b = '\0';
- Z_Free(textprompts[199]->page[1].text);
- textprompts[199]->page[1].text = Z_StrDup(buf);
- textprompts[199]->page[1].lines = 4;
- textprompts[199]->page[1].backcolor = 259;
- Z_Free(buf);
- }
- }
-
- if (modeattacking == ATTACKING_RECORD && !demoplayback)
- P_LoadRecordGhosts();
- else if (modeattacking == ATTACKING_NIGHTS && !demoplayback)
- P_LoadNightsGhosts();
-
- if (G_TagGametype())
- {
- INT32 realnumplayers = 0;
- INT32 playersactive[MAXPLAYERS];
-
- //I just realized how problematic this code can be.
- //D_NumPlayers() will not always cover the scope of the netgame.
- //What if one player is node 0 and the other node 31?
- //The solution? Make a temp array of all players that are currently playing and pick from them.
- //Future todo? When a player leaves, shift all nodes down so D_NumPlayers() can be used as intended?
- //Also, you'd never have to loop through all 32 players slots to find anything ever again.
- for (i = 0; i < MAXPLAYERS; i++)
- {
- if (playeringame[i] && !players[i].spectator)
- {
- playersactive[realnumplayers] = i; //stores the player's node in the array.
- realnumplayers++;
- }
- }
-
- if (realnumplayers) //this should also fix the dedicated crash bug. You only pick a player if one exists to be picked.
- {
- i = P_RandomKey(realnumplayers);
- players[playersactive[i]].pflags |= PF_TAGIT; //choose our initial tagger before map starts.
-
- // Taken and modified from G_DoReborn()
- // Remove the player so he can respawn elsewhere.
- // first dissasociate the corpse
- if (players[playersactive[i]].mo)
- P_RemoveMobj(players[playersactive[i]].mo);
-
- G_SpawnPlayer(playersactive[i], false); //respawn the lucky player in his dedicated spawn location.
- }
- else
- CONS_Printf(M_GetText("No player currently available to become IT. Awaiting available players.\n"));
-
- }
- else if (gametype == GT_RACE && server)
- CV_StealthSetValue(&cv_numlaps,
- (cv_basenumlaps.value)
- ? cv_basenumlaps.value
- : mapheaderinfo[gamemap - 1]->numlaps);
-
- // ===========
- // landing point for netgames.
- netgameskip:
-
- if (!dedicated)
- {
- P_SetupCamera();
-
- // Salt: CV_ClearChangedFlags() messes with your settings :(
- /*if (!cv_cam_height.changed)
- CV_Set(&cv_cam_height, cv_cam_height.defaultvalue);
- if (!cv_cam2_height.changed)
- CV_Set(&cv_cam2_height, cv_cam2_height.defaultvalue);
-
- if (!cv_cam_dist.changed)
- CV_Set(&cv_cam_dist, cv_cam_dist.defaultvalue);
- if (!cv_cam2_dist.changed)
- CV_Set(&cv_cam2_dist, cv_cam2_dist.defaultvalue);*/
-
- // Though, I don't think anyone would care about cam_rotate being reset back to the only value that makes sense :P
- if (!cv_cam_rotate.changed)
- CV_Set(&cv_cam_rotate, cv_cam_rotate.defaultvalue);
- if (!cv_cam2_rotate.changed)
- CV_Set(&cv_cam2_rotate, cv_cam2_rotate.defaultvalue);
-
- if (!cv_analog[0].changed)
- CV_SetValue(&cv_analog[0], 0);
- if (!cv_analog[1].changed)
- CV_SetValue(&cv_analog[1], 0);
-
- displayplayer = consoleplayer; // Start with your OWN view, please!
- }
-
- if (cv_useranalog[0].value)
- CV_SetValue(&cv_analog[0], true);
-
- if (splitscreen && cv_useranalog[1].value)
- CV_SetValue(&cv_analog[1], true);
- else if (botingame)
- CV_SetValue(&cv_analog[1], true);
+ if (!fromnetsave)
+ P_InitGametype();
- if (twodlevel)
- {
- CV_SetValue(&cv_analog[1], false);
- CV_SetValue(&cv_analog[0], false);
- }
+ P_InitCamera();
// clear special respawning que
iquehead = iquetail = 0;
@@ -3235,7 +3281,7 @@ boolean P_SetupLevel(boolean skipprecip)
lastmaploaded = gamemap; // HAS to be set after saving!!
- if (loadprecip) // uglier hack
+ if (!fromnetsave) // uglier hack
{ // to make a newly loaded level start on the second frame.
INT32 buf = gametic % BACKUPTICS;
for (i = 0; i < MAXPLAYERS; i++)
@@ -3269,6 +3315,26 @@ boolean P_SetupLevel(boolean skipprecip)
return true;
}
+#ifdef HWRENDER
+void HWR_SetupLevel(void)
+{
+ // Lactozilla (December 8, 2019)
+ // Level setup used to free EVERY mipmap from memory.
+ // Even mipmaps that aren't related to level textures.
+ // Presumably, the hardware render code used to store textures as level data.
+ // Meaning, they had memory allocated and marked with the PU_LEVEL tag.
+ // Level textures are only reloaded after R_LoadTextures, which is
+ // when the texture list is loaded.
+#ifdef ALAM_LIGHTING
+ // BP: reset light between levels (we draw preview frame lights on current frame)
+ HWR_ResetLights();
+#endif
+ // Correct missing sidedefs & deep water trick
+ HWR_CorrectSWTricks();
+ HWR_CreatePlanePolygons((INT32)numnodes - 1);
+}
+#endif
+
//
// P_RunSOC
//
diff --git a/src/p_setup.h b/src/p_setup.h
index c95dd0f630cc516aec9509e73a921609a025a05f..d7e2d886159b6b71cfe240c13902cb780328b6c4 100644
--- a/src/p_setup.h
+++ b/src/p_setup.h
@@ -96,8 +96,11 @@ void P_SetupLevelSky(INT32 skynum, boolean global);
#ifdef SCANTHINGS
void P_ScanThings(INT16 mapnum, INT16 wadnum, INT16 lumpnum);
#endif
-void P_LoadThingsOnly(void);
-boolean P_SetupLevel(boolean skipprecip);
+void P_RespawnThings(void);
+boolean P_LoadLevel(boolean fromnetsave);
+#ifdef HWRENDER
+void HWR_SetupLevel(void);
+#endif
boolean P_AddWadFile(const char *wadfilename);
boolean P_RunSOC(const char *socfilename);
void P_LoadSoundsRange(UINT16 wadnum, UINT16 first, UINT16 num);
diff --git a/src/p_slopes.c b/src/p_slopes.c
index 89d265fa4d352009f66482afd475377dac5bebc8..e66d7ed2189135bf4c2166e7b1d17e16f037cf7e 100644
--- a/src/p_slopes.c
+++ b/src/p_slopes.c
@@ -445,10 +445,9 @@ static pslope_t *MakeViaMapthings(INT16 tag1, INT16 tag2, INT16 tag3, UINT8 flag
I_Error("MakeViaMapthings: Slope vertex %s (for linedef tag %d) not found!", sizeu1(i), tag1);
vx[i].x = mt->x << FRACBITS;
vx[i].y = mt->y << FRACBITS;
- if (mt->extrainfo)
- vx[i].z = mt->options << FRACBITS;
- else
- vx[i].z = (R_PointInSubsector(mt->x << FRACBITS, mt->y << FRACBITS)->sector->floorheight) + ((mt->options >> ZSHIFT) << FRACBITS);
+ vx[i].z = mt->z << FRACBITS;
+ if (!mt->extrainfo)
+ vx[i].z += R_PointInSubsector(vx[i].x, vx[i].y)->sector->floorheight;
}
ReconfigureViaVertexes(ret, vx[0], vx[1], vx[2]);
@@ -553,11 +552,8 @@ pslope_t *P_SlopeById(UINT16 id)
}
/// Reset slopes and read them from special lines.
-void P_ResetDynamicSlopes(const UINT32 fromsave) {
+void P_ResetDynamicSlopes(const boolean fromsave) {
size_t i;
-
- boolean spawnthinkers = !(boolean)fromsave;
-
slopelist = NULL;
slopecount = 0;
@@ -574,14 +570,14 @@ void P_ResetDynamicSlopes(const UINT32 fromsave) {
case 711:
case 712:
case 713:
- line_SpawnViaLine(i, spawnthinkers);
+ line_SpawnViaLine(i, !fromsave);
break;
case 704:
case 705:
case 714:
case 715:
- line_SpawnViaVertexes(i, spawnthinkers);
+ line_SpawnViaVertexes(i, !fromsave);
break;
default:
diff --git a/src/p_slopes.h b/src/p_slopes.h
index 076fd87969454ca0746f7bed2758ea13ca2c1879..96764051b428cf013fb503db03fff1b6de5ff23c 100644
--- a/src/p_slopes.h
+++ b/src/p_slopes.h
@@ -23,7 +23,7 @@ extern UINT16 slopecount;
void P_LinkSlopeThinkers (void);
void P_CalculateSlopeNormal(pslope_t *slope);
-void P_ResetDynamicSlopes(const UINT32 fromsave);
+void P_ResetDynamicSlopes(const boolean fromsave);
//
// P_CopySectorSlope
diff --git a/src/p_spec.c b/src/p_spec.c
index d0890f3c9f1325c4f4e5452a6e5278eaf015cc65..0851e3199cac0e8d4133f6e79066dd430a43139d 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -1603,8 +1603,6 @@ static inline void P_InitTagLists(void)
size_t j = (unsigned)sectors[i].tag % numsectors;
sectors[i].nexttag = sectors[j].firsttag;
sectors[j].firsttag = (INT32)i;
- sectors[i].spawn_nexttag = sectors[i].nexttag;
- sectors[j].spawn_firsttag = sectors[j].firsttag;
}
for (i = numlines - 1; i != (size_t)-1; i--)
@@ -4694,7 +4692,7 @@ DoneSection2:
}
case 2: // Special stage GOAL sector / Exit Sector / CTF Flag Return
- if (player->bot || !G_PlatformGametype())
+ if (player->bot || !(gametyperules & GTR_ALLOWEXIT))
break;
if (!(maptol & TOL_NIGHTS) && G_IsSpecialStage(gamemap) && player->nightstime > 6)
{
@@ -4729,7 +4727,7 @@ DoneSection2:
break;
case 3: // Red Team's Base
- if (gametype == GT_CTF && P_IsObjectOnGround(player->mo))
+ if ((gametyperules & GTR_TEAMFLAGS) && P_IsObjectOnGround(player->mo))
{
if (player->ctfteam == 1 && (player->gotflag & GF_BLUEFLAG))
{
@@ -4762,7 +4760,7 @@ DoneSection2:
break;
case 4: // Blue Team's Base
- if (gametype == GT_CTF && P_IsObjectOnGround(player->mo))
+ if ((gametyperules & GTR_TEAMFLAGS) && P_IsObjectOnGround(player->mo))
{
if (player->ctfteam == 2 && (player->gotflag & GF_REDFLAG))
{
@@ -6405,22 +6403,16 @@ static void P_ApplyFlatAlignment(line_t *master, sector_t *sector, angle_t flata
{
if (!(master->flags & ML_NETONLY)) // Modify floor flat alignment unless ML_NETONLY flag is set
{
- sector->spawn_flrpic_angle = sector->floorpic_angle = flatangle;
+ sector->floorpic_angle = flatangle;
sector->floor_xoffs += xoffs;
sector->floor_yoffs += yoffs;
- // saved for netgames
- sector->spawn_flr_xoffs = sector->floor_xoffs;
- sector->spawn_flr_yoffs = sector->floor_yoffs;
}
if (!(master->flags & ML_NONET)) // Modify ceiling flat alignment unless ML_NONET flag is set
{
- sector->spawn_ceilpic_angle = sector->ceilingpic_angle = flatangle;
+ sector->ceilingpic_angle = flatangle;
sector->ceiling_xoffs += xoffs;
sector->ceiling_yoffs += yoffs;
- // saved for netgames
- sector->spawn_ceil_xoffs = sector->ceiling_xoffs;
- sector->spawn_ceil_yoffs = sector->ceiling_yoffs;
}
}
@@ -6434,14 +6426,13 @@ static void P_ApplyFlatAlignment(line_t *master, sector_t *sector, angle_t flata
* as they'll just be erased by UnArchiveThinkers.
* \sa P_SpawnPrecipitation, P_SpawnFriction, P_SpawnPushers, P_SpawnScrollers
*/
-void P_SpawnSpecials(INT32 fromnetsave)
+void P_SpawnSpecials(boolean fromnetsave)
{
sector_t *sector;
size_t i;
INT32 j;
thinkerlist_t *secthinkers;
thinker_t *th;
-
// This used to be used, and *should* be used in the future,
// but currently isn't.
(void)fromnetsave;
@@ -7187,46 +7178,14 @@ void P_SpawnSpecials(INT32 fromnetsave)
EV_AddLaserThinker(§ors[s], §ors[sec], lines + i, secthinkers);
break;
- case 259: // Make-Your-Own FOF!
+ case 259: // Custom FOF
if (lines[i].sidenum[1] != 0xffff)
{
- UINT8 *data;
- UINT16 b;
-
- if (W_IsLumpWad(lastloadedmaplumpnum)) // welp it's a map wad in a pk3
- { // HACK: Open wad file rather quickly so we can get the data from the sidedefs lump
- UINT8 *wadData = W_CacheLumpNum(lastloadedmaplumpnum, PU_STATIC);
- filelump_t *fileinfo = (filelump_t *)(wadData + ((wadinfo_t *)wadData)->infotableofs);
- fileinfo += ML_SIDEDEFS; // we only need the SIDEDEFS lump
- data = Z_Malloc(fileinfo->size, PU_STATIC, NULL);
- M_Memcpy(data, wadData + fileinfo->filepos, fileinfo->size); // copy data
- Z_Free(wadData); // we're done with this now
- }
- else // phew it's just a WAD
- data = W_CacheLumpNum(lastloadedmaplumpnum + ML_SIDEDEFS,PU_STATIC);
-
- for (b = 0; b < (INT16)numsides; b++)
- {
- register mapsidedef_t *msd = (mapsidedef_t *)data + b;
-
- if (b == lines[i].sidenum[1])
- {
- if ((msd->toptexture[0] >= '0' && msd->toptexture[0] <= '9')
- || (msd->toptexture[0] >= 'A' && msd->toptexture[0] <= 'F'))
- {
- ffloortype_e FOF_Flags = axtoi(msd->toptexture);
-
- P_AddFakeFloorsByLine(i, FOF_Flags, secthinkers);
- break;
- }
- else
- I_Error("Make-Your-Own-FOF (tag %d) needs a value in the linedef's second side upper texture field.", lines[i].tag);
- }
- }
- Z_Free(data);
+ ffloortype_e fofflags = sides[lines[i].sidenum[1]].toptexture;
+ P_AddFakeFloorsByLine(i, fofflags, secthinkers);
}
else
- I_Error("Make-Your-Own FOF (tag %d) found without a 2nd linedef side!", lines[i].tag);
+ I_Error("Custom FOF (tag %d) found without a linedef back side!", lines[i].tag);
break;
case 300: // Linedef executor (combines with sector special 974/975) and commands
@@ -7240,14 +7199,14 @@ void P_SpawnSpecials(INT32 fromnetsave)
break;
case 308: // Race-only linedef executor. Triggers once.
- if (gametype != GT_RACE && gametype != GT_COMPETITION)
+ if (!(gametyperules & GTR_RACE))
lines[i].special = 0;
break;
// Linedef executor triggers for CTF teams.
case 309:
case 311:
- if (gametype != GT_CTF)
+ if (!(gametyperules & GTR_TEAMFLAGS))
lines[i].special = 0;
break;
diff --git a/src/p_spec.h b/src/p_spec.h
index 14d3ebb59a5ed5ca6ad5894d039c5c1f64e15e4c..630bcb3de1045cdc9eec2077a6972c0662167bea 100644
--- a/src/p_spec.h
+++ b/src/p_spec.h
@@ -35,7 +35,7 @@ void P_SetupLevelFlatAnims(void);
// at map load
void P_InitSpecials(void);
-void P_SpawnSpecials(INT32 fromnetsave);
+void P_SpawnSpecials(boolean fromnetsave);
// every tic
void P_UpdateSpecials(void);
diff --git a/src/p_user.c b/src/p_user.c
index c88566f4d1784ee68cce55e3985891f204d58393..cd338c989693cb48819a408f428ce123e0aab194 100644
--- a/src/p_user.c
+++ b/src/p_user.c
@@ -389,7 +389,7 @@ UINT8 P_FindLowestMare(void)
mobj_t *mo2;
UINT8 mare = UINT8_MAX;
- if (gametype == GT_RACE || gametype == GT_COMPETITION)
+ if (gametyperules & GTR_RACE)
return 0;
// scan the thinkers
@@ -640,9 +640,7 @@ static void P_DeNightserizePlayer(player_t *player)
player->marebonuslap = 0;
player->flyangle = 0;
player->anotherflyangle = 0;
-#ifdef ROTSPRITE
player->mo->rollangle = 0;
-#endif
P_SetTarget(&player->mo->target, NULL);
P_SetTarget(&player->axis1, P_SetTarget(&player->axis2, NULL));
@@ -770,9 +768,7 @@ void P_NightserizePlayer(player_t *player, INT32 nighttime)
player->secondjump = 0;
player->flyangle = 0;
player->anotherflyangle = 0;
-#ifdef ROTSPRITE
player->mo->rollangle = 0;
-#endif
player->powers[pw_shield] = SH_NONE;
player->powers[pw_super] = 0;
@@ -795,7 +791,7 @@ void P_NightserizePlayer(player_t *player, INT32 nighttime)
P_RestoreMusic(player);
}
- if (gametype == GT_RACE || gametype == GT_COMPETITION)
+ if (gametyperules & GTR_RACE)
{
if (player->drillmeter < 48*20)
player->drillmeter = 48*20;
@@ -1602,7 +1598,7 @@ void P_RestoreMusic(player_t *player)
P_PlayJingle(player, JT_SUPER);
// Invulnerability
- else if (player->powers[pw_invulnerability] > 1)
+ else if (player->powers[pw_invulnerability] > 1 && !player->powers[pw_super])
{
strlcpy(S_sfx[sfx_None].caption, "Invincibility", 14);
S_StartCaption(sfx_None, -1, player->powers[pw_invulnerability]);
@@ -2183,7 +2179,7 @@ void P_DoPlayerExit(player_t *player)
if (cv_allowexitlevel.value == 0 && !G_PlatformGametype())
return;
- else if (gametype == GT_RACE || gametype == GT_COMPETITION) // If in Race Mode, allow
+ else if (gametyperules & GTR_RACE) // If in Race Mode, allow
{
if (!countdown) // a 60-second wait ala Sonic 2.
countdown = (cv_countdowntime.value - 1)*TICRATE + 1; // Use cv_countdowntime
@@ -3112,7 +3108,7 @@ static void P_DoPlayerHeadSigns(player_t *player)
}
}
}
- else if (gametype == GT_CTF && (player->gotflag & (GF_REDFLAG|GF_BLUEFLAG))) // If you have the flag (duh).
+ else if ((gametyperules & GTR_TEAMFLAGS) && (player->gotflag & (GF_REDFLAG|GF_BLUEFLAG))) // If you have the flag (duh).
{
// Spawn a got-flag message over the head of the player that
// has it (but not on your own screen if you have the flag).
@@ -4637,7 +4633,13 @@ static void P_DoSpinAbility(player_t *player, ticcmd_t *cmd)
S_StartSound(player->mo, sfx_spin);
break;
}
- if (player->dashspeed < player->maxdash)
+ if (player->dashspeed < player->mindash)
+ player->dashspeed = player->mindash;
+
+ if (player->dashspeed > player->maxdash)
+ player->dashspeed = player->maxdash;
+
+ if (player->dashspeed < player->maxdash && player->mindash != player->maxdash)
{
#define chargecalculation (6*(player->dashspeed - player->mindash))/(player->maxdash - player->mindash)
fixed_t soundcalculation = chargecalculation;
@@ -4672,7 +4674,7 @@ static void P_DoSpinAbility(player_t *player, ticcmd_t *cmd)
if (player->powers[pw_carry] == CR_BRAKGOOP)
player->dashspeed = 0;
- if (!((gametype == GT_RACE || gametype == GT_COMPETITION) && leveltime < 4*TICRATE))
+ if (!((gametyperules & GTR_RACE) && leveltime < 4*TICRATE))
{
if (player->dashspeed)
{
@@ -5050,7 +5052,7 @@ static void P_DoJumpStuff(player_t *player, ticcmd_t *cmd)
{
if (onground || player->climbing || player->powers[pw_carry])
;
- else if (gametype == GT_CTF && player->gotflag)
+ else if ((gametyperules & GTR_TEAMFLAGS) && player->gotflag)
;
else if (player->pflags & (PF_GLIDING|PF_SLIDING|PF_SHIELDABILITY)) // If the player has used an ability previously
;
@@ -5130,11 +5132,7 @@ static void P_DoJumpStuff(player_t *player, ticcmd_t *cmd)
boolean elem = ((player->powers[pw_shield] & SH_NOSTACK) == SH_ELEMENTAL);
player->pflags |= PF_THOKKED|PF_SHIELDABILITY;
if (elem)
- {
- player->pflags |= PF_NOJUMPDAMAGE;
- P_SetPlayerMobjState(player->mo, S_PLAY_FALL);
S_StartSound(player->mo, sfx_s3k43);
- }
else
{
player->pflags &= ~PF_NOJUMPDAMAGE;
@@ -5275,7 +5273,7 @@ static void P_DoJumpStuff(player_t *player, ticcmd_t *cmd)
player->secondjump = 0;
player->pflags &= ~PF_THOKKED;
}
- else if (player->pflags & PF_SLIDING || (gametype == GT_CTF && player->gotflag))
+ else if (player->pflags & PF_SLIDING || ((gametyperules & GTR_TEAMFLAGS) && player->gotflag) || player->pflags & PF_SHIELDABILITY)
;
/*else if (P_SuperReady(player))
{
@@ -5572,7 +5570,7 @@ static void P_DoJumpStuff(player_t *player, ticcmd_t *cmd)
{
player->pflags |= PF_JUMPDOWN;
- if ((gametype != GT_CTF || !player->gotflag) && !player->exiting)
+ if ((!(gametyperules & GTR_TEAMFLAGS) || !player->gotflag) && !player->exiting)
{
if (player->secondjump == 1 && player->charability != CA_DOUBLEJUMP)
{
@@ -6829,7 +6827,6 @@ static void P_DoNiGHTSCapsule(player_t *player)
P_SetPlayerMobjState(player->mo, S_PLAY_ROLL);
}
-#ifdef ROTSPRITE
if (!(player->charflags & SF_NONIGHTSROTATION))
{
if ((player->mo->state == &states[S_PLAY_NIGHTS_PULL])
@@ -6838,7 +6835,6 @@ static void P_DoNiGHTSCapsule(player_t *player)
else
player->mo->rollangle = 0;
}
-#endif
if (G_IsSpecialStage(gamemap))
{ // In special stages, share rings. Everyone gives up theirs to the capsule player always, because we can't have any individualism here!
@@ -7101,9 +7097,7 @@ static void P_NiGHTSMovement(player_t *player)
INT32 i;
statenum_t flystate;
UINT16 visangle;
-#ifdef ROTSPRITE
angle_t rollangle = 0;
-#endif
player->pflags &= ~PF_DRILLING;
@@ -7142,7 +7136,7 @@ static void P_NiGHTSMovement(player_t *player)
&& !player->exiting)
player->nightstime--;
}
- else if (gametype != GT_RACE && gametype != GT_COMPETITION
+ else if (!(gametyperules & GTR_RACE)
&& !(player->mo->state >= &states[S_PLAY_NIGHTS_TRANS1]
&& player->mo->state <= &states[S_PLAY_NIGHTS_TRANS6])
&& !(player->capsule && player->capsule->reactiontime)
@@ -7288,9 +7282,7 @@ static void P_NiGHTSMovement(player_t *player)
&& player->mo->state <= &states[S_PLAY_NIGHTS_TRANS6])
{
player->mo->momx = player->mo->momy = player->mo->momz = 0;
-#ifdef ROTSPRITE
player->mo->rollangle = 0;
-#endif
return;
}
@@ -7298,7 +7290,7 @@ static void P_NiGHTSMovement(player_t *player)
{
player->mo->momx = player->mo->momy = 0;
- if (gametype != GT_RACE && gametype != GT_COMPETITION)
+ if (!(gametyperules & GTR_RACE))
P_SetObjectMomZ(player->mo, FRACUNIT/2, (P_MobjFlip(player->mo)*player->mo->momz >= 0));
else
player->mo->momz = 0;
@@ -7616,7 +7608,6 @@ static void P_NiGHTSMovement(player_t *player)
flystate += (visangle*2); // S_PLAY_NIGHTS_FLY0-C - the *2 is to skip over drill states
#endif
}
-#ifdef ROTSPRITE
else
{
angle_t a = R_PointToAngle(player->mo->x, player->mo->y) - player->mo->angle;
@@ -7634,18 +7625,15 @@ static void P_NiGHTSMovement(player_t *player)
rollangle = FixedAngle(visangle<<FRACBITS);
}
-#endif
}
if (player->mo->state != &states[flystate])
P_SetPlayerMobjState(player->mo, flystate);
-#ifdef ROTSPRITE
if (player->charflags & SF_NONIGHTSROTATION)
player->mo->rollangle = 0;
else
player->mo->rollangle = rollangle;
-#endif
if (player == &players[consoleplayer])
localangle = player->mo->angle;
@@ -9691,12 +9679,12 @@ static void P_DeathThink(player_t *player)
player->playerstate = PST_REBORN;
}
- if (gametype == GT_RACE || gametype == GT_COMPETITION || (gametype == GT_COOP && (multiplayer || netgame)))
+ if ((gametyperules & GTR_RACE) || (gametype == GT_COOP && (multiplayer || netgame)))
{
// Keep time rolling in race mode
if (!(countdown2 && !countdown) && !player->exiting && !(player->pflags & PF_GAMETYPEOVER) && !stoppedclock)
{
- if (gametype == GT_RACE || gametype == GT_COMPETITION)
+ if (gametyperules & GTR_RACE)
{
if (leveltime >= 4*TICRATE)
player->realtime = leveltime - 4*TICRATE;
@@ -10594,6 +10582,11 @@ boolean P_SpectatorJoinGame(player_t *player)
else
changeto = (P_RandomFixed() & 1) + 1;
+#ifdef HAVE_BLUA
+ if (!LUAh_TeamSwitch(player, changeto, true, false, false))
+ return false;
+#endif
+
if (player->mo)
{
P_RemoveMobj(player->mo);
@@ -10605,7 +10598,14 @@ boolean P_SpectatorJoinGame(player_t *player)
//Reset away view
if (P_IsLocalPlayer(player) && displayplayer != consoleplayer)
+ {
+#ifdef HAVE_BLUA
+ // Call ViewpointSwitch hooks here.
+ // The viewpoint was forcibly changed.
+ LUAh_ViewpointSwitch(player, &players[displayplayer], true);
+#endif
displayplayer = consoleplayer;
+ }
if (changeto == 1)
CONS_Printf(M_GetText("%s switched to the %c%s%c.\n"), player_names[player-players], '\x85', M_GetText("Red team"), '\x80');
@@ -10619,8 +10619,12 @@ boolean P_SpectatorJoinGame(player_t *player)
{
// Exception for hide and seek. Don't join a game when you simply
// respawn in place and sit there for the rest of the round.
- if (!(gametype == GT_HIDEANDSEEK && leveltime > (hidetime * TICRATE)))
+ if (!((gametyperules & GTR_HIDEFROZEN) && leveltime > (hidetime * TICRATE)))
{
+#ifdef HAVE_BLUA
+ if (!LUAh_TeamSwitch(player, 3, true, false, false))
+ return false;
+#endif
if (player->mo)
{
P_RemoveMobj(player->mo);
@@ -10643,7 +10647,14 @@ boolean P_SpectatorJoinGame(player_t *player)
//Reset away view
if (P_IsLocalPlayer(player) && displayplayer != consoleplayer)
+ {
+#ifdef HAVE_BLUA
+ // Call ViewpointSwitch hooks here.
+ // The viewpoint was forcibly changed.
+ LUAh_ViewpointSwitch(player, &players[displayplayer], true);
+#endif
displayplayer = consoleplayer;
+ }
if (gametype != GT_COOP)
CONS_Printf(M_GetText("%s entered the game.\n"), player_names[player-players]);
@@ -10769,7 +10780,7 @@ void P_DoPityCheck(player_t *player)
{
// No pity outside of match or CTF.
if (player->spectator
- || !(gametype == GT_MATCH || gametype == GT_TEAMMATCH || gametype == GT_CTF))
+ || !(gametyperules & GTR_PITYSHIELD))
return;
// Apply pity shield if available.
@@ -11602,7 +11613,7 @@ void P_PlayerThink(player_t *player)
I_Error("player %s is in PST_REBORN\n", sizeu1(playeri));
#endif
- if (gametype == GT_RACE || gametype == GT_COMPETITION)
+ if (gametyperules & GTR_RACE)
{
INT32 i;
@@ -11665,7 +11676,7 @@ void P_PlayerThink(player_t *player)
player->exiting > 0 && player->exiting <= 1*TICRATE &&
(!multiplayer || gametype == GT_COOP ? !mapheaderinfo[gamemap-1]->musinterfadeout : true) &&
// don't fade if we're fading during intermission. follows Y_StartIntermission intertype = int_coop
- (gametype == GT_RACE || gametype == GT_COMPETITION ? countdown2 == 0 : true) && // don't fade on timeout
+ ((gametyperules & GTR_RACE) ? countdown2 == 0 : true) && // don't fade on timeout
player->lives > 0 && // don't fade on game over (competition)
P_IsLocalPlayer(player))
{
@@ -11780,7 +11791,7 @@ void P_PlayerThink(player_t *player)
player->lives = cv_startinglives.value;
}
- if ((gametype == GT_RACE || gametype == GT_COMPETITION) && leveltime < 4*TICRATE)
+ if ((gametyperules & GTR_RACE) && leveltime < 4*TICRATE)
{
cmd->buttons &= BT_USE; // Remove all buttons except BT_USE
cmd->forwardmove = 0;
@@ -11790,7 +11801,7 @@ void P_PlayerThink(player_t *player)
// Synchronizes the "real" amount of time spent in the level.
if (!player->exiting && !stoppedclock)
{
- if (gametype == GT_RACE || gametype == GT_COMPETITION)
+ if (gametyperules & GTR_RACE)
{
if (leveltime >= 4*TICRATE)
player->realtime = leveltime - 4*TICRATE;
diff --git a/src/r_bsp.c b/src/r_bsp.c
index 51d9bd3fddad73389f6756305a9fe469c76beb69..6b4667aeef2afab999348a74f7a3ba4c8e505a3a 100644
--- a/src/r_bsp.c
+++ b/src/r_bsp.c
@@ -1169,9 +1169,11 @@ static void R_Subsector(size_t num)
while (count--)
{
// CONS_Debug(DBG_GAMELOGIC, "Adding normal line %d...(%d)\n", line->linedef-lines, leveltime);
+ if (!line->glseg
#ifdef POLYOBJECTS
- if (!line->polyseg) // ignore segs that belong to polyobjects
+ && !line->polyseg // ignore segs that belong to polyobjects
#endif
+ )
R_AddLine(line);
line++;
curline = NULL; /* cph 2001/11/18 - must clear curline now we're done with it, so stuff doesn't try using it for other things */
diff --git a/src/r_data.c b/src/r_data.c
index cecd4840ccb4badf6d42434a6800ec3c7259d2bb..bfd83a62d1169e02d89084b38f60bd86a975585b 100644
--- a/src/r_data.c
+++ b/src/r_data.c
@@ -2095,7 +2095,6 @@ lighttable_t *R_CreateLightTable(extracolormap_t *extra_colormap)
/////////////////////
// This code creates the colormap array used by software renderer
/////////////////////
- if (rendermode == render_soft)
{
double r, g, b, cbrightness;
int p;
@@ -2717,7 +2716,7 @@ void R_PrecacheLevel(void)
lump = sf->lumppat[k];
if (devparm)
spritememory += W_LumpLength(lump);
- W_CachePatchNum(lump, PU_CACHE);
+ W_CachePatchNum(lump, PU_PATCH);
}
}
}
diff --git a/src/r_defs.h b/src/r_defs.h
index 3cc780545446509c55d0eaffcabaf5e77521b7bf..96ef953ceb54bee4f5a548241df0ec1c26c191fd 100644
--- a/src/r_defs.h
+++ b/src/r_defs.h
@@ -384,17 +384,6 @@ typedef struct sector_s
// for fade thinker
INT16 spawn_lightlevel;
- // these are saved for netgames, so do not let Lua touch these!
- INT32 spawn_nexttag, spawn_firsttag; // the actual nexttag/firsttag values may differ if the sector's tag was changed
-
- // offsets sector spawned with (via linedef type 7)
- fixed_t spawn_flr_xoffs, spawn_flr_yoffs;
- fixed_t spawn_ceil_xoffs, spawn_ceil_yoffs;
-
- // flag angles sector spawned with (via linedef type 7)
- angle_t spawn_flrpic_angle;
- angle_t spawn_ceilpic_angle;
-
// colormap structure
extracolormap_t *spawn_extra_colormap;
} sector_t;
@@ -447,14 +436,10 @@ typedef struct line_s
polyobj_t *polyobj; // Belongs to a polyobject?
#endif
- char *text; // a concatination of all front and back texture names, for linedef specials that require a string.
+ char *text; // a concatenation of all front and back texture names, for linedef specials that require a string.
INT16 callcount; // no. of calls left before triggering, for the "X calls" linedef specials, defaults to 0
} line_t;
-//
-// The SideDef.
-//
-
typedef struct
{
// add this to the calculated texture column
@@ -467,13 +452,16 @@ typedef struct
// We do not maintain names here.
INT32 toptexture, bottomtexture, midtexture;
- // Sector the SideDef is facing.
+ // Linedef the sidedef belongs to
+ line_t *line;
+
+ // Sector the sidedef is facing.
sector_t *sector;
INT16 special; // the special of the linedef this side belongs to
INT16 repeatcnt; // # of times to repeat midtexture
- char *text; // a concatination of all top, bottom, and mid texture names, for linedef specials that require a string.
+ char *text; // a concatenation of all top, bottom, and mid texture names, for linedef specials that require a string.
extracolormap_t *colormap_data; // storage for colormaps; not applied to sectors.
} side_t;
@@ -598,6 +586,7 @@ typedef struct seg_s
polyobj_t *polyseg;
boolean dontrenderme;
#endif
+ boolean glseg;
} seg_t;
//
@@ -742,9 +731,9 @@ typedef struct
boolean cached[8];
#ifdef HWRENDER
aatree_t *hardware_patch[8];
-#endif
+#endif/*HWRENDER*/
} rotsprite_t;
-#endif
+#endif/*ROTSPRITE*/
typedef enum
{
@@ -756,6 +745,24 @@ typedef enum
SRF_NONE = 0xff // Initial value
} spriterotateflags_t; // SRF's up!
+// Same as a patch_t, except just the header
+// and the wadnum/lumpnum combination that points
+// to wherever the patch is in memory.
+struct patchinfo_s
+{
+ INT16 width; // bounding box size
+ INT16 height;
+ INT16 leftoffset; // pixels to the left of origin
+ INT16 topoffset; // pixels below the origin
+
+ UINT16 wadnum; // the software patch lump num for when the patch
+ UINT16 lumpnum; // was flushed, and we need to re-create it
+
+ // next patchinfo_t in memory
+ struct patchinfo_s *next;
+};
+typedef struct patchinfo_s patchinfo_t;
+
//
// Sprites are patches with a special naming convention so they can be
// recognized by R_InitSprites.
diff --git a/src/r_main.c b/src/r_main.c
index 9cb0f3edbef0a59e4d6a1856c6ed85df0422664e..b60022d22f20c7608d793984c81f266585890e1a 100644
--- a/src/r_main.c
+++ b/src/r_main.c
@@ -19,6 +19,7 @@
#include "r_local.h"
#include "r_splats.h" // faB(21jan): testing
#include "r_sky.h"
+#include "hu_stuff.h"
#include "st_stuff.h"
#include "p_local.h"
#include "keys.h"
@@ -28,6 +29,7 @@
#include "d_main.h"
#include "v_video.h"
#include "p_spec.h" // skyboxmo
+#include "p_setup.h"
#include "z_zone.h"
#include "m_random.h" // quake camera shake
#include "r_portal.h"
@@ -1154,6 +1156,26 @@ void R_RenderPlayerView(player_t *player)
free(masks);
}
+// Lactozilla: Renderer switching
+#ifdef HWRENDER
+void R_InitHardwareMode(void)
+{
+ HWR_AddSessionCommands();
+ HWR_Switch();
+ HWR_LoadTextures(numtextures);
+ if (gamestate == GS_LEVEL || (gamestate == GS_TITLESCREEN && titlemapinaction))
+ HWR_SetupLevel();
+}
+#endif
+
+void R_ReloadHUDGraphics(void)
+{
+ CONS_Debug(DBG_RENDER, "R_ReloadHUDGraphics()...\n");
+ ST_LoadGraphics();
+ HU_LoadGraphics();
+ ST_ReloadSkinFaceGraphics();
+}
+
// =========================================================================
// ENGINE COMMANDS & VARS
// =========================================================================
diff --git a/src/r_main.h b/src/r_main.h
index 58c23cd8147792e4efdf890da95a27901f7dd759..143cc1de0225e978cc2d549f64878a08603f58b5 100644
--- a/src/r_main.h
+++ b/src/r_main.h
@@ -89,6 +89,10 @@ extern consvar_t cv_tailspickup;
// Called by startup code.
void R_Init(void);
+#ifdef HWRENDER
+void R_InitHardwareMode(void);
+#endif
+void R_ReloadHUDGraphics(void);
// just sets setsizeneeded true
extern boolean setsizeneeded;
diff --git a/src/r_patch.c b/src/r_patch.c
index d4bfa9cbda29f84a07b234d91d13324a14979875..fbb64e3621a266f3febab774f4c66b52a4a60615 100644
--- a/src/r_patch.c
+++ b/src/r_patch.c
@@ -49,8 +49,6 @@
#endif
static unsigned char imgbuf[1<<26];
-fixed_t cosang2rad[ROTANGLES];
-fixed_t sinang2rad[ROTANGLES];
//
// R_CheckIfPatch
@@ -789,11 +787,9 @@ static void R_ParseSpriteInfoFrame(spriteinfo_t *info)
size_t sprinfoTokenLength;
char *frameChar = NULL;
UINT8 frameFrame = 0xFF;
-#ifdef ROTSPRITE
INT16 frameXPivot = 0;
INT16 frameYPivot = 0;
rotaxis_t frameRotAxis = 0;
-#endif
// Sprite identifier
sprinfoToken = M_GetToken(NULL);
@@ -828,7 +824,6 @@ static void R_ParseSpriteInfoFrame(spriteinfo_t *info)
}
while (strcmp(sprinfoToken,"}")!=0)
{
-#ifdef ROTSPRITE
if (stricmp(sprinfoToken, "XPIVOT")==0)
{
Z_Free(sprinfoToken);
@@ -852,7 +847,6 @@ static void R_ParseSpriteInfoFrame(spriteinfo_t *info)
else if ((stricmp(sprinfoToken, "Z")==0) || (stricmp(sprinfoToken, "ZAXIS")==0) || (stricmp(sprinfoToken, "YAW")==0))
frameRotAxis = ROTAXIS_Z;
}
-#endif
Z_Free(sprinfoToken);
sprinfoToken = M_GetToken(NULL);
@@ -866,11 +860,9 @@ static void R_ParseSpriteInfoFrame(spriteinfo_t *info)
}
// set fields
-#ifdef ROTSPRITE
info->pivot[frameFrame].x = frameXPivot;
info->pivot[frameFrame].y = frameYPivot;
info->pivot[frameFrame].rotaxis = frameRotAxis;
-#endif
}
//
@@ -1093,16 +1085,60 @@ void R_LoadSpriteInfoLumps(UINT16 wadnum, UINT16 numlumps)
for (i = 0; i < numlumps; i++, lumpinfo++)
{
name = lumpinfo->name;
- // load SPRTINFO lumps
- if (!stricmp(name, "SPRTINFO"))
+ // Load SPRTINFO and SPR_ lumps as SpriteInfo
+ if (!memcmp(name, "SPRTINFO", 8) || !memcmp(name, "SPR_", 4))
R_ParseSPRTINFOLump(wadnum, i);
- // load SPR_ lumps (as DEHACKED lump)
- else if (!memcmp(name, "SPR_", 4))
- DEH_LoadDehackedLumpPwad(wadnum, i, false);
}
}
+static UINT16 GetPatchPixel(patch_t *patch, INT32 x, INT32 y, boolean flip)
+{
+ fixed_t ofs;
+ column_t *column;
+ UINT8 *source;
+
+ if (x >= 0 && x < SHORT(patch->width))
+ {
+ INT32 topdelta, prevdelta = -1;
+ column = (column_t *)((UINT8 *)patch + LONG(patch->columnofs[flip ? (patch->width-1-x) : x]));
+ while (column->topdelta != 0xff)
+ {
+ topdelta = column->topdelta;
+ if (topdelta <= prevdelta)
+ topdelta += prevdelta;
+ prevdelta = topdelta;
+ source = (UINT8 *)(column) + 3;
+ for (ofs = 0; ofs < column->length; ofs++)
+ {
+ if ((topdelta + ofs) == y)
+ return source[ofs];
+ }
+ column = (column_t *)((UINT8 *)column + column->length + 4);
+ }
+ }
+
+ return 0xFF00;
+}
+
#ifdef ROTSPRITE
+//
+// R_GetRollAngle
+//
+// Angles precalculated in R_InitSprites.
+//
+fixed_t rollcosang[ROTANGLES];
+fixed_t rollsinang[ROTANGLES];
+INT32 R_GetRollAngle(angle_t rollangle)
+{
+ INT32 ra = AngleFixed(rollangle)>>FRACBITS;
+#if (ROTANGDIFF > 1)
+ ra += (ROTANGDIFF/2);
+#endif
+ ra /= ROTANGDIFF;
+ ra %= ROTANGLES;
+ return ra;
+}
+
//
// R_CacheRotSprite
//
@@ -1114,8 +1150,8 @@ void R_CacheRotSprite(spritenum_t sprnum, UINT8 frame, spriteinfo_t *sprinfo, sp
INT32 angle;
patch_t *patch;
patch_t *newpatch;
- UINT16 *rawsrc, *rawdst;
- size_t size, size2;
+ UINT16 *rawdst;
+ size_t size;
INT32 bflip = (flip != 0x00);
#define SPRITE_XCENTER (leftoffset)
@@ -1160,23 +1196,12 @@ void R_CacheRotSprite(spritenum_t sprnum, UINT8 frame, spriteinfo_t *sprinfo, sp
leftoffset = width - leftoffset;
}
- // Draw the sprite to a temporary buffer.
- size = (width*height);
- rawsrc = Z_Malloc(size * sizeof(UINT16), PU_STATIC, NULL);
-
- // can't memset here
- for (i = 0; i < size; i++)
- rawsrc[i] = 0xFF00;
-
- R_PatchToFlat_16bpp(patch, rawsrc, bflip);
-
- // Don't cache angle = 0
for (angle = 1; angle < ROTANGLES; angle++)
{
INT32 newwidth, newheight;
- ca = cosang2rad[angle];
- sa = sinang2rad[angle];
+ ca = rollcosang[angle];
+ sa = rollsinang[angle];
// Find the dimensions of the rotated patch.
{
@@ -1237,17 +1262,15 @@ void R_CacheRotSprite(spritenum_t sprnum, UINT8 frame, spriteinfo_t *sprinfo, sp
#undef BOUNDARYADJUST
}
- size2 = (newwidth * newheight);
- if (!size2)
- size2 = size;
-
- rawdst = Z_Malloc(size2 * sizeof(UINT16), PU_STATIC, NULL);
+ // Draw the rotated sprite to a temporary buffer.
+ size = (newwidth * newheight);
+ if (!size)
+ size = (width * height);
- // can't memset here
- for (i = 0; i < size2; i++)
+ rawdst = Z_Malloc(size * sizeof(UINT16), PU_STATIC, NULL);
+ for (i = 0; i < size; i++)
rawdst[i] = 0xFF00;
- // Draw the rotated sprite to a temporary buffer.
for (dy = 0; dy < newheight; dy++)
{
for (dx = 0; dx < newwidth; dx++)
@@ -1259,7 +1282,7 @@ void R_CacheRotSprite(spritenum_t sprnum, UINT8 frame, spriteinfo_t *sprinfo, sp
sx >>= FRACBITS;
sy >>= FRACBITS;
if (sx >= 0 && sy >= 0 && sx < width && sy < height)
- rawdst[(dy*newwidth)+dx] = rawsrc[(sy*width)+sx];
+ rawdst[(dy*newwidth)+dx] = GetPatchPixel(patch, sx, sy, bflip);
}
}
@@ -1296,7 +1319,6 @@ void R_CacheRotSprite(spritenum_t sprnum, UINT8 frame, spriteinfo_t *sprinfo, sp
sprframe->rotsprite.cached[rot] = true;
// free image data
- Z_Free(rawsrc);
Z_Free(patch);
}
#undef SPRITE_XCENTER
@@ -1374,4 +1396,19 @@ void R_FreeSkinRotSprite(size_t skinnum)
skinsprites++;
}
}
+
+//
+// R_FreeAllRotSprite
+//
+// Free ALL sprite rotation data from memory.
+//
+void R_FreeAllRotSprite(void)
+{
+ INT32 i;
+ size_t s;
+ for (s = 0; s < numsprites; s++)
+ R_FreeSingleRotSprite(&sprites[s]);
+ for (i = 0; i < numskins; ++i)
+ R_FreeSkinRotSprite(i);
+}
#endif
diff --git a/src/r_patch.h b/src/r_patch.h
index 8a8ab5602bbebaa507a84cb129b82d5a35bac53d..2961448a0bc10d1401ae5bf39e8dc06f6664a30f 100644
--- a/src/r_patch.h
+++ b/src/r_patch.h
@@ -18,7 +18,6 @@
#include "doomdef.h"
// Structs
-#ifdef ROTSPRITE
typedef enum
{
ROTAXIS_X, // Roll (the default)
@@ -31,13 +30,10 @@ typedef struct
INT32 x, y;
rotaxis_t rotaxis;
} spriteframepivot_t;
-#endif
typedef struct
{
-#ifdef ROTSPRITE
spriteframepivot_t pivot[64];
-#endif
boolean available;
} spriteinfo_t;
@@ -66,11 +62,13 @@ void R_ParseSPRTINFOLump(UINT16 wadNum, UINT16 lumpNum);
// Sprite rotation
#ifdef ROTSPRITE
+INT32 R_GetRollAngle(angle_t rollangle);
void R_CacheRotSprite(spritenum_t sprnum, UINT8 frame, spriteinfo_t *sprinfo, spriteframe_t *sprframe, INT32 rot, UINT8 flip);
void R_FreeSingleRotSprite(spritedef_t *spritedef);
void R_FreeSkinRotSprite(size_t skinnum);
-extern fixed_t cosang2rad[ROTANGLES];
-extern fixed_t sinang2rad[ROTANGLES];
+extern fixed_t rollcosang[ROTANGLES];
+extern fixed_t rollsinang[ROTANGLES];
+void R_FreeAllRotSprite(void);
#endif
#endif // __R_PATCH__
diff --git a/src/r_segs.c b/src/r_segs.c
index 29120ebb89b4b7bac4ca3bdb7de6d16852dafe0a..1af1cb2a23fefcb91015e82b79857693d670e9d2 100644
--- a/src/r_segs.c
+++ b/src/r_segs.c
@@ -165,7 +165,7 @@ static void R_DrawWallSplats(void)
mfloorclip = floorclip;
mceilingclip = ceilingclip;
- patch = W_CachePatchNum(splat->patch, PU_CACHE);
+ patch = W_CachePatchNum(splat->patch, PU_PATCH);
dc_texturemid = splat->top + (SHORT(patch->height)<<(FRACBITS-1)) - viewz;
if (splat->yoffset)
@@ -308,6 +308,10 @@ void R_RenderMaskedSegRange(drawseg_t *ds, INT32 x1, INT32 x2)
// for horizontal / vertical / diagonal. Diagonal?
// OPTIMIZE: get rid of LIGHTSEGSHIFT globally
curline = ds->curline;
+
+ if (curline->glseg)
+ return;
+
frontsector = curline->frontsector;
backsector = curline->backsector;
texnum = R_GetTextureNum(curline->sidedef->midtexture);
diff --git a/src/r_splats.c b/src/r_splats.c
index 414e93eb6f6bac225435926e7d497e939b21bd5b..f690dfa9417a4dff9a45d5605c719d6a9860208c 100644
--- a/src/r_splats.c
+++ b/src/r_splats.c
@@ -147,7 +147,7 @@ void R_AddWallSplat(line_t *wallline, INT16 sectorside, const char *patchname, f
splat->flags = flags;
// bad.. but will be needed for drawing anyway..
- patch = W_CachePatchNum(splat->patch, PU_CACHE);
+ patch = W_CachePatchNum(splat->patch, PU_PATCH);
// offset needed by draw code for texture mapping
linelength = P_SegLength((seg_t *)wallline);
diff --git a/src/r_state.h b/src/r_state.h
index 75566923b140adfdffb47a3f64282e3f4ea3a3b5..4e1eb388e7d0a05d46a9c5ee80970c7b2545d2c9 100644
--- a/src/r_state.h
+++ b/src/r_state.h
@@ -63,6 +63,7 @@ extern seg_t *segs;
extern size_t numsectors;
extern sector_t *sectors;
+extern sector_t *spawnsectors;
extern size_t numsubsectors;
extern subsector_t *subsectors;
@@ -72,9 +73,11 @@ extern node_t *nodes;
extern size_t numlines;
extern line_t *lines;
+extern line_t *spawnlines;
extern size_t numsides;
extern side_t *sides;
+extern side_t *spawnsides;
//
// POV data.
diff --git a/src/r_things.c b/src/r_things.c
index aa2a73515adfd2d75d450e18b6d9d10c9b050f34..b9871c06bf155e478b2dd804eeb5e5a7089e784d 100644
--- a/src/r_things.c
+++ b/src/r_things.c
@@ -126,11 +126,10 @@ static void R_InstallSpriteLump(UINT16 wad, // graphics patch
for (ang = 0; ang < ROTANGLES; ang++)
sprtemp[frame].rotsprite.patch[r][ang] = NULL;
#ifdef HWRENDER
- if (rendermode == render_opengl)
- sprtemp[frame].rotsprite.hardware_patch[r] = M_AATreeAlloc(AATREE_ZUSER);
-#endif // HWRENDER
+ sprtemp[frame].rotsprite.hardware_patch[r] = M_AATreeAlloc(AATREE_ZUSER);
+#endif/*HWRENDER*/
}
-#endif
+#endif/*ROTSPRITE*/
if (rotation == 0)
{
@@ -500,7 +499,7 @@ void R_InitSprites(void)
{
size_t i;
#ifdef ROTSPRITE
- INT32 angle, realangle = 0;
+ INT32 angle;
float fa;
#endif
@@ -508,12 +507,11 @@ void R_InitSprites(void)
negonearray[i] = -1;
#ifdef ROTSPRITE
- for (angle = 0; angle < ROTANGLES; angle++)
+ for (angle = 1; angle < ROTANGLES; angle++)
{
- fa = ANG2RAD(FixedAngle(realangle<<FRACBITS));
- cosang2rad[angle] = FLOAT_TO_FIXED(cos(-fa));
- sinang2rad[angle] = FLOAT_TO_FIXED(sin(-fa));
- realangle += ROTANGDIFF;
+ fa = ANG2RAD(FixedAngle((ROTANGDIFF * angle)<<FRACBITS));
+ rollcosang[angle] = FLOAT_TO_FIXED(cos(-fa));
+ rollsinang[angle] = FLOAT_TO_FIXED(sin(-fa));
}
#endif
@@ -1127,8 +1125,7 @@ static void R_ProjectSprite(mobj_t *thing)
fixed_t spr_offset, spr_topoffset;
#ifdef ROTSPRITE
patch_t *rotsprite = NULL;
- angle_t arollangle = thing->rollangle;
- UINT32 rollangle = AngleFixed(arollangle)>>FRACBITS;
+ INT32 rollangle = 0;
#endif
#ifndef PROPERPAPER
@@ -1260,11 +1257,11 @@ static void R_ProjectSprite(mobj_t *thing)
spr_topoffset = spritecachedinfo[lump].topoffset;
#ifdef ROTSPRITE
- if (rollangle > 0)
+ if (thing->rollangle)
{
+ rollangle = R_GetRollAngle(thing->rollangle);
if (!sprframe->rotsprite.cached[rot])
R_CacheRotSprite(thing->sprite, (thing->frame & FF_FRAMEMASK), sprinfo, sprframe, rot, flip);
- rollangle /= ROTANGDIFF;
rotsprite = sprframe->rotsprite.patch[rot][rollangle];
if (rotsprite != NULL)
{
@@ -2839,7 +2836,7 @@ boolean R_SkinUsable(INT32 playernum, INT32 skinnum)
{
return ((skinnum == -1) // Simplifies things elsewhere, since there's already plenty of checks for less-than-0...
|| (!skins[skinnum].availability)
- || ((playernum != -1) ? (players[playernum].availabilities & (1 << skinnum)) : (unlockables[skins[skinnum].availability - 1].unlocked))
+ || (((netgame || multiplayer) && playernum != -1) ? (players[playernum].availabilities & (1 << skinnum)) : (unlockables[skins[skinnum].availability - 1].unlocked))
|| (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.
diff --git a/src/s_sound.c b/src/s_sound.c
index a494990407693568ed6ddda9ad042784dd3d8c66..0235d8376ce791b7859ab8997153709a2b336848 100644
--- a/src/s_sound.c
+++ b/src/s_sound.c
@@ -61,7 +61,9 @@ static void GameMIDIMusic_OnChange(void);
static void GameSounds_OnChange(void);
static void GameDigiMusic_OnChange(void);
+#ifdef HAVE_OPENMPT
static void ModFilter_OnChange(void);
+#endif
static lumpnum_t S_GetMusicLumpNum(const char *mname);
diff --git a/src/screen.c b/src/screen.c
index 507067705e473223272be23d22f1c28c80564fe3..f9d81f8af3fd71a0e655a76fdb0ed25607093870 100644
--- a/src/screen.c
+++ b/src/screen.c
@@ -53,6 +53,7 @@ void (*spanfuncs_npo2[SPANDRAWFUNC_MAX])(void);
// ------------------
viddef_t vid;
INT32 setmodeneeded; //video mode change needed if > 0 (the mode number to set + 1)
+UINT8 setrenderneeded = 0;
static CV_PossibleValue_t scr_depth_cons_t[] = {{8, "8 bits"}, {16, "16 bits"}, {24, "24 bits"}, {32, "32 bits"}, {0, NULL}};
@@ -62,7 +63,11 @@ consvar_t cv_scr_height = {"scr_height", "800", CV_SAVE, CV_Unsigned, NULL, 0, N
consvar_t cv_scr_depth = {"scr_depth", "16 bits", CV_SAVE, scr_depth_cons_t, NULL, 0, NULL, NULL, 0, 0, NULL};
consvar_t cv_renderview = {"renderview", "On", 0, CV_OnOff, NULL, 0, NULL, NULL, 0, 0, NULL};
-static void SCR_ChangeFullscreen (void);
+static void SCR_ActuallyChangeRenderer(void);
+CV_PossibleValue_t cv_renderer_t[] = {{1, "Software"}, {2, "OpenGL"}, {0, NULL}};
+consvar_t cv_renderer = {"renderer", "Software", CV_SAVE|CV_NOLUA|CV_CALL, cv_renderer_t, SCR_ChangeRenderer, 0, NULL, NULL, 0, 0, NULL};
+
+static void SCR_ChangeFullscreen(void);
consvar_t cv_fullscreen = {"fullscreen", "Yes", CV_SAVE|CV_CALL, CV_YesNo, SCR_ChangeFullscreen, 0, NULL, NULL, 0, 0, NULL};
@@ -87,19 +92,8 @@ boolean R_3DNow = false;
boolean R_MMXExt = false;
boolean R_SSE2 = false;
-
-void SCR_SetMode(void)
+void SCR_SetDrawFuncs(void)
{
- if (dedicated)
- return;
-
- if (!setmodeneeded || WipeInAction)
- return; // should never happen and don't change it during a wipe, BAD!
-
- VID_SetMode(--setmodeneeded);
-
- V_SetPalette(0);
-
//
// setup the right draw routines for either 8bpp or 16bpp
//
@@ -193,9 +187,37 @@ void SCR_SetMode(void)
if (SCR_IsAspectCorrect(vid.width, vid.height))
CONS_Alert(CONS_WARNING, M_GetText("Resolution is not aspect-correct!\nUse a multiple of %dx%d\n"), BASEVIDWIDTH, BASEVIDHEIGHT);
*/
+}
+
+void SCR_SetMode(void)
+{
+ if (dedicated)
+ return;
+
+ if (!(setmodeneeded || setrenderneeded) || WipeInAction)
+ return; // should never happen and don't change it during a wipe, BAD!
+
+ // Lactozilla: Renderer switching
+ if (setrenderneeded)
+ {
+ Z_PreparePatchFlush();
+ needpatchflush = true;
+ needpatchrecache = true;
+ VID_CheckRenderer();
+ if (!setmodeneeded)
+ VID_SetMode(vid.modenum);
+ }
+
+ if (setmodeneeded)
+ VID_SetMode(--setmodeneeded);
+
+ V_SetPalette(0);
+
+ SCR_SetDrawFuncs();
// set the apprpriate drawer for the sky (tall or INT16)
setmodeneeded = 0;
+ setrenderneeded = 0;
}
// do some initial settings for the game loading screen
@@ -383,6 +405,8 @@ void SCR_CheckDefaultMode(void)
// see note above
setmodeneeded = VID_GetModeForSize(cv_scr_width.value, cv_scr_height.value) + 1;
}
+
+ SCR_ActuallyChangeRenderer();
}
// sets the modenum as the new default video mode to be saved in the config file
@@ -412,6 +436,50 @@ void SCR_ChangeFullscreen(void)
#endif
}
+static int target_renderer = 0;
+
+void SCR_ActuallyChangeRenderer(void)
+{
+ setrenderneeded = target_renderer;
+ // setting the same renderer twice WILL crash your game, so let's not, please
+ if (rendermode == setrenderneeded)
+ setrenderneeded = 0;
+}
+
+// Lactozilla: Renderer switching
+void SCR_ChangeRenderer(void)
+{
+ setrenderneeded = 0;
+
+ if (con_startup)
+ {
+ target_renderer = cv_renderer.value;
+ if (M_CheckParm("-opengl"))
+ target_renderer = rendermode = render_opengl;
+ else if (M_CheckParm("-software"))
+ target_renderer = rendermode = render_soft;
+ // set cv_renderer back
+ SCR_ChangeRendererCVars(rendermode);
+ return;
+ }
+
+ if (cv_renderer.value == 1)
+ target_renderer = render_soft;
+ else if (cv_renderer.value == 2)
+ target_renderer = render_opengl;
+ SCR_ActuallyChangeRenderer();
+}
+
+void SCR_ChangeRendererCVars(INT32 mode)
+{
+ // set cv_renderer back
+ if (mode == render_soft)
+ CV_StealthSetValue(&cv_renderer, 1);
+ else if (mode == render_opengl)
+ CV_StealthSetValue(&cv_renderer, 2);
+ CV_StealthSetValue(&cv_newrenderer, cv_renderer.value);
+}
+
boolean SCR_IsAspectCorrect(INT32 width, INT32 height)
{
return
diff --git a/src/screen.h b/src/screen.h
index 470acb4b9699bac380afcc0770fa2fa99e358832..d47cdff9aa3ccf45555c79314e8430faeef63339 100644
--- a/src/screen.h
+++ b/src/screen.h
@@ -170,18 +170,27 @@ extern boolean R_SSE2;
// ----------------
// screen variables
// ----------------
+
extern viddef_t vid;
extern INT32 setmodeneeded; // mode number to set if needed, or 0
+void SCR_ChangeRenderer(void);
+void SCR_ChangeRendererCVars(INT32 mode);
+extern UINT8 setrenderneeded;
+
extern INT32 scr_bpp;
extern UINT8 *scr_borderpatch; // patch used to fill the view borders
-extern consvar_t cv_scr_width, cv_scr_height, cv_scr_depth, cv_renderview, cv_fullscreen;
+extern CV_PossibleValue_t cv_renderer_t[];
+
+extern consvar_t cv_scr_width, cv_scr_height, cv_scr_depth, cv_renderview, cv_renderer, cv_fullscreen;
+extern consvar_t cv_newrenderer;
// wait for page flipping to end or not
extern consvar_t cv_vidwait;
// Change video mode, only at the start of a refresh.
void SCR_SetMode(void);
+void SCR_SetDrawFuncs(void);
// Recalc screen size dependent stuff
void SCR_Recalc(void);
// Check parms once at startup
diff --git a/src/sdl/i_video.c b/src/sdl/i_video.c
index e054381eec6183cba9b46d4948dc4f0723a0b088..8065162929001c4e92de7ad75bac7dc5278a51ab 100644
--- a/src/sdl/i_video.c
+++ b/src/sdl/i_video.c
@@ -71,6 +71,7 @@
#include "../i_video.h"
#include "../console.h"
#include "../command.h"
+#include "../r_main.h"
#include "sdlmain.h"
#ifdef HWRENDER
#include "../hardware/hw_main.h"
@@ -1208,7 +1209,6 @@ void I_FinishUpdate(void)
SDL_RenderCopy(renderer, texture, NULL, NULL);
SDL_RenderPresent(renderer);
}
-
#ifdef HWRENDER
else if (rendermode == render_opengl)
{
@@ -1408,37 +1408,53 @@ void VID_PrepareModeList(void)
#endif
}
-INT32 VID_SetMode(INT32 modeNum)
+static SDL_bool Impl_CreateContext(void)
{
- SDLdoUngrabMouse();
-
- vid.recalc = 1;
- vid.bpp = 1;
-
- if (modeNum >= 0 && modeNum < MAXWINMODES)
+ // Renderer-specific stuff
+#ifdef HWRENDER
+ if (rendermode == render_opengl)
{
- vid.width = windowedModes[modeNum][0];
- vid.height = windowedModes[modeNum][1];
- vid.modenum = modeNum;
+ if (!sdlglcontext)
+ sdlglcontext = SDL_GL_CreateContext(window);
+ if (sdlglcontext == NULL)
+ {
+ SDL_DestroyWindow(window);
+ I_Error("Failed to create a GL context: %s\n", SDL_GetError());
+ }
+ SDL_GL_MakeCurrent(window, sdlglcontext);
}
else
+#endif
+ if (rendermode == render_soft)
{
- // just set the desktop resolution as a fallback
- SDL_DisplayMode mode;
- SDL_GetWindowDisplayMode(window, &mode);
- if (mode.w >= 2048)
- {
- vid.width = 1920;
- vid.height = 1200;
- }
- else
+ int flags = 0; // Use this to set SDL_RENDERER_* flags now
+ if (usesdl2soft)
+ flags |= SDL_RENDERER_SOFTWARE;
+ else if (cv_vidwait.value)
+ flags |= SDL_RENDERER_PRESENTVSYNC;
+
+ if (!renderer)
+ renderer = SDL_CreateRenderer(window, -1, flags);
+ if (renderer == NULL)
{
- vid.width = mode.w;
- vid.height = mode.h;
+ CONS_Printf(M_GetText("Couldn't create rendering context: %s\n"), SDL_GetError());
+ return SDL_FALSE;
}
- vid.modenum = -1;
+ SDL_RenderSetLogicalSize(renderer, BASEVIDWIDTH, BASEVIDHEIGHT);
+ }
+ return SDL_TRUE;
+}
+
+void VID_CheckRenderer(void)
+{
+ if (dedicated)
+ return;
+
+ if (setrenderneeded)
+ {
+ rendermode = setrenderneeded;
+ Impl_CreateContext();
}
- //Impl_SetWindowName("SRB2 "VERSIONSTRING);
SDLSetMode(vid.width, vid.height, USE_FULLSCREEN);
Impl_VideoSetupBuffer();
@@ -1450,8 +1466,39 @@ INT32 VID_SetMode(INT32 modeNum)
SDL_FreeSurface(bufSurface);
bufSurface = NULL;
}
+#ifdef HWRENDER
+ HWR_FreeTextureCache();
+#endif
+ SCR_SetDrawFuncs();
+ }
+#ifdef HWRENDER
+ else if (rendermode == render_opengl)
+ {
+ I_StartupHardwareGraphics();
+ R_InitHardwareMode();
+ HWR_Switch();
}
+#endif
+}
+
+INT32 VID_SetMode(INT32 modeNum)
+{
+ SDLdoUngrabMouse();
+
+ vid.recalc = 1;
+ vid.bpp = 1;
+ if (modeNum < 0)
+ modeNum = 0;
+ if (modeNum >= MAXWINMODES)
+ modeNum = MAXWINMODES-1;
+
+ vid.width = windowedModes[modeNum][0];
+ vid.height = windowedModes[modeNum][1];
+ vid.modenum = modeNum;
+
+ //Impl_SetWindowName("SRB2 "VERSIONSTRING);
+ VID_CheckRenderer();
return SDL_TRUE;
}
@@ -1472,8 +1519,7 @@ static SDL_bool Impl_CreateWindow(SDL_bool fullscreen)
flags |= SDL_WINDOW_BORDERLESS;
#ifdef HWRENDER
- if (rendermode == render_opengl)
- flags |= SDL_WINDOW_OPENGL;
+ flags |= SDL_WINDOW_OPENGL;
#endif
// Create a window
@@ -1486,38 +1532,7 @@ static SDL_bool Impl_CreateWindow(SDL_bool fullscreen)
return SDL_FALSE;
}
- // Renderer-specific stuff
-#ifdef HWRENDER
- if (rendermode == render_opengl)
- {
- sdlglcontext = SDL_GL_CreateContext(window);
- if (sdlglcontext == NULL)
- {
- SDL_DestroyWindow(window);
- I_Error("Failed to create a GL context: %s\n", SDL_GetError());
- }
- SDL_GL_MakeCurrent(window, sdlglcontext);
- }
- else
-#endif
- if (rendermode == render_soft)
- {
- flags = 0; // Use this to set SDL_RENDERER_* flags now
- if (usesdl2soft)
- flags |= SDL_RENDERER_SOFTWARE;
- else if (cv_vidwait.value)
- flags |= SDL_RENDERER_PRESENTVSYNC;
-
- renderer = SDL_CreateRenderer(window, -1, flags);
- if (renderer == NULL)
- {
- CONS_Printf(M_GetText("Couldn't create rendering context: %s\n"), SDL_GetError());
- return SDL_FALSE;
- }
- SDL_RenderSetLogicalSize(renderer, BASEVIDWIDTH, BASEVIDHEIGHT);
- }
-
- return SDL_TRUE;
+ return Impl_CreateContext();
}
/*
@@ -1572,17 +1587,14 @@ static void Impl_VideoSetupSDLBuffer(void)
static void Impl_VideoSetupBuffer(void)
{
// Set up game's software render buffer
- //if (rendermode == render_soft)
+ vid.rowbytes = vid.width * vid.bpp;
+ vid.direct = NULL;
+ if (vid.buffer)
+ free(vid.buffer);
+ vid.buffer = calloc(vid.rowbytes*vid.height, NUMSCREENS);
+ if (!vid.buffer)
{
- vid.rowbytes = vid.width * vid.bpp;
- vid.direct = NULL;
- if (vid.buffer)
- free(vid.buffer);
- vid.buffer = calloc(vid.rowbytes*vid.height, NUMSCREENS);
- if (!vid.buffer)
- {
- I_Error("%s", M_GetText("Not enough memory for video buffer\n"));
- }
+ I_Error("%s", M_GetText("Not enough memory for video buffer\n"));
}
}
@@ -1626,10 +1638,13 @@ void I_StartupGraphics(void)
))
framebuffer = SDL_TRUE;
}
- if (M_CheckParm("-software"))
- {
+
+#ifdef HWRENDER
+ if (M_CheckParm("-opengl"))
+ rendermode = render_opengl;
+ else if (M_CheckParm("-software"))
+#endif
rendermode = render_soft;
- }
usesdl2soft = M_CheckParm("-softblit");
borderlesswindow = M_CheckParm("-borderless");
@@ -1637,44 +1652,7 @@ void I_StartupGraphics(void)
//SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY>>1,SDL_DEFAULT_REPEAT_INTERVAL<<2);
VID_Command_ModeList_f();
#ifdef HWRENDER
- if (M_CheckParm("-opengl") || rendermode == render_opengl)
- {
- rendermode = render_opengl;
- HWD.pfnInit = hwSym("Init",NULL);
- 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);
- HWD.pfnReadRect = hwSym("ReadRect",NULL);
- HWD.pfnGClipRect = hwSym("GClipRect",NULL);
- HWD.pfnClearMipMapCache = hwSym("ClearMipMapCache",NULL);
- HWD.pfnSetSpecialState = hwSym("SetSpecialState",NULL);
- HWD.pfnSetPalette = hwSym("SetPalette",NULL);
- HWD.pfnGetTextureUsed = hwSym("GetTextureUsed",NULL);
- HWD.pfnDrawModel = hwSym("DrawModel",NULL);
- HWD.pfnCreateModelVBOs = hwSym("CreateModelVBOs",NULL);
- HWD.pfnSetTransform = hwSym("SetTransform",NULL);
- HWD.pfnGetRenderVersion = hwSym("GetRenderVersion",NULL);
- HWD.pfnPostImgRedraw = hwSym("PostImgRedraw",NULL);
- HWD.pfnFlushScreenTextures=hwSym("FlushScreenTextures",NULL);
- HWD.pfnStartScreenWipe = hwSym("StartScreenWipe",NULL);
- HWD.pfnEndScreenWipe = hwSym("EndScreenWipe",NULL);
- HWD.pfnDoScreenWipe = hwSym("DoScreenWipe",NULL);
- HWD.pfnDrawIntermissionBG=hwSym("DrawIntermissionBG",NULL);
- HWD.pfnMakeScreenTexture= hwSym("MakeScreenTexture",NULL);
- HWD.pfnMakeScreenFinalTexture=hwSym("MakeScreenFinalTexture",NULL);
- HWD.pfnDrawScreenFinalTexture=hwSym("DrawScreenFinalTexture",NULL);
- // check gl renderer lib
- if (HWD.pfnGetRenderVersion() != VERSION)
- I_Error("%s", M_GetText("The version of the renderer doesn't match the version of the executable\nBe sure you have installed SRB2 properly.\n"));
- if (!HWD.pfnInit(I_Error)) // let load the OpenGL library
- {
- rendermode = render_soft;
- }
- }
+ I_StartupHardwareGraphics();
#endif
// Fury: we do window initialization after GL setup to allow
@@ -1734,6 +1712,50 @@ void I_StartupGraphics(void)
graphics_started = true;
}
+void I_StartupHardwareGraphics(void)
+{
+#ifdef HWRENDER
+ static boolean glstartup = false;
+ if (!glstartup)
+ {
+ HWD.pfnInit = hwSym("Init",NULL);
+ 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);
+ HWD.pfnReadRect = hwSym("ReadRect",NULL);
+ HWD.pfnGClipRect = hwSym("GClipRect",NULL);
+ HWD.pfnClearMipMapCache = hwSym("ClearMipMapCache",NULL);
+ HWD.pfnSetSpecialState = hwSym("SetSpecialState",NULL);
+ HWD.pfnSetPalette = hwSym("SetPalette",NULL);
+ HWD.pfnGetTextureUsed = hwSym("GetTextureUsed",NULL);
+ HWD.pfnDrawModel = hwSym("DrawModel",NULL);
+ HWD.pfnCreateModelVBOs = hwSym("CreateModelVBOs",NULL);
+ HWD.pfnSetTransform = hwSym("SetTransform",NULL);
+ HWD.pfnGetRenderVersion = hwSym("GetRenderVersion",NULL);
+ HWD.pfnPostImgRedraw = hwSym("PostImgRedraw",NULL);
+ HWD.pfnFlushScreenTextures=hwSym("FlushScreenTextures",NULL);
+ HWD.pfnStartScreenWipe = hwSym("StartScreenWipe",NULL);
+ HWD.pfnEndScreenWipe = hwSym("EndScreenWipe",NULL);
+ HWD.pfnDoScreenWipe = hwSym("DoScreenWipe",NULL);
+ HWD.pfnDrawIntermissionBG=hwSym("DrawIntermissionBG",NULL);
+ HWD.pfnMakeScreenTexture= hwSym("MakeScreenTexture",NULL);
+ HWD.pfnMakeScreenFinalTexture=hwSym("MakeScreenFinalTexture",NULL);
+ HWD.pfnDrawScreenFinalTexture=hwSym("DrawScreenFinalTexture",NULL);
+ // check gl renderer lib
+ if (HWD.pfnGetRenderVersion() != VERSION)
+ I_Error("%s", M_GetText("The version of the renderer doesn't match the version of the executable\nBe sure you have installed SRB2 properly.\n"));
+ if (!HWD.pfnInit(I_Error)) // let load the OpenGL library
+ rendermode = render_soft;
+ else
+ glstartup = true;
+ }
+#endif
+}
+
void I_ShutdownGraphics(void)
{
const rendermode_t oldrendermode = rendermode;
diff --git a/src/sdl/sdl_sound.c b/src/sdl/sdl_sound.c
index 33b366bf60320270eb77df832e12257cc3f6b020..b8991293c344b65a8bc63ca356512896e3ffede6 100644
--- a/src/sdl/sdl_sound.c
+++ b/src/sdl/sdl_sound.c
@@ -1432,6 +1432,8 @@ static void I_ResumeGME(void)
boolean I_LoadSong(char *data, size_t len)
{
+ (void)data;
+ (void)len;
return false;
}
@@ -1493,6 +1495,7 @@ boolean I_FadeSongFromVolume(UINT8 target_volume, UINT8 source_volume, UINT32 ms
(void)target_volume;
(void)source_volume;
(void)ms;
+ (void)callback;
return false;
}
@@ -1500,6 +1503,7 @@ boolean I_FadeSong(UINT8 target_volume, UINT32 ms, void (*callback)(void))
{
(void)target_volume;
(void)ms;
+ (void)callback;
return false;
}
diff --git a/src/st_stuff.c b/src/st_stuff.c
index 03b32285d9e844f314a19d3242d71e547dab7144..bc4ab1a544b216c1456e16a8d4305bfdd46ac738 100644
--- a/src/st_stuff.c
+++ b/src/st_stuff.c
@@ -694,7 +694,7 @@ static void ST_drawTime(void)
else
{
// Counting down the hidetime?
- if ((gametype == GT_TAG || gametype == GT_HIDEANDSEEK) && (stplyr->realtime <= (hidetime*TICRATE)))
+ if ((gametyperules & GTR_HIDETIME) && (stplyr->realtime <= (hidetime*TICRATE)))
{
tics = (hidetime*TICRATE - stplyr->realtime);
if (tics < 3*TICRATE)
@@ -705,11 +705,11 @@ static void ST_drawTime(void)
else
{
// Hidetime finish!
- if ((gametype == GT_TAG || gametype == GT_HIDEANDSEEK) && (stplyr->realtime < ((hidetime+1)*TICRATE)))
+ if ((gametyperules & GTR_HIDETIME) && (stplyr->realtime < ((hidetime+1)*TICRATE)))
ST_drawRaceNum(hidetime*TICRATE - stplyr->realtime);
// Time limit?
- if (gametype != GT_COOP && gametype != GT_RACE && gametype != GT_COMPETITION && cv_timelimit.value && timelimitintics > 0)
+ if ((gametyperules & GTR_TIMELIMIT) && cv_timelimit.value && timelimitintics > 0)
{
if (timelimitintics > stplyr->realtime)
{
@@ -723,7 +723,7 @@ static void ST_drawTime(void)
downwards = true;
}
// Post-hidetime normal.
- else if (gametype == GT_TAG || gametype == GT_HIDEANDSEEK)
+ else if (gametyperules & GTR_TAG)
tics = stplyr->realtime - hidetime*TICRATE;
// "Shadow! What are you doing? Hurry and get back here
// right now before the island blows up with you on it!"
@@ -912,7 +912,7 @@ static void ST_drawLivesArea(void)
else if (stplyr->spectator)
v_colmap = V_GRAYMAP;
// Tag
- else if (gametype == GT_TAG || gametype == GT_HIDEANDSEEK)
+ else if (gametyperules & GTR_TAG)
{
if (stplyr->pflags & PF_TAGIT)
{
@@ -1187,21 +1187,33 @@ tic_t lt_exitticker = 0, lt_endtime = 0;
//
// Load the graphics for the title card.
+// Don't let LJ see this
//
static void ST_cacheLevelTitle(void)
{
- if (!(mapheaderinfo[gamemap-1]->levelflags & LF_WARNINGTITLE))
- {
- lt_patches[0] = (patch_t *)W_CachePatchName("LTACTBLU", PU_HUDGFX);
- lt_patches[1] = (patch_t *)W_CachePatchName("LTZIGZAG", PU_HUDGFX);
- lt_patches[2] = (patch_t *)W_CachePatchName("LTZZTEXT", PU_HUDGFX);
- }
- else // boss map
- {
- lt_patches[0] = (patch_t *)W_CachePatchName("LTACTRED", PU_HUDGFX);
- lt_patches[1] = (patch_t *)W_CachePatchName("LTZIGRED", PU_HUDGFX);
- lt_patches[2] = (patch_t *)W_CachePatchName("LTZZWARN", PU_HUDGFX);
- }
+#define SETPATCH(default, warning, custom, idx) \
+{ \
+ lumpnum_t patlumpnum = LUMPERROR; \
+ if (mapheaderinfo[gamemap-1]->custom[0] != '\0') \
+ { \
+ patlumpnum = W_CheckNumForName(mapheaderinfo[gamemap-1]->custom); \
+ if (patlumpnum != LUMPERROR) \
+ lt_patches[idx] = (patch_t *)W_CachePatchNum(patlumpnum, PU_HUDGFX); \
+ } \
+ if (patlumpnum == LUMPERROR) \
+ { \
+ if (!(mapheaderinfo[gamemap-1]->levelflags & LF_WARNINGTITLE)) \
+ lt_patches[idx] = (patch_t *)W_CachePatchName(default, PU_HUDGFX); \
+ else \
+ lt_patches[idx] = (patch_t *)W_CachePatchName(warning, PU_HUDGFX); \
+ } \
+}
+
+ SETPATCH("LTACTBLU", "LTACTRED", ltactdiamond, 0)
+ SETPATCH("LTZIGZAG", "LTZIGRED", ltzzpatch, 1)
+ SETPATCH("LTZZTEXT", "LTZZWARN", ltzztext, 2)
+
+#undef SETPATCH
}
//
@@ -1226,6 +1238,9 @@ void ST_startTitleCard(void)
//
void ST_preDrawTitleCard(void)
{
+ if (!G_IsTitleCardAvailable())
+ return;
+
if (lt_ticker >= (lt_endtime + TICRATE))
return;
@@ -1241,6 +1256,9 @@ void ST_preDrawTitleCard(void)
//
void ST_runTitleCard(void)
{
+ if (!G_IsTitleCardAvailable())
+ return;
+
if (lt_ticker >= (lt_endtime + TICRATE))
return;
@@ -1294,6 +1312,9 @@ void ST_drawTitleCard(void)
INT32 zzticker;
patch_t *actpat, *zigzag, *zztext;
+ if (!G_IsTitleCardAvailable())
+ return;
+
#ifdef HAVE_BLUA
if (!LUA_HudEnabled(hud_stagetitle))
goto luahook;
@@ -1772,7 +1793,7 @@ static void ST_drawNiGHTSHUD(void)
ST_drawNiGHTSLink();
}
- if (gametype == GT_RACE || gametype == GT_COMPETITION)
+ if (gametyperules & GTR_RACE)
{
ST_drawScore();
ST_drawTime();
@@ -2213,34 +2234,37 @@ static void ST_drawTextHUD(void)
if (G_IsSpecialStage(gamemap))
textHUDdraw(M_GetText("\x82""Wait for the stage to end..."))
- else if (gametype == GT_COOP)
+ else if (G_PlatformGametype())
{
- if (stplyr->lives <= 0
- && cv_cooplives.value == 2
- && (netgame || multiplayer))
+ if (gametype == GT_COOP)
{
- INT32 i;
- for (i = 0; i < MAXPLAYERS; i++)
+ if (stplyr->lives <= 0
+ && cv_cooplives.value == 2
+ && (netgame || multiplayer))
{
- if (!playeringame[i])
- continue;
-
- if (&players[i] == stplyr)
- continue;
-
- if (players[i].lives > 1)
- break;
- }
-
- if (i != MAXPLAYERS)
- textHUDdraw(M_GetText("You'll steal a life on respawn..."))
+ INT32 i;
+ for (i = 0; i < MAXPLAYERS; i++)
+ {
+ if (!playeringame[i])
+ continue;
+
+ if (&players[i] == stplyr)
+ continue;
+
+ if (players[i].lives > 1)
+ break;
+ }
+
+ if (i != MAXPLAYERS)
+ textHUDdraw(M_GetText("You'll steal a life on respawn..."))
+ else
+ textHUDdraw(M_GetText("Wait to respawn..."))
+ }
else
textHUDdraw(M_GetText("Wait to respawn..."))
}
- else
- textHUDdraw(M_GetText("Wait to respawn..."))
}
- else
+ else if (G_GametypeHasSpectators())
textHUDdraw(M_GetText("\x82""FIRE:""\x80 Enter game"))
}
@@ -2283,13 +2307,14 @@ static void ST_drawTextHUD(void)
}
}
}
- else if ((gametype == GT_TAG || gametype == GT_HIDEANDSEEK) && (!stplyr->spectator))
+ else if ((gametyperules & GTR_TAG) && (!stplyr->spectator))
{
if (leveltime < hidetime * TICRATE)
{
if (stplyr->pflags & PF_TAGIT)
{
- textHUDdraw(M_GetText("\x82""You are blindfolded!"))
+ if (gametyperules & GTR_BLINDFOLDED)
+ textHUDdraw(M_GetText("\x82""You are blindfolded!"))
textHUDdraw(M_GetText("Waiting for players to hide..."))
}
else if (gametype == GT_HIDEANDSEEK)
@@ -2304,7 +2329,8 @@ static void ST_drawTextHUD(void)
textHUDdraw(M_GetText("\x82""VIEWPOINT:""\x80 Switch view"))
donef12 = true;
}
- textHUDdraw(M_GetText("You cannot move while hiding."))
+ if (gametyperules & GTR_HIDEFROZEN)
+ textHUDdraw(M_GetText("You cannot move while hiding."))
}
}
@@ -2326,21 +2352,27 @@ static void ST_drawTeamHUD(void)
if (F_GetPromptHideHud(0)) // y base is 0
return;
- if (gametype == GT_CTF)
+ if (gametyperules & GTR_TEAMFLAGS)
p = bflagico;
else
p = bmatcico;
+#ifdef HAVE_BLUA
+ if (LUA_HudEnabled(hud_teamscores))
+#endif
V_DrawSmallScaledPatch(BASEVIDWIDTH/2 - SEP - SHORT(p->width)/4, 4, V_HUDTRANS|V_PERPLAYER|V_SNAPTOTOP, p);
- if (gametype == GT_CTF)
+ if (gametyperules & GTR_TEAMFLAGS)
p = rflagico;
else
p = rmatcico;
+#ifdef HAVE_BLUA
+ if (LUA_HudEnabled(hud_teamscores))
+#endif
V_DrawSmallScaledPatch(BASEVIDWIDTH/2 + SEP - SHORT(p->width)/4, 4, V_HUDTRANS|V_PERPLAYER|V_SNAPTOTOP, p);
- if (gametype != GT_CTF)
+ if (!(gametyperules & GTR_TEAMFLAGS))
goto num;
{
INT32 i;
@@ -2349,28 +2381,53 @@ static void ST_drawTeamHUD(void)
// Show which flags aren't at base.
for (i = 0; i < MAXPLAYERS; i++)
{
- if (players[i].gotflag & GF_BLUEFLAG) // Blue flag isn't at base
+ if (players[i].gotflag & GF_BLUEFLAG // Blue flag isn't at base
+#ifdef HAVE_BLUA
+ && LUA_HudEnabled(hud_teamscores)
+#endif
+ )
V_DrawScaledPatch(BASEVIDWIDTH/2 - SEP - SHORT(nonicon->width)/2, 0, V_HUDTRANS|V_PERPLAYER|V_SNAPTOTOP, nonicon);
- if (players[i].gotflag & GF_REDFLAG) // Red flag isn't at base
+
+ if (players[i].gotflag & GF_REDFLAG // Red flag isn't at base
+#ifdef HAVE_BLUA
+ && LUA_HudEnabled(hud_teamscores)
+#endif
+ )
V_DrawScaledPatch(BASEVIDWIDTH/2 + SEP - SHORT(nonicon2->width)/2, 0, V_HUDTRANS|V_PERPLAYER|V_SNAPTOTOP, nonicon2);
whichflag |= players[i].gotflag;
+
if ((whichflag & (GF_REDFLAG|GF_BLUEFLAG)) == (GF_REDFLAG|GF_BLUEFLAG))
break; // both flags were found, let's stop early
}
// Display a countdown timer showing how much time left until the flag returns to base.
{
- if (blueflag && blueflag->fuse > 1)
+ if (blueflag && blueflag->fuse > 1
+#ifdef HAVE_BLUA
+ && LUA_HudEnabled(hud_teamscores)
+#endif
+ )
V_DrawCenteredString(BASEVIDWIDTH/2 - SEP, 8, V_YELLOWMAP|V_HUDTRANS|V_PERPLAYER|V_SNAPTOTOP, va("%u", (blueflag->fuse / TICRATE)));
- if (redflag && redflag->fuse > 1)
+ if (redflag && redflag->fuse > 1
+#ifdef HAVE_BLUA
+ && LUA_HudEnabled(hud_teamscores)
+#endif
+ )
V_DrawCenteredString(BASEVIDWIDTH/2 + SEP, 8, V_YELLOWMAP|V_HUDTRANS|V_PERPLAYER|V_SNAPTOTOP, va("%u", (redflag->fuse / TICRATE)));
}
}
num:
+#ifdef HAVE_BLUA
+ if (LUA_HudEnabled(hud_teamscores))
+#endif
V_DrawCenteredString(BASEVIDWIDTH/2 - SEP, 16, V_HUDTRANS|V_PERPLAYER|V_SNAPTOTOP, va("%u", bluescore));
+
+#ifdef HAVE_BLUA
+ if (LUA_HudEnabled(hud_teamscores))
+#endif
V_DrawCenteredString(BASEVIDWIDTH/2 + SEP, 16, V_HUDTRANS|V_PERPLAYER|V_SNAPTOTOP, va("%u", redscore));
#undef SEP
@@ -2643,7 +2700,7 @@ static void ST_overlayDrawer(void)
}
// If you are in overtime, put a big honkin' flashin' message on the screen.
- if (G_RingSlingerGametype() && cv_overtime.value
+ if (((gametyperules & GTR_TIMELIMIT) && (gametyperules & GTR_OVERTIME)) && cv_overtime.value
&& (leveltime > (timelimitintics + TICRATE/2)) && cv_timelimit.value && (leveltime/TICRATE % 2 == 0))
V_DrawCenteredString(BASEVIDWIDTH/2, 184, V_PERPLAYER, M_GetText("OVERTIME!"));
@@ -2658,7 +2715,7 @@ static void ST_overlayDrawer(void)
ST_drawMatchHUD();
// Race HUD Stuff
- if (gametype == GT_RACE || gametype == GT_COMPETITION)
+ if (gametyperules & GTR_RACE)
ST_drawRaceHUD();
// Emerald Hunt Indicators
@@ -2719,6 +2776,9 @@ static void ST_overlayDrawer(void)
void ST_Drawer(void)
{
+ if (needpatchrecache)
+ R_ReloadHUDGraphics();
+
#ifdef SEENAMES
if (cv_seenames.value && cv_allowseenames.value && displayplayer == consoleplayer && seenplayer && seenplayer->mo)
{
@@ -2763,7 +2823,7 @@ void ST_Drawer(void)
if (rendermode != render_none) ST_doPaletteStuff();
// Blindfold!
- if ((gametype == GT_TAG || gametype == GT_HIDEANDSEEK)
+ if ((gametyperules & GTR_BLINDFOLDED)
&& (leveltime < hidetime * TICRATE))
{
if (players[displayplayer].pflags & PF_TAGIT)
diff --git a/src/v_video.c b/src/v_video.c
index c91e5f213e8fb7ec0eca1ddc9d29176dbc2d8440..4785a154186c91a8421ce89027a2b9362b0c38d2 100644
--- a/src/v_video.c
+++ b/src/v_video.c
@@ -1045,13 +1045,13 @@ void V_DrawContinueIcon(INT32 x, INT32 y, INT32 flags, INT32 skinnum, UINT8 skin
{
spritedef_t *sprdef = &skins[skinnum].sprites[SPR2_XTRA];
spriteframe_t *sprframe = &sprdef->spriteframes[XTRA_CONTINUE];
- patch_t *patch = W_CachePatchNum(sprframe->lumppat[0], PU_LEVEL);
+ patch_t *patch = W_CachePatchNum(sprframe->lumppat[0], PU_PATCH);
const UINT8 *colormap = R_GetTranslationColormap(skinnum, skincolor, GTC_CACHE);
V_DrawMappedPatch(x, y, flags, patch, colormap);
}
else
- V_DrawScaledPatch(x - 10, y - 14, flags, W_CachePatchName("CONTINS", PU_CACHE));
+ V_DrawScaledPatch(x - 10, y - 14, flags, W_CachePatchName("CONTINS", PU_PATCH));
}
//
diff --git a/src/w_wad.c b/src/w_wad.c
index 86972118a8c8d55a44e7d3e23bcda86d4d2cfd4d..1aa2814264935ac92aa3c11d425142fe5795836a 100644
--- a/src/w_wad.c
+++ b/src/w_wad.c
@@ -55,6 +55,7 @@
#include "dehacked.h"
#include "d_clisrv.h"
#include "r_defs.h"
+#include "r_data.h"
#include "i_system.h"
#include "md5.h"
#include "lua_script.h"
@@ -1375,7 +1376,6 @@ void *W_CacheLumpNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
void *W_CacheLumpNum(lumpnum_t lumpnum, INT32 tag)
{
-
return W_CacheLumpNumPwad(WADFILENUM(lumpnum),LUMPNUM(lumpnum),tag);
}
@@ -1488,12 +1488,31 @@ void *W_CacheLumpName(const char *name, INT32 tag)
// Cache a patch into heap memory, convert the patch format as necessary
//
+void W_FlushCachedPatches(void)
+{
+ if (needpatchflush)
+ {
+ Z_FreeTag(PU_CACHE);
+ Z_FreeTag(PU_PATCH);
+ Z_FreeTag(PU_HUDGFX);
+ Z_FreeTag(PU_HWRPATCHINFO);
+ Z_FreeTag(PU_HWRMODELTEXTURE);
+ Z_FreeTag(PU_HWRCACHE);
+ Z_FreeTags(PU_HWRCACHE_UNLOCKED, PU_HWRPATCHINFO_UNLOCKED);
+ }
+ needpatchflush = false;
+}
+
+// Software-only compile cache the data without conversion
void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag)
{
#ifdef HWRENDER
GLPatch_t *grPatch;
#endif
+ if (needpatchflush)
+ W_FlushCachedPatches();
+
if (!TestValidLump(wad, lump))
return NULL;
@@ -1872,3 +1891,101 @@ int W_VerifyNMUSlumps(const char *filename)
};
return W_VerifyFile(filename, NMUSlist, false);
}
+
+/** \brief Generates a virtual resource used for level data loading.
+ *
+ * \param lumpnum_t reference
+ * \return Virtual resource
+ *
+ */
+virtres_t* vres_GetMap(lumpnum_t lumpnum)
+{
+ UINT32 i;
+ virtres_t* vres = NULL;
+ virtlump_t* vlumps = NULL;
+ size_t numlumps = 0;
+
+ if (W_IsLumpWad(lumpnum))
+ {
+ // Remember that we're assuming that the WAD will have a specific set of lumps in a specific order.
+ UINT8 *wadData = W_CacheLumpNum(lumpnum, PU_LEVEL);
+ filelump_t *fileinfo = (filelump_t *)(wadData + ((wadinfo_t *)wadData)->infotableofs);
+ numlumps = ((wadinfo_t *)wadData)->numlumps;
+ vlumps = Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL);
+
+ // Build the lumps.
+ for (i = 0; i < numlumps; i++)
+ {
+ vlumps[i].size = (size_t)(((filelump_t *)(fileinfo + i))->size);
+ // Play it safe with the name in this case.
+ memcpy(vlumps[i].name, (fileinfo + i)->name, 8);
+ vlumps[i].name[8] = '\0';
+ vlumps[i].data = Z_Malloc(vlumps[i].size, PU_LEVEL, NULL); // This is memory inefficient, sorry about that.
+ memcpy(vlumps[i].data, wadData + (fileinfo + i)->filepos, vlumps[i].size);
+ }
+
+ Z_Free(wadData);
+ }
+ else
+ {
+ // Count number of lumps until the end of resource OR up until next "MAPXX" lump.
+ lumpnum_t lumppos = lumpnum + 1;
+ for (i = LUMPNUM(lumppos); i < wadfiles[WADFILENUM(lumpnum)]->numlumps; i++, lumppos++, numlumps++)
+ if (memcmp(W_CheckNameForNum(lumppos), "MAP", 3) == 0)
+ break;
+ numlumps++;
+
+ vlumps = Z_Malloc(sizeof(virtlump_t)*numlumps, PU_LEVEL, NULL);
+ for (i = 0; i < numlumps; i++, lumpnum++)
+ {
+ vlumps[i].size = W_LumpLength(lumpnum);
+ memcpy(vlumps[i].name, W_CheckNameForNum(lumpnum), 8);
+ vlumps[i].name[8] = '\0';
+ vlumps[i].data = W_CacheLumpNum(lumpnum, PU_LEVEL);
+ }
+ }
+ vres = Z_Malloc(sizeof(virtres_t), PU_LEVEL, NULL);
+ vres->vlumps = vlumps;
+ vres->numlumps = numlumps;
+
+ return vres;
+}
+
+/** \brief Frees zone memory for a given virtual resource.
+ *
+ * \param Virtual resource
+ */
+void vres_Free(virtres_t* vres)
+{
+ while (vres->numlumps--)
+ Z_Free(vres->vlumps[vres->numlumps].data);
+ Z_Free(vres->vlumps);
+ Z_Free(vres);
+}
+
+/** (Debug) Prints lumps from a virtual resource into console.
+ */
+/*
+static void vres_Diag(const virtres_t* vres)
+{
+ UINT32 i;
+ for (i = 0; i < vres->numlumps; i++)
+ CONS_Printf("%s\n", vres->vlumps[i].name);
+}
+*/
+
+/** \brief Finds a lump in a given virtual resource.
+ *
+ * \param Virtual resource
+ * \param Lump name to look for
+ * \return Virtual lump if found, NULL otherwise
+ *
+ */
+virtlump_t* vres_Find(const virtres_t* vres, const char* name)
+{
+ UINT32 i;
+ for (i = 0; i < vres->numlumps; i++)
+ if (fastcmp(name, vres->vlumps[i].name))
+ return &vres->vlumps[i];
+ return NULL;
+}
diff --git a/src/w_wad.h b/src/w_wad.h
index a8be13ece29c17511a7dc5579faccdfa0789d9ad..aca67c00f3df5daafe0bf92a7d6203f147427b19 100644
--- a/src/w_wad.h
+++ b/src/w_wad.h
@@ -72,6 +72,25 @@ typedef struct
compmethod compression; // lump compression method
} lumpinfo_t;
+// =========================================================================
+// 'VIRTUAL' RESOURCES
+// =========================================================================
+
+typedef struct {
+ char name[9];
+ UINT8* data;
+ size_t size;
+} virtlump_t;
+
+typedef struct {
+ size_t numlumps;
+ virtlump_t* vlumps;
+} virtres_t;
+
+virtres_t* vres_GetMap(lumpnum_t);
+void vres_Free(virtres_t*);
+virtlump_t* vres_Find(const virtres_t*, const char*);
+
// =========================================================================
// DYNAMIC WAD LOADING
// =========================================================================
@@ -177,6 +196,7 @@ void *W_CachePatchNumPwad(UINT16 wad, UINT16 lump, INT32 tag); // return a patch
void *W_CachePatchNum(lumpnum_t lumpnum, INT32 tag); // return a patch_t
void W_UnlockCachedPatch(void *patch);
+void W_FlushCachedPatches(void);
void W_VerifyFileMD5(UINT16 wadfilenum, const char *matchmd5);
diff --git a/src/win32/win_vid.c b/src/win32/win_vid.c
index 39a60cd93b936ba3e524d18c4614a8834128a8a4..d0aab92b3e16a4d13fb4cb57039869a732bfaef1 100644
--- a/src/win32/win_vid.c
+++ b/src/win32/win_vid.c
@@ -239,6 +239,11 @@ void I_StartupGraphics(void)
if (!dedicated) graphics_started = true;
}
+void I_StartupHardwareGraphics(void)
+{
+ // oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo yeah oh yeah woo y
+}
+
// ------------------
// I_ShutdownGraphics
// Close the screen, restore previous video mode.
@@ -946,6 +951,11 @@ INT32 VID_SetMode(INT32 modenum)
return 1;
}
+void VID_CheckRenderer(void)
+{
+ // ..............
+}
+
// ========================================================================
// Free the video buffer of the last video mode,
// allocate a new buffer for the video mode to set.
diff --git a/src/y_inter.c b/src/y_inter.c
index 842bd1b287e22d7696185cdec69af5dce953aa29..be0550e72acb03a68d17bf7bd50024cf9559ce46 100644
--- a/src/y_inter.c
+++ b/src/y_inter.c
@@ -37,6 +37,10 @@
#include "m_cond.h" // condition sets
#include "lua_hook.h" // IntermissionThinker hook
+#ifdef HAVE_BLUA
+#include "lua_hud.h"
+#endif
+
#ifdef HWRENDER
#include "hardware/hw_main.h"
#endif
@@ -157,6 +161,7 @@ typedef struct
boolean usebuffer = false;
static boolean useinterpic;
+static boolean safetorender = true;
static y_buffer_t *y_buffer;
static INT32 intertic;
@@ -164,6 +169,7 @@ static INT32 tallydonetic = -1;
static INT32 endtic = -1;
intertype_t intertype = int_none;
+intertype_t intermissiontypes[NUMGAMETYPES];
static void Y_RescaleScreenBuffer(void);
static void Y_AwardCoopBonuses(void);
@@ -172,6 +178,7 @@ static void Y_CalculateCompetitionWinners(void);
static void Y_CalculateTimeRaceWinners(void);
static void Y_CalculateMatchWinners(void);
static void Y_UnloadData(void);
+static void Y_CleanupData(void);
// Stuff copy+pasted from st_stuff.c
#define ST_DrawNumFromHud(h,n) V_DrawTallNum(hudinfo[h].x, hudinfo[h].y, hudinfo[h].f, n)
@@ -318,12 +325,31 @@ void Y_IntermissionDrawer(void)
// Bonus loops
INT32 i;
- if (intertype == int_none || rendermode == render_none)
+ if (rendermode == render_none)
+ return;
+
+ if (intertype == int_none)
+ {
+#ifdef HAVE_BLUA
+ LUAh_IntermissionHUD();
+#endif
return;
+ }
if (!usebuffer)
+ // Lactozilla: Renderer switching
+ if (needpatchrecache)
+ {
+ Y_CleanupData();
+ safetorender = false;
+ }
+
+ if (!usebuffer || !safetorender)
V_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, 31);
+ if (!safetorender)
+ goto dontdrawbg;
+
if (useinterpic)
V_DrawScaledPatch(0, 0, 0, interpic);
else if (!usetile)
@@ -358,6 +384,13 @@ void Y_IntermissionDrawer(void)
else
V_DrawPatchFill(bgtile);
+#ifdef HAVE_BLUA
+ LUAh_IntermissionHUD();
+ if (!LUA_HudEnabled(hud_intermissiontally))
+ goto skiptallydrawer;
+#endif
+
+dontdrawbg:
if (intertype == int_coop)
{
INT32 bonusy;
@@ -407,14 +440,17 @@ void Y_IntermissionDrawer(void)
bonusy = 150;
// Total
- V_DrawScaledPatch(152, bonusy, 0, data.coop.ptotal);
- V_DrawTallNum(BASEVIDWIDTH - 68, bonusy + 1, 0, data.coop.total);
+ if (safetorender)
+ {
+ V_DrawScaledPatch(152, bonusy, 0, data.coop.ptotal);
+ V_DrawTallNum(BASEVIDWIDTH - 68, bonusy + 1, 0, data.coop.total);
+ }
bonusy -= (3*SHORT(tallnum[0]->height)/2) + 1;
// Draw bonuses
for (i = 3; i >= 0; --i)
{
- if (data.coop.bonuses[i].display)
+ if (data.coop.bonuses[i].display && safetorender)
{
V_DrawScaledPatch(152, bonusy, 0, data.coop.bonuspatches[i]);
V_DrawTallNum(BASEVIDWIDTH - 68, bonusy + 1, 0, data.coop.bonuses[i].points);
@@ -643,7 +679,8 @@ void Y_IntermissionDrawer(void)
char strtime[10];
// draw the header
- V_DrawScaledPatch(112, 2, 0, data.match.result);
+ if (safetorender)
+ V_DrawScaledPatch(112, 2, 0, data.match.result);
// draw the level name
V_DrawCenteredString(BASEVIDWIDTH/2, 20, 0, data.match.levelstring);
@@ -907,6 +944,12 @@ void Y_IntermissionDrawer(void)
}
}
+#ifdef HAVE_BLUA
+skiptallydrawer:
+ if (!LUA_HudEnabled(hud_intermissionmessages))
+ return;
+#endif
+
if (timer)
V_DrawCenteredString(BASEVIDWIDTH/2, 188, V_YELLOWMAP,
va("start in %d seconds", timer/TICRATE));
@@ -1169,6 +1212,8 @@ void Y_StartIntermission(void)
I_Error("endtic is dirty");
#endif
+ safetorender = true;
+
if (!multiplayer)
{
timer = 0;
@@ -1187,7 +1232,9 @@ void Y_StartIntermission(void)
timer = 1;
}
- if (gametype == GT_COOP)
+ if (intermissiontypes[gametype] != int_none)
+ intertype = intermissiontypes[gametype];
+ else if (gametype == GT_COOP)
intertype = (G_IsSpecialStage(gamemap)) ? int_spec : int_coop;
else if (gametype == GT_TEAMMATCH)
intertype = int_teammatch;
@@ -1222,20 +1269,20 @@ void Y_StartIntermission(void)
data.coop.tics = players[consoleplayer].realtime;
for (i = 0; i < 4; ++i)
- data.coop.bonuspatches[i] = W_CachePatchName(data.coop.bonuses[i].patch, PU_STATIC);
- data.coop.ptotal = W_CachePatchName("YB_TOTAL", PU_STATIC);
+ data.coop.bonuspatches[i] = W_CachePatchName(data.coop.bonuses[i].patch, PU_PATCH);
+ data.coop.ptotal = W_CachePatchName("YB_TOTAL", PU_PATCH);
// get act number
data.coop.actnum = mapheaderinfo[gamemap-1]->actnum;
// get background patches
- widebgpatch = W_CachePatchName("INTERSCW", PU_STATIC);
- bgpatch = W_CachePatchName("INTERSCR", PU_STATIC);
+ widebgpatch = W_CachePatchName("INTERSCW", PU_PATCH);
+ bgpatch = W_CachePatchName("INTERSCR", PU_PATCH);
// grab an interscreen if appropriate
if (mapheaderinfo[gamemap-1]->interscreen[0] != '#')
{
- interpic = W_CachePatchName(mapheaderinfo[gamemap-1]->interscreen, PU_STATIC);
+ interpic = W_CachePatchName(mapheaderinfo[gamemap-1]->interscreen, PU_PATCH);
useinterpic = true;
usebuffer = false;
}
@@ -1293,18 +1340,18 @@ void Y_StartIntermission(void)
Y_AwardSpecialStageBonus();
for (i = 0; i < 2; ++i)
- data.spec.bonuspatches[i] = W_CachePatchName(data.spec.bonuses[i].patch, PU_STATIC);
+ data.spec.bonuspatches[i] = W_CachePatchName(data.spec.bonuses[i].patch, PU_PATCH);
- data.spec.pscore = W_CachePatchName("YB_SCORE", PU_STATIC);
- data.spec.pcontinues = W_CachePatchName("YB_CONTI", PU_STATIC);
+ data.spec.pscore = W_CachePatchName("YB_SCORE", PU_PATCH);
+ data.spec.pcontinues = W_CachePatchName("YB_CONTI", PU_PATCH);
// get background tile
- bgtile = W_CachePatchName("SPECTILE", PU_STATIC);
+ bgtile = W_CachePatchName("SPECTILE", PU_PATCH);
// grab an interscreen if appropriate
if (mapheaderinfo[gamemap-1]->interscreen[0] != '#')
{
- interpic = W_CachePatchName(mapheaderinfo[gamemap-1]->interscreen, PU_STATIC);
+ interpic = W_CachePatchName(mapheaderinfo[gamemap-1]->interscreen, PU_PATCH);
useinterpic = true;
}
else
@@ -1316,14 +1363,14 @@ void Y_StartIntermission(void)
// get special stage specific patches
/* if (!stagefailed && ALL7EMERALDS(emeralds))
{
- data.spec.cemerald = W_CachePatchName("GOTEMALL", PU_STATIC);
+ data.spec.cemerald = W_CachePatchName("GOTEMALL", PU_PATCH);
data.spec.headx = 70;
data.spec.nowsuper = players[consoleplayer].skin
- ? NULL : W_CachePatchName("NOWSUPER", PU_STATIC);
+ ? NULL : W_CachePatchName("NOWSUPER", PU_PATCH);
}
else
{
- data.spec.cemerald = W_CachePatchName("CEMERALD", PU_STATIC);
+ data.spec.cemerald = W_CachePatchName("CEMERALD", PU_PATCH);
data.spec.headx = 48;
data.spec.nowsuper = NULL;
} */
@@ -1401,9 +1448,9 @@ void Y_StartIntermission(void)
// get RESULT header
data.match.result =
- W_CachePatchName("RESULT", PU_STATIC);
+ W_CachePatchName("RESULT", PU_PATCH);
- bgtile = W_CachePatchName("SRB2BACK", PU_STATIC);
+ bgtile = W_CachePatchName("SRB2BACK", PU_PATCH);
usetile = true;
useinterpic = false;
break;
@@ -1429,9 +1476,9 @@ void Y_StartIntermission(void)
data.match.levelstring[sizeof data.match.levelstring - 1] = '\0';
// get RESULT header
- data.match.result = W_CachePatchName("RESULT", PU_STATIC);
+ data.match.result = W_CachePatchName("RESULT", PU_PATCH);
- bgtile = W_CachePatchName("SRB2BACK", PU_STATIC);
+ bgtile = W_CachePatchName("SRB2BACK", PU_PATCH);
usetile = true;
useinterpic = false;
break;
@@ -1468,7 +1515,7 @@ void Y_StartIntermission(void)
data.match.blueflag = bmatcico;
}
- bgtile = W_CachePatchName("SRB2BACK", PU_STATIC);
+ bgtile = W_CachePatchName("SRB2BACK", PU_PATCH);
usetile = true;
useinterpic = false;
break;
@@ -1494,7 +1541,7 @@ void Y_StartIntermission(void)
data.competition.levelstring[sizeof data.competition.levelstring - 1] = '\0';
// get background tile
- bgtile = W_CachePatchName("SRB2BACK", PU_STATIC);
+ bgtile = W_CachePatchName("SRB2BACK", PU_PATCH);
usetile = true;
useinterpic = false;
break;
@@ -2032,7 +2079,8 @@ void Y_EndIntermission(void)
usebuffer = false;
}
-#define UNLOAD(x) Z_ChangeTag(x, PU_CACHE); x = NULL
+#define UNLOAD(x) if (x) {Z_ChangeTag(x, PU_CACHE);} x = NULL;
+#define CLEANUP(x) x = NULL;
//
// Y_UnloadData
@@ -2083,5 +2131,47 @@ static void Y_UnloadData(void)
//are not handled
break;
}
+}
+
+static void Y_CleanupData(void)
+{
+ // unload the background patches
+ CLEANUP(bgpatch);
+ CLEANUP(widebgpatch);
+ CLEANUP(bgtile);
+ CLEANUP(interpic);
+ switch (intertype)
+ {
+ case int_coop:
+ // unload the coop and single player patches
+ CLEANUP(data.coop.bonuspatches[3]);
+ CLEANUP(data.coop.bonuspatches[2]);
+ CLEANUP(data.coop.bonuspatches[1]);
+ CLEANUP(data.coop.bonuspatches[0]);
+ CLEANUP(data.coop.ptotal);
+ break;
+ case int_spec:
+ // unload the special stage patches
+ //CLEANUP(data.spec.cemerald);
+ //CLEANUP(data.spec.nowsuper);
+ CLEANUP(data.spec.bonuspatches[1]);
+ CLEANUP(data.spec.bonuspatches[0]);
+ CLEANUP(data.spec.pscore);
+ CLEANUP(data.spec.pcontinues);
+ break;
+ case int_match:
+ case int_race:
+ CLEANUP(data.match.result);
+ break;
+ case int_ctf:
+ CLEANUP(data.match.blueflag);
+ CLEANUP(data.match.redflag);
+ break;
+ default:
+ //without this default,
+ //int_none, int_tag, int_chaos, and int_classicrace
+ //are not handled
+ break;
+ }
}
diff --git a/src/y_inter.h b/src/y_inter.h
index 7dffbff32c3ad61643d912ec2ae4deadcbaa0918..5cf2cc1b84ee8c9ac75923cac9fc9e99481e5e6f 100644
--- a/src/y_inter.h
+++ b/src/y_inter.h
@@ -31,3 +31,4 @@ typedef enum
int_comp, // Competition
} intertype_t;
extern intertype_t intertype;
+extern intertype_t intermissiontypes[NUMGAMETYPES];
diff --git a/src/z_zone.c b/src/z_zone.c
index daad5489d32252eaf7ac116ef5c19ecd8c5bf703..5a0ff638bfd7e09512af622abf46d66565251029 100644
--- a/src/z_zone.c
+++ b/src/z_zone.c
@@ -27,6 +27,7 @@
#include "doomdef.h"
#include "doomstat.h"
+#include "r_patch.h"
#include "i_system.h" // I_GetFreeMem
#include "i_video.h" // rendermode
#include "z_zone.h"
@@ -497,6 +498,35 @@ void Z_FreeTags(INT32 lowtag, INT32 hightag)
// Utility functions
// -----------------
+// for renderer switching, free a bunch of stuff
+boolean needpatchflush = false;
+boolean needpatchrecache = false;
+
+// flush all patches from memory
+// (also frees memory tagged with PU_CACHE)
+// (which are not necessarily patches but I don't care)
+void Z_FlushCachedPatches(void)
+{
+ CONS_Debug(DBG_RENDER, "Z_FlushCachedPatches()...\n");
+ Z_FreeTag(PU_CACHE);
+ Z_FreeTag(PU_PATCH);
+ Z_FreeTag(PU_HUDGFX);
+ Z_FreeTag(PU_HWRPATCHINFO);
+ Z_FreeTag(PU_HWRMODELTEXTURE);
+ Z_FreeTag(PU_HWRCACHE);
+ Z_FreeTag(PU_HWRCACHE_UNLOCKED);
+ Z_FreeTag(PU_HWRPATCHINFO_UNLOCKED);
+}
+
+// happens before a renderer switch
+void Z_PreparePatchFlush(void)
+{
+ CONS_Debug(DBG_RENDER, "Z_PreparePatchFlush()...\n");
+#ifdef ROTSPRITE
+ R_FreeAllRotSprite();
+#endif
+}
+
// starting value of nextcleanup
#define CLEANUPCOUNT 2000
diff --git a/src/z_zone.h b/src/z_zone.h
index 635c334cf78e0565b2e9bd25f4ff075c432fc115..9e5f74343aa0b009956ad13af57fa8e01be089a0 100644
--- a/src/z_zone.h
+++ b/src/z_zone.h
@@ -43,6 +43,7 @@ enum
PU_SOUND = 11, // static while playing
PU_MUSIC = 12, // static while playing
PU_HUDGFX = 13, // static until WAD added
+ PU_PATCH = 14, // static until renderer change
PU_HWRPATCHINFO = 21, // Hardware GLPatch_t struct for OpenGL texture cache
PU_HWRPATCHCOLMIPMAP = 22, // Hardware GLMipmap_t struct colormap variation of patch
@@ -142,4 +143,10 @@ size_t Z_TagsUsage(INT32 lowtag, INT32 hightag);
char *Z_StrDup(const char *in);
#define Z_Unlock(p) (void)p // TODO: remove this now that NDS code has been removed
+// For renderer switching
+extern boolean needpatchflush;
+extern boolean needpatchrecache;
+void Z_FlushCachedPatches(void);
+void Z_PreparePatchFlush(void);
+
#endif