What changed in EDuke32, build by build

The latter is commented out, since it has to be *compiled* with script_expertmode enabled.

Related to that, it looks like out-of-bounds accesses when drawing such walls/ maskwalls or *sprites* are fixed, too. Sprites still show a stray lines on some occasions, but Valgrind doesn't complain then.

Most notably, -Wdeclaration-after-statement. This and -Wpointer-arith give some warning on linux, but this is "harmless" as it's assumed that we'll be always compiling with GCC or Clang there. Also, erratum in the "Make ksqrt take uint32_t ..." commit: hypotenuse -> squared length of the hypotenuse

-Wwrite-strings is useful to detect code where string literals and e.g. alloc'd strings are used side-by-side, potentially creating dangerous situations, or to find uses of old, non-constified APIs. However, enabling it would still flood the log with too many warnings. Also, GCC wrongly warns for initializations of char arrays.

Most differences are handled with function parameters, except that one instance checked SpriteProjectile[i].spawns for being >0 instead of >=0. The factored function always checks for >=0.

The bug was introduced with SAMESIZE_ACTOR_T enabling in r2208. This fixes being unable to read the messages in A.Dream* by zykov eddy.

Arrays inside structs must not be accessible, since they're not bound-checked by the FFI. Therefore, we flatten them into repeated scalar fields and need to write accessor functions later.

This fixes an integer overflow when a distance is calculated later.

That is, "clang -ftrapv" builds don't abort almost immediately after entering a level. There are various classes of overflow bugs, needing different handling: - Some texture mapping code was written with signed integer wrapping semantics in mind. In some places, we're able to get away with unsigned casts. - sometimes, we really need a wider range, like when calculating distances or dot products - negating INT_MIN. Here, we cast to int64_t temporarily. Note that if the result is 32-bit wide, no 64-bit code may actually need to be generated. - shifting into a signed integer's sign bit. We cast to uint32 here. - in hitscan(), at the "abyss crash prevention code" comment, it's clearly the other code that is better... This is not merely done for pedantry, but rather makes it easier to track down overflow bugs having a real impact on the game.

- hitscan & related types and constants - profiling with gethitickms - translator: eval the opening parts of block commands early - fix getbunch

For SDL 1.2 and when building on linux, the code using clock_gettime(CLOCK_MONOTINIC, ...) is taken over from SDL HG. gethitickms() is a convenience function that return milliseconds as doubles and isn't exposed in any header file, yet.

Doesn't work: indexed-color modes, gamma (at least for X11), mouse wheel, special keys like ENTER or BACKSPACE in the OSD, probably more... In build/Makefile.shared, we now have logic to autodetect an SDL2 installed in /usr/local, however OS X and Wii builds follow other Makefile code paths, it seems. Note that the matching SDL2_mixer must be used then, too. In source/jaudiolib/src/driver_sdl.c, change the #includes from <SDL/SDL_xxx.h> to "SDL_xxx.h". SDL wiki says this is the most portable way, hopefully this doesn't break builds for anyone.

Flipped reference ceilings/floors aren't handled correctly yet.

This was actually broken all the time except when ALL sectors were selected (which was what I tested incidentally when I wrote the first "fix"). D'oh!

This is to the cvar of the same name as samples/aspect.map is to r_usenewaspect.

This exposes some problems in the default/in-the-wild CONs. As usual, we'll have to retrofit sensible semantics :rolleyes:.

It's time to replace some int32s with 64-bit ints in core engine functions. The problem is that for example, the dot product is taken between vectors that may be the difference between two arbitrary points in a sector, so even if one sticks to the "no blue walls" rule, that doesn't guarantee freedom from overflows.

This was exposed by Clang with -ftrapv, which apparently also traps those.

Bang! One more invalid internals exposure squashed. Maybe one day we'll be able to call EDuke32 "stable"... Actually the offending sprite IS drawn as face sprite with shade 32 and xrepeat and yrepeat 255 for the convenience of the CON coder who will have to debug it.

Literals written out as if they were unsigned and having the highest-order bit set are all too ubiquitous, like hitscan masks for example.